Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發 >> 關於android開發 >> 手把手教你Android來去電通話自動錄音的方法，android來去

手把手教你Android來去電通話自動錄音的方法，android來去

編輯：關於android開發

手把手教你Android來去電通話自動錄音的方法，android來去


我們在使用Android手機打電話時，有時可能會需要對來去電通話自動錄音，本文就詳細講解實現Android來去電通話自動錄音的方法，大家按照文中的方法編寫程序就可以完成此功能。

       來去電自動錄音的關鍵在於如何監聽手機電話狀態的轉變：

       1）來電的狀態的轉換如下（紅色標記是我們要用到的狀態）

       空閒（IDEL）——> 響鈴（RINGING）——> 接聽（ACTIVE）——> 掛斷（經歷DISCONNECTING——DISCONNECTED）——> 空閒（IDEL） 

       或者  空閒（IDEL）——> 響鈴（RINGING）——> 拒接 ——> 空閒（IDEL）

       2）去電狀態的轉換如下

       空閒（IDEL）——> 撥號 （DIALING）——> （對方）響鈴（ALERTING） ——> 建立連接（ACTIVE）—— 掛斷（經歷DISCONNECTING——DISCONNECTED）——> 空閒（IDEL） 

       或者 空閒（IDEL）——> 撥號 （DIALING）——> （對方）響鈴（ALERTING）——> 掛斷/對方拒接 ——> 空閒（IDEL）

       下面就分別就來電和去電這兩種狀態分析並實現。

       1、先進行來電的分析和實現。

       相對去電來說，來電狀態的轉換檢測要簡單些。android api 中的PhoneStateListener 類提供了相應的方法，但我們需要覆蓋其中的 onCallStateChanged(int state, String incomingNumber) 方法即可實現來電狀態的檢測，並在此基礎上添加錄音功能即可。其中 state 參數就是各種電話狀態，到時我們將它跟下面我們要用到的狀態進行比較，若是電話處在我們想要的狀態上，則進行一系列操作，否則就不管他。想要獲取這些狀態，還需要另一個電話相關類，那就是 TelephonyManager， 該類 提供了一些電話狀態，其中我們要用到的是：TelephonyManager.CALL_STATE_IDLE（空閒）、TelephonyManager.CALL_STATE_OFFHOOK（摘機）和 TelephonyManager.CALL_STATE_RINGING（來電響鈴）這三個狀態。判別這三種狀態，可以繼承 android.telephony.PhoneStateListener 類，實現上面提到的 onCallStateChanged(int state, String incomingNumber) 方法，請看如下代碼：

Java代碼
  1. public class TelListener extends PhoneStateListener {     
  2.      
  3.     @Override     
  4.     public void onCallStateChanged(int state, String incomingNumber) {     
  5.         super.onCallStateChanged(state, incomingNumber);     
  6.      
  7.         switch (state) {     
  8.         case TelephonyManager.CALL_STATE_IDLE: // 空閒狀態，即無來電也無去電     
  9.             Log.i("TelephoneState", "IDLE");     
  10.             //此處添加一系列功能代碼    
  11.             break;     
  12.         case TelephonyManager.CALL_STATE_RINGING: // 來電響鈴     
  13.             Log.i("TelephoneState", "RINGING");     
  14.             //此處添加一系列功能代碼    
  15.             break;     
  16.         case TelephonyManager.CALL_STATE_OFFHOOK: // 摘機，即接通    
  17.             Log.i("TelephoneState", "OFFHOOK");     
  18.             //此處添加一系列功能代碼    
  19.             break;     
  20.         }     
  21.      
  22.         Log.i("TelephoneState", String.valueOf(incomingNumber));     
  23.     }     
  24.      
  25. }  

       有了以上來電狀態監聽代碼還不足以實現監聽功能，還需要在我們的一個Activity或者Service中實現監聽，方法很簡單，代碼如下：

Java代碼
  1. /**   
  2. * 在activity 或者 service中加入如下代碼，以實現來電狀態監聽   
  3. */    
  4. TelephonyManager telMgr = (TelephonyManager)context.getSystemService(    
  5.                 Context.TELEPHONY_SERVICE);    
  6.         telMgr.listen(new TelListener(), PhoneStateListener.LISTEN_CALL_STATE);   

       這樣就實現了來電狀態監聽功能，但要能夠在設備中跑起來，這還不夠，它還需要兩個獲取手機電話狀態的權限：

XML/HTML代碼
  1. <uses-permission android:name="android.permission.READ_PHONE_STATE" />    
  2. <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />   

       這樣的話就可以跑起來了。

       說到這，我想如果你可以實現錄音功能的話，在此基礎上實現來電自動錄音就應該沒什麼問題了，不過請容我簡單羅嗦幾句。既然是來電，那麼要想錄音的話，那麼應該就是在監聽到 TelephonyManager.CALL_STATE_OFFHOOK 的狀態時開啟錄音機開始錄音， 在監聽到TelephonyManager.CALL_STATE_IDLE 的狀態時關閉錄音機停止錄音。這樣，來電錄音功能就完成了，不要忘記錄音功能同樣需要權限：

XML/HTML代碼
  1. <uses-permission android:name="android.permission.RECORD_AUDIO"/>     
  2.      
  3. <!-- 要存儲文件或者創建文件夾的話還需要以下兩個權限 -->     
  4. <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>     
  5. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  

       2、介紹完了來電自動錄音，下面就來介紹去電自動錄音的實現方法。

       上面說過，相比來電狀態的監聽，去電的要麻煩些，甚至這種方法不是通用的，這個主要是因為android api 中沒有提供去電狀態監聽的相應類和方法（也許我剛接觸，沒有找到）。剛開始網上搜索了一通也沒有找到對應的解決方法，大多是 來電監聽的，也就是上面的方法。不過中途發現一篇博文（後來就搜不到了），記得是查詢系統日志的方式，從中找到去電過程中的各個狀態的關鍵詞。無奈之中，最終妥協了此方法。

       我的（聯想A65上的）去電日志內容如下：

       過濾關鍵詞為 mforeground

Java代碼
  1. 01-06 16:29:54.225: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  2. 01-06 16:29:54.245: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  3. 01-06 16:29:54.631: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  4. 01-06 16:29:54.645: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  5. 01-06 16:29:54.742: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  6. 01-06 16:29:54.766: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  7. 01-06 16:29:54.873: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  8. 01-06 16:29:54.877: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  9. 01-06 16:29:55.108: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  10. 01-06 16:29:55.125: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DIALING    
  11. 01-06 16:29:57.030: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : ACTIVE    
  12. 01-06 16:29:57.155: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : ACTIVE    
  13. 01-06 16:29:57.480: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : ACTIVE    
  14. 01-06 16:29:57.598: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : ACTIVE    
  15. 01-06 16:29:59.319: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : DISCONNECTING    
  16. 01-06 16:29:59.373: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : DISCONNECTING    
  17. 01-06 16:30:00.392: D/InCallScreen(251): - onDisconnect: currentlyIdle:true ; mForegroundCall.getState():DISCONNECTED    
  18. 01-06 16:30:00.399: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): - onDisconnect: currentlyIdle:true ; mForegroundCall.getState():DISCONNECTED    
  19. 01-06 16:30:01.042: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : IDLE    
  20. 01-06 16:30:01.070: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : IDLE    
  21. 01-06 16:30:01.558: D/InCallScreen(251): onPhoneStateChanged: mForegroundCall.getState() : IDLE    
  22. 01-06 16:30:01.572: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mForegroundCall.getState() : IDLE   

       過濾關鍵詞  mbackground

Java代碼
  1. 01-06 16:29:54.226: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  2. 01-06 16:29:54.256: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  3. 01-06 16:29:54.638: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  4. 01-06 16:29:54.652: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  5. 01-06 16:29:54.743: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  6. 01-06 16:29:54.770: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  7. 01-06 16:29:54.875: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  8. 01-06 16:29:54.882: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  9. 01-06 16:29:55.109: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  10. 01-06 16:29:55.142: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  11. 01-06 16:29:57.031: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  12. 01-06 16:29:57.160: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  13. 01-06 16:29:57.481: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  14. 01-06 16:29:57.622: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  15. 01-06 16:29:59.319: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  16. 01-06 16:29:59.373: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  17. 01-06 16:30:01.042: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  18. 01-06 16:30:01.070: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  19. 01-06 16:30:01.559: D/InCallScreen(251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE    
  20. 01-06 16:30:01.573: V/LogInfo OutGoing Call(2492): D/InCallScreen(  251): onPhoneStateChanged: mBackgroundCall.getState() : IDLE   

       從上面的日志可以看到，每一行的末尾的大寫英文詞就是去電的狀態，狀態說明如下：

       DIALING 撥號，對方還未響鈴
       ACTIVE   對方接通，通話建立
       DISCONNECTING 通話斷開時
       DISCONNECTED  通話已斷開，可以認為是掛機了

       由於我撥打的是10010，沒有響鈴過程（電腦自動接通的夠快），還少了一個狀態，狀態是ALERTING ，這個就是對方正在響鈴的狀態。

       有了這幾個去電狀態就好辦了，現在我們要做的就是讀取系統日志，然後找到這些狀態，提取的關鍵詞就是上面提到的 mforeground（前台通話狀態） 和 mbackground （後台通話狀態）（可能不一樣的設備生成的不一樣，根據自己具體設備設置，這裡只提取前台的），如果讀取的這一行日志中 包含 mforground ，再看看是否包含上面的狀態的單詞。既然說的如此，那麼看看讀取系統日志的代碼吧。

Java代碼
  1. package com.sdvdxl.phonerecorder;    
  2.     
  3. import java.io.BufferedReader;    
  4. import java.io.IOException;    
  5. import java.io.InputStream;    
  6. import java.io.InputStreamReader;    
  7.     
  8. import com.sdvdxl.outgoingcall.OutgoingCallState;    
  9.     
  10. import android.content.Context;    
  11. import android.content.Intent;    
  12. import android.util.Log;    
  13.     
  14. /**   
  15.  *    
  16.  * @author sdvdxl   
  17.  *  找到 日志中的   
  18.  *  onPhoneStateChanged: mForegroundCall.getState() 這個是前台呼叫狀態  
  19.  *  mBackgroundCall.getState() 後台電話   
  20.  *  若 是 DIALING 則是正在撥號，等待建立連接，但對方還沒有響鈴，   
  21.  *  ALERTING 呼叫成功，即對方正在響鈴，   
  22.  *  若是 ACTIVE 則已經接通   
  23.  *  若是 DISCONNECTED 則本號碼呼叫已經掛斷   
  24.  *  若是 IDLE 則是處於 空閒狀態   
  25.  *     
  26.  */    
  27. public class ReadLog extends Thread {    
  28.     private Context ctx;    
  29.     private int logCount;    
  30.         
  31.     private static final String TAG = "LogInfo OutGoing Call";    
  32.         
  33.     /**   
  34.      *  前後台電話   
  35.      * @author sdvdxl   
  36.      *     
  37.      */    
  38.     private static class CallViewState {    
  39.         public static final String FORE_GROUND_CALL_STATE = "mForeground";    
  40.     }    
  41.         
  42.     /**   
  43.      * 呼叫狀態   
  44.      * @author sdvdxl   
  45.      *   
  46.      */    
  47.     private static class CallState {    
  48.         public static final String DIALING = "DIALING";    
  49.         public static final String ALERTING = "ALERTING";    
  50.         public static final String ACTIVE = "ACTIVE";    
  51.         public static final String IDLE = "IDLE";    
  52.         public static final String DISCONNECTED = "DISCONNECTED";    
  53.     }    
  54.         
  55.     public ReadLog(Context ctx) {    
  56.         this.ctx = ctx;    
  57.     }    
  58.         
  59.     /**   
  60.      * 讀取Log流   
  61.      * 取得呼出狀態的log   
  62.      * 從而得到轉換狀態   
  63.      */    
  64.     @Override    
  65.     public void run() {    
  66.         Log.d(TAG, "開始讀取日志記錄");    
  67.             
  68.         String[] catchParams = {"logcat", "InCallScreen *:s"};    
  69.         String[] clearParams = {"logcat", "-c"};    
  70.             
  71.         try {    
  72.             Process process=Runtime.getRuntime().exec(catchParams);    
  73.             InputStream is = process.getInputStream();    
  74.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));    
  75.                 
  76.             String line = null;    
  77.             while ((line=reader.readLine())!=null) {    
  78.                 logCount++;    
  79.                 //輸出所有    
  80.             Log.v(TAG, line);    
  81.                     
  82.                 //日志超過512條就清理    
  83.                 if (logCount>512) {    
  84.                     //清理日志    
  85.                     Runtime.getRuntime().exec(clearParams)    
  86.                         .destroy();//銷毀進程，釋放資源    
  87.                     logCount = 0;    
  88.                     Log.v(TAG, "-----------清理日志---------------");    
  89.                 }       
  90.                     
  91.                 /*---------------------------------前台呼叫-----------------------*/    
  92.                 //空閒    
  93.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  94.                         && line.contains(ReadLog.CallState.IDLE)) {    
  95.                     Log.d(TAG, ReadLog.CallState.IDLE);    
  96.                 }    
  97.                     
  98.                 //正在撥號，等待建立連接，即已撥號，但對方還沒有響鈴，    
  99.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  100.                         && line.contains(ReadLog.CallState.DIALING)) {    
  101.                     Log.d(TAG, ReadLog.CallState.DIALING);    
  102.                 }    
  103.                     
  104.                 //呼叫對方 正在響鈴    
  105.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  106.                         && line.contains(ReadLog.CallState.ALERTING)) {    
  107.                     Log.d(TAG, ReadLog.CallState.ALERTING);    
  108.                 }    
  109.                     
  110.                 //已接通，通話建立    
  111.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  112.                         && line.contains(ReadLog.CallState.ACTIVE)) {    
  113.                     Log.d(TAG, ReadLog.CallState.ACTIVE);    
  114.                 }    
  115.                     
  116.                 //斷開連接，即掛機    
  117.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  118.                         && line.contains(ReadLog.CallState.DISCONNECTED)) {    
  119.                     Log.d(TAG, ReadLog.CallState.DISCONNECTED);    
  120.                 }    
  121.                     
  122.             } //END while    
  123.                 
  124.         } catch (IOException e) {    
  125.             e.printStackTrace();    
  126.         } //END try-catch    
  127.     } //END run    
  128. } //END class ReadLog   

       以上代碼中，之所以用線程，是為了防止讀取日志過程中阻滯主方法的其他方法的執行，影響到程序捕捉對應的電話狀態。

       好了，捕捉到了去電過程中各個狀態的轉變，那麼，如何通知給程序呢，我采用的方法是捕獲後立馬給系統發送廣播，然後程序進行廣播接收，接收後再處理錄音事件。要發送廣播，就要發送一個唯一的廣播，為此，建立如下類：

Java代碼
  1. package com.sdvdxl.outgoingcall;    
  2.     
  3. import com.sdvdxl.phonerecorder.ReadLog;    
  4.     
  5. import android.content.Context;    
  6. import android.util.Log;    
  7.     
  8. public class OutgoingCallState {    
  9.     Context ctx;    
  10.     public OutgoingCallState(Context ctx) {    
  11.         this.ctx = ctx;    
  12.     }    
  13.         
  14.     /**   
  15.      * 前台呼叫狀態   
  16.      * @author sdvdxl   
  17.      *   
  18.      */    
  19.     public static final class ForeGroundCallState {    
  20.         public static final String DIALING =     
  21.                 "com.sdvdxl.phonerecorder.FORE_GROUND_DIALING";    
  22.         public static final String ALERTING =     
  23.                 "com.sdvdxl.phonerecorder.FORE_GROUND_ALERTING";    
  24.         public static final String ACTIVE =     
  25.                 "com.sdvdxl.phonerecorder.FORE_GROUND_ACTIVE";    
  26.         public static final String IDLE =     
  27.                 "com.sdvdxl.phonerecorder.FORE_GROUND_IDLE";    
  28.         public static final String DISCONNECTED =     
  29.                 "com.sdvdxl.phonerecorder.FORE_GROUND_DISCONNECTED";    
  30.     }    
  31.         
  32.     /**   
  33.      * 開始監聽呼出狀態的轉變，   
  34.      * 並在對應狀態發送廣播   
  35.      */    
  36.     public void startListen() {    
  37.         new ReadLog(ctx).start();    
  38.         Log.d("Recorder", "開始監聽呼出狀態的轉變，並在對應狀態發送廣播");    
  39.     }    
  40.         
  41. }   

       程序需要讀取系統日志權限：

XML/HTML代碼
  1. <uses-permission android:name="android.permission.READ_LOGS"/>   

       然後，在讀取日志的類中檢測到去電各個狀態的地方發送一個廣播，那麼，讀取日志的完整代碼如下：

Java代碼
  1. package com.sdvdxl.phonerecorder;    
  2.     
  3. import java.io.BufferedReader;    
  4. import java.io.IOException;    
  5. import java.io.InputStream;    
  6. import java.io.InputStreamReader;    
  7.     
  8. import com.sdvdxl.outgoingcall.OutgoingCallState;    
  9.     
  10. import android.content.Context;    
  11. import android.content.Intent;    
  12. import android.util.Log;    
  13.     
  14. /**   
  15.  *    
  16.  * @author mrloong   
  17.  *  找到 日志中的   
  18.  *  onPhoneStateChanged: mForegroundCall.getState() 這個是前台呼叫狀態  
  19.  *  mBackgroundCall.getState() 後台電話   
  20.  *  若 是 DIALING 則是正在撥號，等待建立連接，但對方還沒有響鈴，   
  21.  *  ALERTING 呼叫成功，即對方正在響鈴，   
  22.  *  若是 ACTIVE 則已經接通   
  23.  *  若是 DISCONNECTED 則本號碼呼叫已經掛斷   
  24.  *  若是 IDLE 則是處於 空閒狀態   
  25.  *     
  26.  */    
  27. public class ReadLog extends Thread {    
  28.     private Context ctx;    
  29.     private int logCount;    
  30.         
  31.     private static final String TAG = "LogInfo OutGoing Call";    
  32.         
  33.     /**   
  34.      *  前後台電話   
  35.      * @author sdvdxl   
  36.      *     
  37.      */    
  38.     private static class CallViewState {    
  39.         public static final String FORE_GROUND_CALL_STATE = "mForeground";    
  40.     }    
  41.         
  42.     /**   
  43.      * 呼叫狀態   
  44.      * @author sdvdxl   
  45.      *   
  46.      */    
  47.     private static class CallState {    
  48.         public static final String DIALING = "DIALING";    
  49.         public static final String ALERTING = "ALERTING";    
  50.         public static final String ACTIVE = "ACTIVE";    
  51.         public static final String IDLE = "IDLE";    
  52.         public static final String DISCONNECTED = "DISCONNECTED";    
  53.     }    
  54.         
  55.     public ReadLog(Context ctx) {    
  56.         this.ctx = ctx;    
  57.     }    
  58.         
  59.     /**   
  60.      * 讀取Log流   
  61.      * 取得呼出狀態的log   
  62.      * 從而得到轉換狀態   
  63.      */    
  64.     @Override    
  65.     public void run() {    
  66.         Log.d(TAG, "開始讀取日志記錄");    
  67.             
  68.         String[] catchParams = {"logcat", "InCallScreen *:s"};    
  69.         String[] clearParams = {"logcat", "-c"};    
  70.             
  71.         try {    
  72.             Process process=Runtime.getRuntime().exec(catchParams);    
  73.             InputStream is = process.getInputStream();    
  74.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));    
  75.                 
  76.             String line = null;    
  77.             while ((line=reader.readLine())!=null) {    
  78.                 logCount++;    
  79.                 //輸出所有    
  80.             Log.v(TAG, line);    
  81.                     
  82.                 //日志超過512條就清理    
  83.                 if (logCount>512) {    
  84.                     //清理日志    
  85.                     Runtime.getRuntime().exec(clearParams)    
  86.                         .destroy();//銷毀進程，釋放資源    
  87.                     logCount = 0;    
  88.                     Log.v(TAG, "-----------清理日志---------------");    
  89.                 }       
  90.                     
  91.                 /*---------------------------------前台呼叫-----------------------*/    
  92.                 //空閒    
  93.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  94.                         && line.contains(ReadLog.CallState.IDLE)) {    
  95.                     Log.d(TAG, ReadLog.CallState.IDLE);    
  96.                 }    
  97.                     
  98.                 //正在撥號，等待建立連接，即已撥號，但對方還沒有響鈴，    
  99.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  100.                         && line.contains(ReadLog.CallState.DIALING)) {    
  101.                     //發送廣播    
  102.                     Intent dialingIntent = new Intent();    
  103.                     dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.DIALING);    
  104.                     ctx.sendBroadcast(dialingIntent);    
  105.                         
  106.                     Log.d(TAG, ReadLog.CallState.DIALING);    
  107.                 }    
  108.                     
  109.                 //呼叫對方 正在響鈴    
  110.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  111.                         && line.contains(ReadLog.CallState.ALERTING)) {    
  112.                     //發送廣播    
  113.                     Intent dialingIntent = new Intent();    
  114.                     dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.ALERTING);    
  115.                     ctx.sendBroadcast(dialingIntent);    
  116.                         
  117.                     Log.d(TAG, ReadLog.CallState.ALERTING);    
  118.                 }    
  119.                     
  120.                 //已接通，通話建立    
  121.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  122.                         && line.contains(ReadLog.CallState.ACTIVE)) {    
  123.                     //發送廣播    
  124.                     Intent dialingIntent = new Intent();    
  125.                     dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.ACTIVE);    
  126.                     ctx.sendBroadcast(dialingIntent);    
  127.                         
  128.                     Log.d(TAG, ReadLog.CallState.ACTIVE);    
  129.                 }    
  130.                     
  131.                 //斷開連接，即掛機    
  132.                 if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)    
  133.                         && line.contains(ReadLog.CallState.DISCONNECTED)) {    
  134.                     //發送廣播    
  135.                     Intent dialingIntent = new Intent();    
  136.                     dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.DISCONNECTED);    
  137.                     ctx.sendBroadcast(dialingIntent);    
  138.                         
  139.                     Log.d(TAG, ReadLog.CallState.DISCONNECTED);    
  140.                 }    
  141.                     
  142.             } //END while    
  143.                 
  144.         } catch (IOException e) {    
  145.             e.printStackTrace();    
  146.         } //END try-catch    
  147.     } //END run    
  148. } //END class ReadLog   

       發送了廣播，那麼就要有接收者，定義接收者如下（關於錄音機的代碼可以先忽略）：

Java代碼
  1. package com.sdvdxl.phonerecorder;    
  2.     
  3. import android.content.BroadcastReceiver;    
  4. import android.content.Context;    
  5. import android.content.Intent;    
  6. import android.util.Log;    
  7.     
  8. import com.sdvdxl.outgoingcall.OutgoingCallState;    
  9.     
  10. public class OutgoingCallReciver extends BroadcastReceiver {    
  11.     static final String TAG = "Recorder";    
  12.     private MyRecorder recorder;    
  13.         
  14.     public OutgoingCallReciver() {    
  15.         recorder = new MyRecorder();    
  16.     }    
  17.         
  18.     public  OutgoingCallReciver (MyRecorder recorder) {    
  19.         this.recorder = recorder;    
  20.     }    
  21.         
  22.     @Override    
  23.     public void onReceive(Context ctx, Intent intent) {    
  24.         String phoneState = intent.getAction();    
  25.             
  26.         if (phoneState.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {    
  27.             String phoneNum = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);//撥出號碼    
  28.             recorder.setPhoneNumber(phoneNum);    
  29.             recorder.setIsCommingNumber(false);    
  30.             Log.d(TAG, "設置為去電狀態");    
  31.             Log.d(TAG, "去電狀態 呼叫：" + phoneNum);    
  32.         }    
  33.             
  34.         if (phoneState.equals(OutgoingCallState.ForeGroundCallState.DIALING)) {    
  35.             Log.d(TAG, "正在撥號...");    
  36.         }    
  37.             
  38.         if (phoneState.equals(OutgoingCallState.ForeGroundCallState.ALERTING)) {    
  39.             Log.d(TAG, "正在呼叫...");    
  40.         }    
  41.             
  42.         if (phoneState.equals(OutgoingCallState.ForeGroundCallState.ACTIVE)) {    
  43.             if (!recorder.isCommingNumber() && !recorder.isStarted()) {    
  44.                 Log.d(TAG, "去電已接通 啟動錄音機");    
  45.                 recorder.start();    
  46.                     
  47.             }    
  48.         }    
  49.             
  50.         if (phoneState.equals(OutgoingCallState.ForeGroundCallState.DISCONNECTED)) {    
  51.             if (!recorder.isCommingNumber() && recorder.isStarted()) {    
  52.                 Log.d(TAG, "已掛斷 關閉錄音機");    
  53.                 recorder.stop();    
  54.             }    
  55.         }    
  56.     }    
  57.     
  58. }   

       其中有這麼一段代碼：

Java代碼
  1. String phoneState = intent.getAction();     
  2.              
  3.         if (phoneState.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {     
  4.             String phoneNum = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);//撥出號碼     
  5.             recorder.setPhoneNumber(phoneNum);     
  6.             recorder.setIsCommingNumber(false);     
  7.             Log.d(TAG, "設置為去電狀態");     
  8.             Log.d(TAG, "去電狀態 呼叫：" + phoneNum);     
  9.         }   

       這裡是接收系統發出的廣播，用於接收去電廣播。這樣，就獲得了去電狀態。

       3、有了以上主要代碼，可以說，來去電監聽功能算是完成了，下面創建一個service來運行監聽：

Java代碼
  1. package com.sdvdxl.service;    
  2.     
  3. import android.app.Service;    
  4. import android.content.Context;    
  5. import android.content.Intent;    
  6. import android.content.IntentFilter;    
  7. import android.os.IBinder;    
  8. import android.telephony.PhoneStateListener;    
  9. import android.telephony.TelephonyManager;    
  10. import android.util.Log;    
  11. import android.widget.Toast;    
  12.     
  13. import com.sdvdxl.outgoingcall.OutgoingCallState;    
  14. import com.sdvdxl.phonerecorder.MyRecorder;    
  15. import com.sdvdxl.phonerecorder.OutgoingCallReciver;    
  16. import com.sdvdxl.phonerecorder.TelListener;    
  17.     
  18. public class PhoneCallStateService extends Service {    
  19.     private OutgoingCallState outgoingCallState;    
  20.     private OutgoingCallReciver outgoingCallReciver;    
  21.     private MyRecorder recorder;    
  22.         
  23.     @Override    
  24.     public void onCreate() {    
  25.         super.onCreate();    
  26.             
  27.         //------以下應放在onStartCommand中，但2.3.5以下版本不會因service重新啟動而重新調用--------    
  28.         //監聽電話狀態，如果是打入且接聽 或者 打出 則開始自動錄音    
  29.         //通話結束，保存文件到外部存儲器上    
  30.         Log.d("Recorder", "正在監聽中...");    
  31.         recorder = new MyRecorder();    
  32.         outgoingCallState = new OutgoingCallState(this);    
  33.         outgoingCallReciver = new OutgoingCallReciver(recorder);    
  34.         outgoingCallState.startListen();    
  35.         Toast.makeText(this, "服務已啟動", Toast.LENGTH_LONG).show();    
  36.             
  37.         //去電    
  38.         IntentFilter outgoingCallFilter = new IntentFilter();    
  39.         outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.IDLE);    
  40.         outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.DIALING);    
  41.         outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.ALERTING);    
  42.         outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.ACTIVE);    
  43.         outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.DISCONNECTED);    
  44.             
  45.         outgoingCallFilter.addAction("android.intent.action.PHONE_STATE");    
  46.         outgoingCallFilter.addAction("android.intent.action.NEW_OUTGOING_CALL");    
  47.             
  48.         //注冊接收者    
  49.         registerReceiver(outgoingCallReciver, outgoingCallFilter);    
  50.             
  51.         //來電    
  52.         TelephonyManager telmgr = (TelephonyManager)getSystemService(    
  53.                 Context.TELEPHONY_SERVICE);    
  54.         telmgr.listen(new TelListener(recorder), PhoneStateListener.LISTEN_CALL_STATE);    
  55.             
  56.             
  57.     }    
  58.         
  59.     @Override    
  60.     public IBinder onBind(Intent intent) {    
  61.         // TODO Auto-generated method stub    
  62.         return null;    
  63.     }    
  64.     
  65.     @Override    
  66.     public void onDestroy() {    
  67.         super.onDestroy();    
  68.         unregisterReceiver(outgoingCallReciver);    
  69.         Toast.makeText(    
  70.                 this, "已關閉電話監聽服務", Toast.LENGTH_LONG)    
  71.                 .show();    
  72.         Log.d("Recorder", "已關閉電話監聽服務");    
  73.     }    
  74.     
  75.     @Override    
  76.     public int onStartCommand(Intent intent, int flags, int startId) {    
  77.             
  78.         return START_STICKY;    
  79.     }    
  80.     
  81. }   

       注冊以下service：

XML/HTML代碼
  1. <service android:name="com.sdvdxl.service.PhoneCallStateService" />  

       到此為止，來去電狀態的監聽功能算是完成了，剩下一個錄音機，附上錄音機代碼如下：

Java代碼
  1. package com.sdvdxl.phonerecorder;    
  2.     
  3. import java.io.File;    
  4. import java.io.IOException;    
  5. import java.text.SimpleDateFormat;    
  6. import java.util.Date;    
  7.     
  8. import android.media.MediaRecorder;    
  9. import android.os.Environment;    
  10. import android.util.Log;    
  11.     
  12. public class MyRecorder {    
  13.     private String phoneNumber;    
  14.     private MediaRecorder mrecorder;    
  15.     private boolean started = false; //錄音機是否已經啟動    
  16.     private boolean isCommingNumber = false;//是否是來電    
  17.     private String TAG = "Recorder";    
  18.         
  19.         
  20.     public MyRecorder(String phoneNumber) {    
  21.         this.setPhoneNumber(phoneNumber);    
  22.     }    
  23.         
  24.     public MyRecorder() {    
  25.     }    
  26.     
  27.     public void start() {    
  28.         started = true;    
  29.         mrecorder = new MediaRecorder();    
  30.             
  31.         File recordPath = new File(    
  32.                 Environment.getExternalStorageDirectory()    
  33.                 , "/My record");     
  34.         if (!recordPath.exists()) {    
  35.             recordPath.mkdirs();    
  36.             Log.d("recorder", "創建目錄");    
  37.         }    
  38.             
  39.         String callDir = "呼出";    
  40.         if (isCommingNumber) {    
  41.             callDir = "呼入";    
  42.         }    
  43.         String fileName = callDir + "-" + phoneNumber + "-"     
  44.                 + new SimpleDateFormat("yy-MM-dd_HH-mm-ss")    
  45.                     .format(new Date(System.currentTimeMillis())) + ".mp3";//實際是3gp    
  46.         File recordName = new File(recordPath, fileName);    
  47.             
  48.         try {    
  49.             recordName.createNewFile();    
  50.             Log.d("recorder", "創建文件" + recordName.getName());    
  51.         } catch (IOException e) {    
  52.             e.printStackTrace();    
  53.         }    
  54.             
  55.         mrecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);    
  56.         mrecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);    
  57.         mrecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);    
  58.             
  59.         mrecorder.setOutputFile(recordName.getAbsolutePath());    
  60.             
  61.         try {    
  62.             mrecorder.prepare();    
  63.         } catch (IllegalStateException e) {    
  64.             e.printStackTrace();    
  65.         } catch (IOException e) {    
  66.             e.printStackTrace();    
  67.         }    
  68.         mrecorder.start();    
  69.         started = true;    
  70.         Log.d(TAG , "錄音開始");    
  71.     }    
  72.         
  73.     public void stop() {    
  74.         try {    
  75.             if (mrecorder!=null) {    
  76.                 mrecorder.stop();    
  77.                 mrecorder.release();    
  78.                 mrecorder = null;    
  79.             }    
  80.             started = false;    
  81.         } catch (IllegalStateException e) {    
  82.             e.printStackTrace();    
  83.         }    
  84.             
  85.             
  86.         Log.d(TAG , "錄音結束");    
  87.     }    
  88.         
  89.     public void pause() {    
  90.             
  91.     }    
  92.     
  93.     public String getPhoneNumber() {    
  94.         return phoneNumber;    
  95.     }    
  96.     
  97.     public void setPhoneNumber(String phoneNumber) {    
  98.         this.phoneNumber = phoneNumber;    
  99.     }    
  100.     
  101.     public boolean isStarted() {    
  102.         return started;    
  103.     }    
  104.     
  105.     public void setStarted(boolean hasStarted) {    
  106.         this.started = hasStarted;    
  107.     }    
  108.     
  109.     public boolean isCommingNumber() {    
  110.         return isCommingNumber;    
  111.     }    
  112.     
  113.     public void setIsCommingNumber(boolean isCommingNumber) {    
  114.         this.isCommingNumber = isCommingNumber;    
  115.     }    
  116.     
  117. }   

       到此，來去電通話自動錄音的所有功能就完成了，大家可以自己試著編寫並實現。

  1. 上一頁:
  2. 下一頁:
關於android開發
開發入門初級開發中級開發高級開發關於android開發
相關文章
熱門文章
App單個頁面的最佳文本框個數是多少個？，app文本框個數 Android組件式開發（2）——實現網格布局的RadioButton矩陣 谷歌官方SwipeRefreshLayout下拉刷新的用法。，swiperefreshlayout 兩個activity之間傳遞數據用startActivityForResult方法。，startactivityresult 安卓動態調試七種武器之孔雀翎 – Ida Pro，安卓ida 手機影音2--軟件架構分析，影音2--架構分析
Android第三方開源對話消息提示框：SweetAlertDialog（sweet-alert-dialog），

Android第三方開源對話消息提示框：SweetAlertDialog
Android中手機錄屏並轉換GIF的兩種方式，android錄屏

Android中手機錄屏並轉換GIF的兩種方式，android錄屏之前在
Android中的普通對話框、單選對話框、多選對話框、帶Icon的對話框、以及自定義Adapter和自定義View對話框詳解

Android中的普通對話框、單選對話框、多選對話框、帶Icon的對話框
nagios分組出圖代碼實現講解[1]

nagios分組出圖代碼實現講解[1]一、背景 鑒於zabbix和ca
閱讀排行版
Copyright © Android教程網 All Rights Reserved