手把手教你Android来去电通话自动录音的方法

时间：2023-02-14 18:13:16

我们在使用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. @Override
  3. public void onCallStateChanged(int state, String incomingNumber) {
  4. super.onCallStateChanged(state, incomingNumber);
  5. switch (state) {
  6. case TelephonyManager.CALL_STATE_IDLE: // 空闲状态，即无来电也无去电
  7. Log.i("TelephoneState", "IDLE");
  8. //此处添加一系列功能代码
  9. break;
  10. case TelephonyManager.CALL_STATE_RINGING: // 来电响铃
  11. Log.i("TelephoneState", "RINGING");
  12. //此处添加一系列功能代码
  13. break;
  14. case TelephonyManager.CALL_STATE_OFFHOOK: // 摘机，即接通
  15. Log.i("TelephoneState", "OFFHOOK");
  16. //此处添加一系列功能代码
  17. break;
  18. }
  19. Log.i("TelephoneState", String.valueOf(incomingNumber));
  20. }
  21. }

有了以上来电状态监听代码还不足以实现监听功能，还需要在我们的一个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. <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
  4. <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. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import com.sdvdxl.outgoingcall.OutgoingCallState;
  7. import android.content.Context;
  8. import android.content.Intent;
  9. import android.util.Log;
  10. /**
  11. *
  12. * @author sdvdxl
  13. *  找到 日志中的
  14. *  onPhoneStateChanged: mForegroundCall.getState() 这个是前台呼叫状态
  15. *  mBackgroundCall.getState() 后台电话
  16. *  若 是 DIALING 则是正在拨号，等待建立连接，但对方还没有响铃，
  17. *  ALERTING 呼叫成功，即对方正在响铃，
  18. *  若是 ACTIVE 则已经接通
  19. *  若是 DISCONNECTED 则本号码呼叫已经挂断
  20. *  若是 IDLE 则是处于 空闲状态
  21. *
  22. */
  23. public class ReadLog extends Thread {
  24. private Context ctx;
  25. private int logCount;
  26. private static final String TAG = "LogInfo OutGoing Call";
  27. /**
  28. *  前后台电话
  29. * @author sdvdxl
  30. *
  31. */
  32. private static class CallViewState {
  33. public static final String FORE_GROUND_CALL_STATE = "mForeground";
  34. }
  35. /**
  36. * 呼叫状态
  37. * @author sdvdxl
  38. *
  39. */
  40. private static class CallState {
  41. public static final String DIALING = "DIALING";
  42. public static final String ALERTING = "ALERTING";
  43. public static final String ACTIVE = "ACTIVE";
  44. public static final String IDLE = "IDLE";
  45. public static final String DISCONNECTED = "DISCONNECTED";
  46. }
  47. public ReadLog(Context ctx) {
  48. this.ctx = ctx;
  49. }
  50. /**
  51. * 读取Log流
  52. * 取得呼出状态的log
  53. * 从而得到转换状态
  54. */
  55. @Override
  56. public void run() {
  57. Log.d(TAG, "开始读取日志记录");
  58. String[] catchParams = {"logcat", "InCallScreen *:s"};
  59. String[] clearParams = {"logcat", "-c"};
  60. try {
  61. Process process=Runtime.getRuntime().exec(catchParams);
  62. InputStream is = process.getInputStream();
  63. BufferedReader reader = new BufferedReader(new InputStreamReader(is));
  64. String line = null;
  65. while ((line=reader.readLine())!=null) {
  66. logCount++;
  67. //输出所有
  68. Log.v(TAG, line);
  69. //日志超过512条就清理
  70. if (logCount>512) {
  71. //清理日志
  72. Runtime.getRuntime().exec(clearParams)
  73. .destroy();//销毁进程，释放资源
  74. logCount = 0;
  75. Log.v(TAG, "-----------清理日志---------------");
  76. }
  77. /*---------------------------------前台呼叫-----------------------*/
  78. //空闲
  79. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  80. && line.contains(ReadLog.CallState.IDLE)) {
  81. Log.d(TAG, ReadLog.CallState.IDLE);
  82. }
  83. //正在拨号，等待建立连接，即已拨号，但对方还没有响铃，
  84. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  85. && line.contains(ReadLog.CallState.DIALING)) {
  86. Log.d(TAG, ReadLog.CallState.DIALING);
  87. }
  88. //呼叫对方 正在响铃
  89. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  90. && line.contains(ReadLog.CallState.ALERTING)) {
  91. Log.d(TAG, ReadLog.CallState.ALERTING);
  92. }
  93. //已接通，通话建立
  94. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  95. && line.contains(ReadLog.CallState.ACTIVE)) {
  96. Log.d(TAG, ReadLog.CallState.ACTIVE);
  97. }
  98. //断开连接，即挂机
  99. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  100. && line.contains(ReadLog.CallState.DISCONNECTED)) {
  101. Log.d(TAG, ReadLog.CallState.DISCONNECTED);
  102. }
  103. } //END while
  104. } catch (IOException e) {
  105. e.printStackTrace();
  106. } //END try-catch
  107. } //END run
  108. } //END class ReadLog

以上代码中，之所以用线程，是为了防止读取日志过程中阻滞主方法的其他方法的执行，影响到程序捕捉对应的电话状态。

好了，捕捉到了去电过程中各个状态的转变，那么，如何通知给程序呢，我采用的方法是捕获后立马给系统发送广播，然后程序进行广播接收，接收后再处理录音事件。要发送广播，就要发送一个唯一的广播，为此，建立如下类：

Java代码
  1. package com.sdvdxl.outgoingcall;
  2. import com.sdvdxl.phonerecorder.ReadLog;
  3. import android.content.Context;
  4. import android.util.Log;
  5. public class OutgoingCallState {
  6. Context ctx;
  7. public OutgoingCallState(Context ctx) {
  8. this.ctx = ctx;
  9. }
  10. /**
  11. * 前台呼叫状态
  12. * @author sdvdxl
  13. *
  14. */
  15. public static final class ForeGroundCallState {
  16. public static final String DIALING =
  17. "com.sdvdxl.phonerecorder.FORE_GROUND_DIALING";
  18. public static final String ALERTING =
  19. "com.sdvdxl.phonerecorder.FORE_GROUND_ALERTING";
  20. public static final String ACTIVE =
  21. "com.sdvdxl.phonerecorder.FORE_GROUND_ACTIVE";
  22. public static final String IDLE =
  23. "com.sdvdxl.phonerecorder.FORE_GROUND_IDLE";
  24. public static final String DISCONNECTED =
  25. "com.sdvdxl.phonerecorder.FORE_GROUND_DISCONNECTED";
  26. }
  27. /**
  28. * 开始监听呼出状态的转变，
  29. * 并在对应状态发送广播
  30. */
  31. public void startListen() {
  32. new ReadLog(ctx).start();
  33. Log.d("Recorder", "开始监听呼出状态的转变，并在对应状态发送广播");
  34. }
  35. }

程序需要读取系统日志权限：

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

然后，在读取日志的类中检测到去电各个状态的地方发送一个广播，那么，读取日志的完整代码如下：

Java代码
  1. package com.sdvdxl.phonerecorder;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import com.sdvdxl.outgoingcall.OutgoingCallState;
  7. import android.content.Context;
  8. import android.content.Intent;
  9. import android.util.Log;
  10. /**
  11. *
  12. * @author mrloong
  13. *  找到 日志中的
  14. *  onPhoneStateChanged: mForegroundCall.getState() 这个是前台呼叫状态
  15. *  mBackgroundCall.getState() 后台电话
  16. *  若 是 DIALING 则是正在拨号，等待建立连接，但对方还没有响铃，
  17. *  ALERTING 呼叫成功，即对方正在响铃，
  18. *  若是 ACTIVE 则已经接通
  19. *  若是 DISCONNECTED 则本号码呼叫已经挂断
  20. *  若是 IDLE 则是处于 空闲状态
  21. *
  22. */
  23. public class ReadLog extends Thread {
  24. private Context ctx;
  25. private int logCount;
  26. private static final String TAG = "LogInfo OutGoing Call";
  27. /**
  28. *  前后台电话
  29. * @author sdvdxl
  30. *
  31. */
  32. private static class CallViewState {
  33. public static final String FORE_GROUND_CALL_STATE = "mForeground";
  34. }
  35. /**
  36. * 呼叫状态
  37. * @author sdvdxl
  38. *
  39. */
  40. private static class CallState {
  41. public static final String DIALING = "DIALING";
  42. public static final String ALERTING = "ALERTING";
  43. public static final String ACTIVE = "ACTIVE";
  44. public static final String IDLE = "IDLE";
  45. public static final String DISCONNECTED = "DISCONNECTED";
  46. }
  47. public ReadLog(Context ctx) {
  48. this.ctx = ctx;
  49. }
  50. /**
  51. * 读取Log流
  52. * 取得呼出状态的log
  53. * 从而得到转换状态
  54. */
  55. @Override
  56. public void run() {
  57. Log.d(TAG, "开始读取日志记录");
  58. String[] catchParams = {"logcat", "InCallScreen *:s"};
  59. String[] clearParams = {"logcat", "-c"};
  60. try {
  61. Process process=Runtime.getRuntime().exec(catchParams);
  62. InputStream is = process.getInputStream();
  63. BufferedReader reader = new BufferedReader(new InputStreamReader(is));
  64. String line = null;
  65. while ((line=reader.readLine())!=null) {
  66. logCount++;
  67. //输出所有
  68. Log.v(TAG, line);
  69. //日志超过512条就清理
  70. if (logCount>512) {
  71. //清理日志
  72. Runtime.getRuntime().exec(clearParams)
  73. .destroy();//销毁进程，释放资源
  74. logCount = 0;
  75. Log.v(TAG, "-----------清理日志---------------");
  76. }
  77. /*---------------------------------前台呼叫-----------------------*/
  78. //空闲
  79. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  80. && line.contains(ReadLog.CallState.IDLE)) {
  81. Log.d(TAG, ReadLog.CallState.IDLE);
  82. }
  83. //正在拨号，等待建立连接，即已拨号，但对方还没有响铃，
  84. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  85. && line.contains(ReadLog.CallState.DIALING)) {
  86. //发送广播
  87. Intent dialingIntent = new Intent();
  88. dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.DIALING);
  89. ctx.sendBroadcast(dialingIntent);
  90. Log.d(TAG, ReadLog.CallState.DIALING);
  91. }
  92. //呼叫对方 正在响铃
  93. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  94. && line.contains(ReadLog.CallState.ALERTING)) {
  95. //发送广播
  96. Intent dialingIntent = new Intent();
  97. dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.ALERTING);
  98. ctx.sendBroadcast(dialingIntent);
  99. Log.d(TAG, ReadLog.CallState.ALERTING);
  100. }
  101. //已接通，通话建立
  102. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  103. && line.contains(ReadLog.CallState.ACTIVE)) {
  104. //发送广播
  105. Intent dialingIntent = new Intent();
  106. dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.ACTIVE);
  107. ctx.sendBroadcast(dialingIntent);
  108. Log.d(TAG, ReadLog.CallState.ACTIVE);
  109. }
  110. //断开连接，即挂机
  111. if (line.contains(ReadLog.CallViewState.FORE_GROUND_CALL_STATE)
  112. && line.contains(ReadLog.CallState.DISCONNECTED)) {
  113. //发送广播
  114. Intent dialingIntent = new Intent();
  115. dialingIntent.setAction(OutgoingCallState.ForeGroundCallState.DISCONNECTED);
  116. ctx.sendBroadcast(dialingIntent);
  117. Log.d(TAG, ReadLog.CallState.DISCONNECTED);
  118. }
  119. } //END while
  120. } catch (IOException e) {
  121. e.printStackTrace();
  122. } //END try-catch
  123. } //END run
  124. } //END class ReadLog

发送了广播，那么就要有接收者，定义接收者如下（关于录音机的代码可以先忽略）：

Java代码
  1. package com.sdvdxl.phonerecorder;
  2. import android.content.BroadcastReceiver;
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.util.Log;
  6. import com.sdvdxl.outgoingcall.OutgoingCallState;
  7. public class OutgoingCallReciver extends BroadcastReceiver {
  8. static final String TAG = "Recorder";
  9. private MyRecorder recorder;
  10. public OutgoingCallReciver() {
  11. recorder = new MyRecorder();
  12. }
  13. public  OutgoingCallReciver (MyRecorder recorder) {
  14. this.recorder = recorder;
  15. }
  16. @Override
  17. public void onReceive(Context ctx, Intent intent) {
  18. String phoneState = intent.getAction();
  19. if (phoneState.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
  20. String phoneNum = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);//拨出号码
  21. recorder.setPhoneNumber(phoneNum);
  22. recorder.setIsCommingNumber(false);
  23. Log.d(TAG, "设置为去电状态");
  24. Log.d(TAG, "去电状态 呼叫：" + phoneNum);
  25. }
  26. if (phoneState.equals(OutgoingCallState.ForeGroundCallState.DIALING)) {
  27. Log.d(TAG, "正在拨号...");
  28. }
  29. if (phoneState.equals(OutgoingCallState.ForeGroundCallState.ALERTING)) {
  30. Log.d(TAG, "正在呼叫...");
  31. }
  32. if (phoneState.equals(OutgoingCallState.ForeGroundCallState.ACTIVE)) {
  33. if (!recorder.isCommingNumber() && !recorder.isStarted()) {
  34. Log.d(TAG, "去电已接通 启动录音机");
  35. recorder.start();
  36. }
  37. }
  38. if (phoneState.equals(OutgoingCallState.ForeGroundCallState.DISCONNECTED)) {
  39. if (!recorder.isCommingNumber() && recorder.isStarted()) {
  40. Log.d(TAG, "已挂断 关闭录音机");
  41. recorder.stop();
  42. }
  43. }
  44. }
  45. }

其中有这么一段代码：

Java代码
  1. String phoneState = intent.getAction();
  2. if (phoneState.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
  3. String phoneNum = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);//拨出号码
  4. recorder.setPhoneNumber(phoneNum);
  5. recorder.setIsCommingNumber(false);
  6. Log.d(TAG, "设置为去电状态");
  7. Log.d(TAG, "去电状态 呼叫：" + phoneNum);
  8. }

这里是接收系统发出的广播，用于接收去电广播。这样，就获得了去电状态。

3、有了以上主要代码，可以说，来去电监听功能算是完成了，下面创建一个service来运行监听：

Java代码
  1. package com.sdvdxl.service;
  2. import android.app.Service;
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.content.IntentFilter;
  6. import android.os.IBinder;
  7. import android.telephony.PhoneStateListener;
  8. import android.telephony.TelephonyManager;
  9. import android.util.Log;
  10. import android.widget.Toast;
  11. import com.sdvdxl.outgoingcall.OutgoingCallState;
  12. import com.sdvdxl.phonerecorder.MyRecorder;
  13. import com.sdvdxl.phonerecorder.OutgoingCallReciver;
  14. import com.sdvdxl.phonerecorder.TelListener;
  15. public class PhoneCallStateService extends Service {
  16. private OutgoingCallState outgoingCallState;
  17. private OutgoingCallReciver outgoingCallReciver;
  18. private MyRecorder recorder;
  19. @Override
  20. public void onCreate() {
  21. super.onCreate();
  22. //------以下应放在onStartCommand中，但2.3.5以下版本不会因service重新启动而重新调用--------
  23. //监听电话状态，如果是打入且接听 或者 打出 则开始自动录音
  24. //通话结束，保存文件到外部存储器上
  25. Log.d("Recorder", "正在监听中...");
  26. recorder = new MyRecorder();
  27. outgoingCallState = new OutgoingCallState(this);
  28. outgoingCallReciver = new OutgoingCallReciver(recorder);
  29. outgoingCallState.startListen();
  30. Toast.makeText(this, "服务已启动", Toast.LENGTH_LONG).show();
  31. //去电
  32. IntentFilter outgoingCallFilter = new IntentFilter();
  33. outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.IDLE);
  34. outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.DIALING);
  35. outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.ALERTING);
  36. outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.ACTIVE);
  37. outgoingCallFilter.addAction(OutgoingCallState.ForeGroundCallState.DISCONNECTED);
  38. outgoingCallFilter.addAction("android.intent.action.PHONE_STATE");
  39. outgoingCallFilter.addAction("android.intent.action.NEW_OUTGOING_CALL");
  40. //注册接收者
  41. registerReceiver(outgoingCallReciver, outgoingCallFilter);
  42. //来电
  43. TelephonyManager telmgr = (TelephonyManager)getSystemService(
  44. Context.TELEPHONY_SERVICE);
  45. telmgr.listen(new TelListener(recorder), PhoneStateListener.LISTEN_CALL_STATE);
  46. }
  47. @Override
  48. public IBinder onBind(Intent intent) {
  49. // TODO Auto-generated method stub
  50. return null;
  51. }
  52. @Override
  53. public void onDestroy() {
  54. super.onDestroy();
  55. unregisterReceiver(outgoingCallReciver);
  56. Toast.makeText(
  57. this, "已关闭电话监听服务", Toast.LENGTH_LONG)
  58. .show();
  59. Log.d("Recorder", "已关闭电话监听服务");
  60. }
  61. @Override
  62. public int onStartCommand(Intent intent, int flags, int startId) {
  63. return START_STICKY;
  64. }
  65. }

注册以下service：

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

到此为止，来去电状态的监听功能算是完成了，剩下一个录音机，附上录音机代码如下：

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

到此，来去电通话自动录音的所有功能就完成了，大家可以自己试着编写并实现。

相关文章