手把手教你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. @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. }

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

时间： 2024-10-13 16:35:52

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

Android6.0 编程实现双向通话自动录音功能的方法详解

本文实例讲述了Android6.0编程实现双向通话自动录音功能的方法.分享给大家供大家参考,具体如下: 项目中需要实现基于Android 6.0 的双向通话自动录音功能,在查阅相关android电话状态监听文章以及Git上的开源录音项目后,整理出此文 首先,介绍一下android 电话状态的监听(来电和去电):http://www.jb51.net/article/32433.htm 实现手机电话状态的监听,主要依靠两个类: TelephoneManger和PhoneStateListener

东方耀 手把手教React Native实战开发视频教程+源码笔记全集

课程序号标题 第0课0.手把手教React Native实战之开山篇_视频 第1课1.手把手教React Native实战之环境搭建_视频_Windows环境 第1课1.手把手教React Native实战之环境搭建[Mac真机]同时调试开发Android&IOS 第2课2.手把手教React Native实战之从React到RN 第3课3.手把手教React Native实战之flexbox布局(RN基础) 第4讲4.手把手教React Native实战之flexbox布局(伸缩属性) 第5讲

Android开发之手把手教你写ButterKnife框架（二）

欢迎转载,转载请标明出处: http://blog.csdn.net/johnny901114/article/details/52664112 本文出自:[余志强的博客] 上一篇博客Android开发之手把手教你写ButterKnife框架(一)我们讲了ButterKnife是什么.ButterKnife的作用和功能介绍以及ButterKnife的实现原理. 本篇博客主要讲在android studio中如何使用apt. 一.新建个项目, 然后创建一个module名叫processor 新建m

Android消息推送：手把手教你集成小米推送

前言 在Android开发中,消息推送功能的使用非常常见. 为了降低开发成本,使用第三方推送是现今较为流行的解决方案. 今天,我将手把手教大家如何在你的应用里集成小米推送 该文档基于小米推送官方Demo,并给出简易推送Demo 看该文档前,请先阅读我写的另外两篇文章: 史上最全解析Android消息推送解决方案 Android推送:第三方消息推送平台详细解析 目录 1. 官方Demo解析 首先,我们先对小米官方的推送Demo进行解析. 请先到官网下载官方Demo和SDK说明文档 1.1 Demo

Android中滑屏实现----手把手教你如何实现触摸滑屏以及Scroller类详解

Android中滑屏实现----手把手教你如何实现触摸滑屏以及Scroller类详解

Android 自定义ViewGroup手把手教你实现ArcMenu

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/37567907 逛eoe发现这样的UI效果,感觉很不错,后来知道github上有这么个开源项目~~~~当然本篇不是教你如何使用这个开源项目,而是教你如何自己通过自定义ViewGroup写这样的效果,自定义ViewGroup也是我的痛楚,嘿嘿,希望以此可以抛砖引玉~~ 效果图: 1.实现思路 通过效果图,会有几个问题: a.动画效果如何实现 可以看出动画是从顶点外外发射的,可能有人

Android开发之手把手教你写ButterKnife框架（三）

欢迎转载,转载请标明出处: http://blog.csdn.net/johnny901114/article/details/52672188 本文出自:[余志强的博客] 一.概述 上一篇博客讲了,如何在android studio使用apt < Android开发之手把手教你写ButterKnife框架(二)> 然后在Processor里生成自己的代码,把要输出的类,通过StringBuilder拼接字符串,然后输出. try { // write the file JavaFileObj

Android 手把手教您自定义ViewGroup（一）

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38339817 , 本文出自:[张鸿洋的博客] 最近由于工作的变动,导致的博客的更新计划有点被打乱,希望可以尽快脉动回来~ 今天给大家带来一篇自定义ViewGroup的教程,说白了,就是教大家如何自定义ViewGroup,如果你对自定义ViewGroup还不是很了解,或者正想学习如何自定义,那么你可以好好看看这篇博客. 1.概述 在写代码之前,我必须得问几个问题: 1.ViewG

UWP Jenkins + NuGet + MSBuild 手把手教你做自动UWP Build 和 App store包

背景 项目上需要做UWP的自动安装包,在以前的公司接触的是TFS来做自动build. 公司要求用Jenkins来做,别笑话我,之前还真不晓得这个东西. 会的同学请看一下支持错误,不会的同学请先自行脑补,我们一步一步的来. 首先我们准备2个安装包,Jenkins,NuGet 都下载最新的好了. 1. 安装Jenkins,下一步下一步.安装好了会自动浏览器跳转到http://localhost:8080/ 如下图 按照提示去C:\Program Files (x86)\Jenkins\secrets