• Android SIP软电话，通话录音，VoIP电话，linphone电话

    各位大佬好，我又来记笔记了~~

    公司又提新需求了，需要开发一个能通话（呼叫客户的手机号码）自动录音的模块。刚接触这个是蒙的，经过一番研究，可实现通话录音的方式大致有下面几种：

      方案一：点击拨号时，调用系统的拨号功能，同时应用内注册通话广播，检测通话状态，接通、挂断来决定开始录音和停止录音，录音可以使用MediaRecorder和AudioRecorder。

            优缺点：实现方式简单，开发容易。但是缺点也有，受Android系统版本影响大，每次打开应用都需要进设置页面开启“无障碍”权限才能录音（目前Android8.0的不用），录音对方的声音较小。不过适当优化下 也能用。

     方案二：刷机，获取设备root权限，把应用修改为“系统”级别应用，就可以正常录制通话（跟手机自带的通话录音一样），具体怎么刷机自行百度

             优缺点：参考手机自带的通话录音功能，效果还是非常好的，但是只能用于一些定制的设备。如正常的一些手机、pad用户就不得行了，因为客户不可能会去刷机来兼容我们的应用。

     方案三： SIP软电话，集成第三方的VoIP网络电话，实现网络通话并录音，效果也还行。如linphone框架，也是本文要讲的。

          优缺点：使用SIP软电话，前提是要有SIP服务器（网上有很多免费的SIP服务器），后面说具体的实现逻辑，通话录音还可以，双方声音都比较大。

     方案四：呼叫时，点击开启系统的录音进行录制，返回我们应用时，把系统的录音文件拿出来展示或上传服务器，哈哈 最笨的方案了，适配主流的机型（前提是手机支持通话录音，获取录音文件的路径各机型适配一下）。

          优缺点：兼容性差，不推荐了。

              

     本文主要记录的是 《方案一》 和《方案三》，下面 只介绍关键步骤，详见文末demo

       方案一：

          大致步骤:   1、权限申请

                            2、注册广播，开启服务进行录音

                            3、开始拨号 

                            4、查看通话记录，播放录音文件

                         

    需要的权限，项目全部权限在这了，有的可能用不到。

    1. <uses-permission android:name="android.permission.INTERNET" />
    2.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    3.     <uses-permission android:name="android.permission.RECORD_AUDIO" />
    4.     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    5.     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    6.     <uses-permission android:name="android.permission.CALL_PHONE" />
    7.     <uses-permission android:name="android.permission.WRITE_CALL_LOG" />
    8.     <uses-permission android:name="android.permission.READ_CALL_LOG" />
    9.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    10.     <uses-permission
    11.         android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
    12.         tools:ignore="ScopedStorage" />
    13.     <uses-permission
    14.         android:name="android.permission.MODIFY_PHONE_STATE"
    15.         tools:ignore="ProtectedPermissions" />
    16.     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
    17.     <uses-permission
    18.         android:name="android.permission.BIND_ACCESSIBILITY_SERVICE"
    19.         tools:ignore="ProtectedPermissions" />
    20.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    注册广播:

    AndroidManifest文件添加 PhoneStateListener和MediaRecorderService

    2.     android:name=".callrecord.PhoneStateListener"
    3.     android:enabled="true"
    4.     android:exported="true">
    5.     
    6.         "android.intent.action.PHONE_STATE" />
    7.     
    9.  
    10.  
    11.             android:name=".callrecord.MediaRecorderService"
    12.             android:enabled="true"
    13.             android:exported="true"
    14.             android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    15.             
    16.                 "android.accessibilityservice.AccessibilityService" />
    17.             
    18.  
    19.             
    20.                 android:name="android.accessibilityservice"
    21.                 android:resource="@xml/accessibility_service_config" />
    22.

    PhoneStateListener类：

    1. /**
    2.  * @ClassName PhoneStateListener
    3.  * @Description TODO
    4.  * @Author HK.W   通话录音广播
    5.  * @Date 2022/10/15 22:13
    6.  */
    7. public class PhoneStateListener extends BroadcastReceiver {
    8.     private static final String TAG = "通话状态监听";
    9.     static boolean incoming_flag;
    10.     private Context mContext;
    11.  
    12.     @Override
    13.     public void onReceive(Context ctx, Intent intent) {
    14.         mContext = ctx;
    15.         String event = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
    16.         Log.d(TAG, "通话状态：state:" + event);
    17.         if (event.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
    18.             Log.d(TAG, "-->RINGING--正在响铃");
    19.             incoming_flag = true;
    20.         } else if (event.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
    21.             Log.d(TAG, "-->EXTRA_STATE_OFFHOOK--正在通话");
    22.             startService(ctx, intent);
    23.         } else if (event.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
    24.             Log.d(TAG, "-->EXTRA_STATE_IDLE--电话挂断--空闲");
    25.             ctx.stopService(new Intent(ctx, MediaRecorderService.class));
    26.             //AudioRecordUtil.getInstance().stopRecording();
    27.             AudioRecorder.getInstance().stopRecord();
    28.         }
    29.  
    30.     }
    31.  
    32.     private void startService(Context context, Intent intent) {
    33.         Log.d(TAG, "-->startService--打开服务-检查权限");
    34.         String[] PERMISSIONS = {Manifest.permission.RECORD_AUDIO,
    35.                 Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE};
    36.         if (hasPermissions(context, PERMISSIONS)) {
    37.             Log.d(TAG, "-->startService--打开服务-权限已打开");
    38.             intent.setClass(context, MediaRecorderService.class);
    39.             intent.putExtra("incoming_flag", incoming_flag);
    40.             if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    41.                 context.startForegroundService(intent);
    42.             } else {
    43.                 context.startService(intent);
    44.             }
    45.         } else {
    46.             Log.d(TAG, "-->startService--打开服务-权限未打开");
    47.         }
    48.     }
    49.  
    50.     public static boolean hasPermissions(Context context, String... permissions) {
    51.         if (context != null && permissions != null) {
    52.             for (String permission : permissions) {
    53.                 if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
    54.                     return false;
    55.                 }
    56.             }
    57.         }
    58.         return true;
    59.     }
    60. }

    MediaRecorderService类：

    1. public class MediaRecorderService extends AccessibilityService {
    2.     private static final String TAG = "通话状态监听";
    3.     NotificationManagerCompat notificationManager;
    4.     private boolean incoming_flag;
    5.     private String number;
    6.  
    7.     @Override
    8.     public void onInterrupt() {
    9.  
    10.     }
    11.  
    12.     @Override
    13.     public void onAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
    14.  
    15.     }
    16.  
    17.     @Override
    18.     public int onStartCommand(Intent intent, int flags, int startId) {
    19.         if (intent != null) {
    20.             Log.d(TAG, "-->startService--进入录音服务");
    21.             number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
    22.             incoming_flag = intent.getBooleanExtra("incoming_flag", false);
    23.             String phone = SpUtils.getInstance().getString(this, "phone", "Unknown");
    24.             AudioRecorder.getInstance().createDefaultAudio(phone);
    25.             AudioRecorder.getInstance().startRecord(new RecordStreamListener() {
    26.                 @Override
    27.                 public void recordOfByte(byte[] data, int begin, int end) {
    28.                     Log.d(TAG, "data:" + data);
    29.                 }
    30.             });
    31.             notificationBuilder();
    32.         }
    33.         return START_STICKY;
    34.     }
    35.  
    36.     private void notificationBuilder() {
    37.         Log.d(TAG, "-->startService--录音服务--打开通知栏，让服务进入前台，避免被杀掉");
    38.         if (Build.VERSION.SDK_INT >= 26) {
    39.             String CHANNEL_ID = "my_channel_01";
    40.             NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Channel title",
    41.                     NotificationManager.IMPORTANCE_DEFAULT);
    42.             ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).createNotificationChannel(channel);
    43.             Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
    44.                     .setContentTitle("")
    45.                     .setContentText("").build();
    46.             startForeground(1, notification);
    47.         } else {
    48.             NotificationCompat.Builder builder = new NotificationCompat.Builder(this, "CHANNEL_ID")
    49.                     .setSmallIcon(R.mipmap.ic_launcher)
    50.                     .setContentTitle("Recording")
    51.                     .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    52.                     .setOngoing(true);
    53.             notificationManager = NotificationManagerCompat.from(this);
    54.             notificationManager.notify(1, builder.build());
    55.         }
    56.     }
    57.  
    58.     @Override
    59.     public void onDestroy() {
    60.         super.onDestroy();
    61.         Log.d(TAG, "-->startService--录音服务--服务被销毁---onDestroy()");
    62.         stopRecording();
    63.     }
    64.  
    65.     private void stopRecording() {
    66.         Log.d(TAG, "-->startService--录音服务--停止录音");
    67.         if (Build.VERSION.SDK_INT >= 26) {
    68.             stopForeground(true);
    69.         } else {
    70.             NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    71.             notificationManager.cancel(1);
    72.         }
    73.     }
    74. }

    功能相关页面截图：

     拨号：

    1.  private void callPhone(String phoneNumber) {
    2.         Intent intentPhone = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + 
    3.      phoneEt.getText().toString()));
    4.         startActivity(intentPhone);
    5.     }

     开始录音

    1.  @Override
    2.     public int onStartCommand(Intent intent, int flags, int startId) {
    3.         if (intent != null) {
    4.             Log.d(TAG, "-->startService--进入录音服务");
    5.             number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
    6.             incoming_flag = intent.getBooleanExtra("incoming_flag", false);
    7.             String phone = SpUtils.getInstance().getString(this, "phone", "Unknown");
    8.            //开始录音
    9.             AudioRecorder.getInstance().createDefaultAudio(phone);
    10.             AudioRecorder.getInstance().startRecord(new RecordStreamListener() {
    11.                 @Override
    12.                 public void recordOfByte(byte[] data, int begin, int end) {
    13.                     Log.d(TAG, "data:" + data);
    14.                 }
    15.             });
    16.             notificationBuilder();
    17.         }
    18.         return START_STICKY;
    19.     }

    停止录音：

    1. public class PhoneStateListener extends BroadcastReceiver {
    2.     private static final String TAG = "通话状态监听";
    3.     static boolean incoming_flag;
    4.     private Context mContext;
    5.  
    6.     @Override
    7.     public void onReceive(Context ctx, Intent intent) {
    8.         mContext = ctx;
    9.         String event = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
    10.         Log.d(TAG, "通话状态：state:" + event);
    11.         if (event.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
    12.             Log.d(TAG, "-->RINGING--正在响铃");
    13.             incoming_flag = true;
    14.         } else if (event.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
    15.             Log.d(TAG, "-->EXTRA_STATE_OFFHOOK--正在通话");
    16.             startService(ctx, intent);
    17.         } else if (event.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
    18.             Log.d(TAG, "-->EXTRA_STATE_IDLE--电话挂断--空闲");
    19.             ctx.stopService(new Intent(ctx, MediaRecorderService.class));
    20.             //AudioRecordUtil.getInstance().stopRecording();
    21.  
    22.             //为什么不在服务里面停止录音？有的机型挂断电话后没有马上销毁服务，所以在状态这里直接停止录音
    23.             AudioRecorder.getInstance().stopRecord();
    24.         }
    25.     }

    本文demo 录音文件保存在根目录anyi.phone/record 文件下。

    获取通话记录对应的录音文件:

    1.  /**
    2.      * 获取录音文件路径 --通话记录
    3.      */
    4.     private List getLocalRecord() {
    5.         List contacts = readContacts();
    6.         List list = new ArrayList<>();
    7.         JSONArray allFiles = getAllFiles("", "wav");
    8.         //Log.d("allFiles", "allFiles:" + allFiles.toString());
    9.         if (null != allFiles) {
    10.             for (int i = 0; i < allFiles.length(); i++) {
    11.                 try {
    12.                     JSONObject jsonObject = allFiles.getJSONObject(i);
    13.                     String name = jsonObject.getString("name");
    14.                     String path = jsonObject.getString("path");
    15.                     String[] split1 = name.split("-");
    16.                     if (split1.length > 0) {
    17.                         RecordBean recordBean = new RecordBean();
    18.                         recordBean.setNumber(split1[0]);
    19.                         recordBean.setPath(path);
    20.                         recordBean.setDate(new SimpleDateFormat("HH:mm").format(new Date(Long.parseLong(split1[1]))));
    21.                         if (contacts.size() > 0) {
    22.                             for (ContactsBean b : contacts) {
    23.                                 if (split1[0].equals(b.getNumber())) {
    24.                                     recordBean.setCachedName(b.getName());
    25.                                 }
    26.                             }
    27.                         } else {
    28.                             recordBean.setCachedName("未知");
    29.                         }
    30.                         list.add(recordBean);
    31.                     }
    32.                 } catch (JSONException e) {
    33.                     e.printStackTrace();
    34.                 }
    35.             }
    36.             Collections.reverse(list);
    37.             return list;
    38.         }
    39.         return list;
    40.     }
    41.  
    42.     public static JSONArray getAllFiles(String dirPath, String _type) {
    43.         dirPath = "/storage/emulated/0/anyi.phone/record/";
    44.         File f = new File(dirPath);
    45.         if (!f.exists()) {//判断路径是否存在
    46.             return null;
    47.         }
    48.         File[] files = f.listFiles();
    49.         if (files == null) {//判断权限
    50.             return null;
    51.         }
    52.         JSONArray fileList = new JSONArray();
    53.         for (File _file : files) {//遍历目录
    54.             if (_file.isFile() && (_file.getName().endsWith("amr")||_file.getName().endsWith("wav"))) {
    55.                 String _name = _file.getName();
    56.                 String filePath = _file.getAbsolutePath();//获取文件路径
    57.                 String fileName = _file.getName().substring(0, _name.length() - 4);//获取文件名
    58.                 try {
    59.                     JSONObject _fInfo = new JSONObject();
    60.                     _fInfo.put("name", fileName);
    61.                     _fInfo.put("path", filePath);
    62.                     fileList.put(_fInfo);
    63.                 } catch (Exception e) {
    64.                 }
    65.             } else if (_file.isDirectory()) {//查询子目录
    66.                 //getAllFiles(_file.getAbsolutePath(), _type);
    67.             } else {
    68.             }
    69.         }
    70.         return fileList;
    71.     }

    播放：

    1.  private void initPlay() {
    2.         mediaPlayer = new MediaPlayer();
    3.     }
    4.  
    5.     private void startPlay(String path) {
    6.         if (TextUtils.isEmpty(path)) {
    7.             Toast.makeText(this, "文件路径不存在", Toast.LENGTH_LONG).show();
    8.             return;
    9.         }
    10.         mediaPlayer.reset(); //清空里面的其他歌曲
    11.         try {
    12.             mediaPlayer.setDataSource(path);
    13.             mediaPlayer.prepare(); //准备就绪
    14.             mediaPlayer.start(); //开始唱歌
    15.         } catch (IOException e) {
    16.             e.printStackTrace();
    17.         }
    18.     }

    方案三，SIP通话录音，linphone 为例，只调试了音频通话，视频通话未调试

     前提准备

    准备一个SIP服务器地址和一个账号密码。可以自己搭建SIP服务器或者网上找一个SIP服务器注册 一个账号密码。下面是网上找的资源，没试过。因为我们公司是购买的有SIP话机服务器的。

    1. 免费sip账号注册地址 http://serweb.iptel.org/user/reg/index.php
    2. 免费sip服务器   iptel.org
    3. 免费sip客户端 http://www.fring.com

            

    正文：

    1、把linphone-sdk-android-4.3.0-beta.aar包放在项目libs，提取码: nq6q。

    2、配置文件注册服务：

    1.  
    2.             android:name=".linphone.LinphoneService"
    3.             android:enabled="true"
    4.             android:exported="true"
    5.             android:label="@string/app_name" />

    3.在启动页 启动SIP相关服务,

    启动页：

    1. public class LauncherActivity extends AppCompatActivity {
    2.  
    3.     private static final String TAG = "XXPermissions";
    4.     private Handler mHandler;
    5.  
    6.     @Override
    7.     protected void onCreate(Bundle savedInstanceState) {
    8.         super.onCreate(savedInstanceState);
    9.         setContentView(R.layout.activity_launcher);
    10.         mHandler = new Handler();
    11.     }
    12.  
    13.     @Override
    14.     protected void onStart() {
    15.         super.onStart();
    16.         getPermission();
    17.     }
    18.  
    19.     private void getPermission() {
    20.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    21.             XXPermissions.with(this)
    22.                     .permission(allPermission)
    23.                     .request(new OnPermissionCallback() {
    24.                         @Override
    25.                         public void onGranted(List permissions, boolean all) {
    26.                             if (all) {
    27.                                 if (LinphoneService.isReady()) {
    28.                                     onServiceReady();
    29.                                 } else {
    30.                                     startService(new Intent().setClass(LauncherActivity.this, LinphoneService.class));
    31.                                     new ServiceWaitThread().start();
    32.                                 }
    33.                             }
    34.                         }
    35.  
    36.                         @Override
    37.                         public void onDenied(List permissions, boolean never) {
    38.                             if (never) {
    39.                                 Log.e(TAG, "onDenied：被永久拒绝授权，请手动授予权限 ");
    40.                             } else {
    41.                                 Log.e(TAG, "onDenied: 权限获取失败");
    42.                             }
    43.                         }
    44.                     });
    45.         } else {
    46.             if (LinphoneService.isReady()) {
    47.                 onServiceReady();
    48.             } else {
    49.                 startService(new Intent().setClass(LauncherActivity.this, LinphoneService.class));
    50.                 new ServiceWaitThread().start();
    51.             }
    52.         }
    53.     }
    54.  
    55.     private void onServiceReady() {
    56.         Intent intent = new Intent();
    57.         intent.setClass(LauncherActivity.this, MainActivity.class);
    58.         if (getIntent() != null && getIntent().getExtras() != null) {
    59.             intent.putExtras(getIntent().getExtras());
    60.         }
    61.         intent.setAction(getIntent().getAction());
    62.         intent.setType(getIntent().getType());
    63.         startActivity(intent);
    64.     }
    65.  
    66.     private class ServiceWaitThread extends Thread {
    67.         public void run() {
    68.             while (!LinphoneService.isReady()) {
    69.                 try {
    70.                     sleep(30);
    71.                 } catch (InterruptedException e) {
    72.                     throw new RuntimeException("waiting thread sleep() has been interrupted");
    73.                 }
    74.             }
    75.             mHandler.post(new Runnable() {
    76.                 @Override
    77.                 public void run() {
    78.                     onServiceReady();
    79.                 }
    80.             });
    81.         }
    82.     }
    83. }

    首页activity  onResume（）方法中检测 账号是否注册，未注册跳转到注册页面：

    1. @Override
    2.     protected void onResume() {
    3.         super.onResume();
    4.         Log.d(TAG, "onResume()");
    5.         LinphoneService.getCore().addListener(mCoreListener);
    6.         ProxyConfig proxyConfig = LinphoneService.getCore().getDefaultProxyConfig();
    7.         if (proxyConfig != null) {
    8.             updateLed(proxyConfig.getState());
    9.         } else {
    10.             startActivity(new Intent(this, ConfigureAccountActivity.class));
    11.         }
    12.     }

    注册：

    1. /**
    2.      * 注册
    3.      */
    4.     private void configureAccount() {
    5.         mAccountCreator.setUsername(mUsername.getText().toString());
    6.         mAccountCreator.setDomain(mDomain.getText().toString());
    7.         mAccountCreator.setPassword(mPassword.getText().toString());
    8.         switch (mTransport.getCheckedRadioButtonId()) {
    9.             case R.id.transport_udp:
    10.                 mAccountCreator.setTransport(TransportType.Udp);
    11.                 break;
    12.             case R.id.transport_tcp:
    13.                 mAccountCreator.setTransport(TransportType.Tcp);
    14.                 break;
    15.             case R.id.transport_tls:
    16.                 mAccountCreator.setTransport(TransportType.Tls);
    17.                 break;
    18.         }
    19.         ProxyConfig cfg = mAccountCreator.createProxyConfig();
    20.         LinphoneService.getCore().setDefaultProxyConfig(cfg);
    21.     }
    22.  
    23. public void listener(){
    24. mCoreListener = new CoreListenerStub() {
    25.             /**
    26.              * 监听注册是否成功
    27.              * @param core
    28.              * @param cfg
    29.              * @param state
    30.              * @param message
    31.              */
    32.             @Override
    33.             public void onRegistrationStateChanged(Core core, ProxyConfig cfg, RegistrationState state, String message) {
    34.                 registerPr.setVisibility(View.GONE);
    35.                 if (state == RegistrationState.Ok) {
    36.                     finish();
    37.                 } else if (state == RegistrationState.Failed) {
    38.                     Toast.makeText(ConfigureAccountActivity.this, "Failure: " + message, Toast.LENGTH_LONG).show();
    39.                 }
    40.             }
    41.         };
    42. }

    注册成功开始通话：

    1.  private void sipCallIng() {
    2.         Core core = LinphoneService.getCore();
    3.         Address addressToCall = core.interpretUrl(phoneEt.getText().toString());
    4.         CallParams params = core.createCallParams(null);
    5.         params.enableVideo(false);
    6.         if (addressToCall != null) {
    7.             String filePath = AudioRecordUtil.getInstance().getFilename(phoneEt.getText().toString(), ".wav");
    8.             android.util.Log.d("linPhone--", "开始呼叫--号码--filePath = " + filePath);
    9.            //重要：通话前需要设置录音文件，要不不会录音，
    10.             params.setRecordFile(filePath);
    11.             core.inviteAddressWithParams(addressToCall, params);
    12.  
    13.             Intent intent = new Intent(getActivity(), CallActivity.class);
    14.             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    15.             startActivity(intent);
    16.         }
    17.     }

    开始录音：

    1.  
    2.     /**
    3.      * ---通话接通--开始录音
    4.      */
    5.     private void startRecord() {
    6.         android.util.Log.d("linPhone--", "接通或者拒绝");
    7.         android.util.Log.d("linPhone--", "开始录音：录音地址：" + core.getRecordFile());
    8.         call.startRecording();
    9.     }

    停止录音：

    1.  /**
    2.      * ---通话挂断--停止录音--销毁页面
    3.      */
    4.     private void stopRecord() {
    5.         android.util.Log.d("linPhone--", "挂断，未接");
    6.         android.util.Log.d("linPhone--", "停止录音");
    7.        
    8.         call.stopRecording();//停止录音
    9.         finish();//挂断电话-销毁页面
    10.     }

    后面就是拿到录音文件播放，-----具体就不说了，

    研究SIP也用了大量时间和下载了很多大佬的资源，也花费了很多积分，

    so  想要demo的朋友们也希望支持一下，

    demo需要积分下载，具体多少由平台分配。

    本文demo成功实现了两种主流的通话录音方式，应该是能满足你们的业务需求的，

    demo传送门---

  • 相关阅读:
    使用hyper-V 编译和调试Android13（android-13.0.0_r3）源码
    带池化注意力 Strip Pooling | Rethinking Spatial Pooling for Scene Parsing
    Linux 文件 & 目录管理 & 链接
    C++软件异常排查从入门到精通
    学习Git---20分钟git快速上手
    Linux中查看并删除端口
    【C#项目】使用百度ai人脸库实现人脸识别
    HCIP练习03（重发布）
    视野修炼-技术周刊第56期
    我做了几年的Android应用层开发，为什么还要去学习安卓系统知识？
  • 原文地址：https://blog.csdn.net/m13984458297/article/details/127534688