Android实现电话录音功能（附带源码）

一、项目介绍

在现代智能手机应用中，电话录音功能具有广泛的应用场景与价值：

• 客户服务质检：呼叫中心需要对客服与客户的通话进行录音，便于质量监控与培训。

• 法律与合规：某些行业（如金融、电信）需要对重要业务通话进行留档备查。

• 个人备忘：记者、商务人士在与对方重要通话时，可启用录音，留存对话内容。

• 技术测试：开发者调试 VoIP 或通话相关功能时，也常需要录音。

然而，自 Android 6.0（API 23）以来，Google 对通话录音进行了越来越严格的限制，直接使用 MediaRecorder.AudioSource.VOICE_CALL 常常会被系统阻止或只录到单方声音。各大厂商也有不同的限制策略。本项目将从原理剖析、权限与兼容、前台服务、录音方案、UI 设计等多维度，全方位展示如何在合法、可控的前提下，实现稳定的电话录音功能。文中内容超过一万字，覆盖从底层机制到完整代码、再到项目发布与测试的方方面面。

---

二、相关知识详解

1. Android 音频子系统架构

• AudioRecord / MediaRecorder

  • MediaRecorder：高级 API，一行代码即可录音，但可用的音源受限。

  • AudioRecord：底层 API，可精细控制声道、采样率、缓冲区等，适合做二次处理。

• AudioSource 常量

  • DEFAULT、MIC、VOICE_CALL、VOICE_COMMUNICATION、VOICE_DOWNLINK、VOICE_UPLINK 等。

  • 其中，VOICE_CALL、VOICE_DOWNLINK、VOICE_UPLINK 理论上可录通话双方，但厂商常屏蔽。

• 音频路由与回声消除 (AEC)

  • 通话时系统会开启回声消除和噪声抑制，可能导致录音 API 采样流被处理或屏蔽。

• 安全策略

  • Android P（9.0）后，Google 屏蔽了大部分通话录音音源，仅允许 MIC。

  • 部分机型可通过反射或私有 API 恢复，或使用 root 权限。

2. 通话状态监听

• TelephonyManager

  • 通过 TelephonyManager.listen() 注册 PhoneStateListener，监听 CALL_STATE_RINGING、CALL_STATE_OFFHOOK、CALL_STATE_IDLE。

• BroadcastReceiver

  • 监听系统广播 ACTION_PHONE_STATE_CHANGED，兼容低版本。

3. 后台录音的持久化与存储

• 文件格式与编码

  • PCM、WAV、AMR、3GP、MP4 等。

  • PCM 最灵活，后期可转码；AMR/3GP 体积小，但音质一般。

• 存储路径

  • Android 10+ 需要使用 MediaStore 或 getExternalFilesDir()，并申请 MANAGE_EXTERNAL_STORAGE 或使用 SAF。

• 文件命名与管理

  • 按通话时间戳或对方号码命名；提供文件浏览、删除、分享功能。

4. 权限管理

• 运行时权限

  • RECORD_AUDIO、READ_PHONE_STATE、WRITE_EXTERNAL_STORAGE（Android 10 以下）

  • Android 10+ 需要动态申请并在 Manifest 中声明 foregroundServiceType="microphone"

• 前台服务权限

  • 录音服务需启动为前台服务，并在通知栏显示录音状态，以防被系统回收。

5. 厂商兼容与 Root 方案

• 部分厂商私有 API

  • 通过反射调用底层 AudioSystem.setParameters("...") 解禁录音音源。

• Root 权限

  • 在已 Root 设备上，执行 su 并修改系统配置（如 persist.sys.audio.silky.enable）或直接调用底层命令。

---

三、项目实现思路

项目整体架构分为以下模块：

1. UI 层

   • 主界面显示录音开关、呼叫记录列表

   • 通话中弹出小窗或前台通知，展示录音状态

   • 录音文件浏览与回放界面

2. 业务层

   • CallRecorderService（前台 Service）

     • 负责监听通话状态

     • 管理录音生命周期（启动、暂停、停止）

     • 将录音流保存至文件

   • PhoneStateReceiver（BroadcastReceiver）

     • 双重保险，确保所有机型都能捕获通话事件

   • RecordManager

     • 封装 MediaRecorder / AudioRecord 录音逻辑

     • 提供启动、停止、错误回调等接口

3. 数据层

   • RecordEntity：录音文件的数据模型，包含文件路径、通话时间、对方号码、录音时长

   • RecordDatabase：使用 Room 或 SQLite 存储录音列表

4. 安全与兼容层

   • PermissionHelper：统一处理运行时权限申请与回调

   • AudioSourceHelper：根据机型与系统版本，动态选择可用音源，或尝试私有 API

   • FileStorageHelper：根据 Android 版本，选择合规存储方案

5. 测试与日志

   • 使用 Logback / Timber 输出日志，记录录音启动失败原因

   • 提供 UI 一键导出日志，便于问题排查

---

四、完整项目代码（整合）

说明：以下代码已将所有 Java/Kotlin 类与 XML 布局、资源整合在一起，用 // === 类名 === 分隔，并在每个代码段前加详细注释。请在复制时以实际目录结构分割。

 

// =================================================
// File: CallRecorderFullExample.java
// 完整整合示例，包含所有类、XML 与资源
// =================================================

package com.example.callrecorder;

import android.Manifest;
import android.app.*;
import android.content.*;
import android.content.pm.PackageManager;
import android.media.*;
import android.os.*;
import android.provider.Settings;
import android.telephony.*;
import android.util.Log;
import android.view.*;
import android.widget.*;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;
import androidx.core.app.NotificationCompat;
import androidx.core.content.ContextCompat;
import androidx.room.*;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

// =================================================
// Class: MainActivity
// 说明：应用主界面，展示录音开关与录音列表
// =================================================
public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    private static final int REQUEST_PERMISSIONS = 1001;

    private Button btnToggleRecording;
    private ListView lvRecords;
    private RecordAdapter recordAdapter;
    private List<RecordEntity> recordList;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 初始化 UI
        btnToggleRecording = findViewById(R.id.btn_toggle);
        lvRecords = findViewById(R.id.lv_records);

        // 加载历史录音
        recordList = RecordDatabase.getInstance(this)
                .recordDao().getAll();
        recordAdapter = new RecordAdapter(this, recordList);
        lvRecords.setAdapter(recordAdapter);

        // 申请必要权限
        requestPermissions();

        // 按钮点击：启动或停止录音服务
        btnToggleRecording.setOnClickListener(v -> {
            if (CallRecorderService.isRunning) {
                stopService(new Intent(this, CallRecorderService.class));
                btnToggleRecording.setText("开始电话录音");
            } else {
                startService(new Intent(this, CallRecorderService.class));
                btnToggleRecording.setText("停止电话录音");
            }
        });
    }

    /** 申请运行时权限 */
    private void requestPermissions() {
        List<String> needed = new ArrayList<>();
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO)
                != PackageManager.PERMISSION_GRANTED) {
            needed.add(Manifest.permission.RECORD_AUDIO);
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE)
                != PackageManager.PERMISSION_GRANTED) {
            needed.add(Manifest.permission.READ_PHONE_STATE);
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q &&
                ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                        != PackageManager.PERMISSION_GRANTED) {
            needed.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        }
        if (!needed.isEmpty()) {
            ActivityCompat.requestPermissions(
                    this,
                    needed.toArray(new String[0]),
                    REQUEST_PERMISSIONS);
        }
    }

    // 权限请求结果回调
    @Override
    public void onRequestPermissionsResult(int req, String[] perms, int[] results) {
        super.onRequestPermissionsResult(req, perms, results);
        // 简单处理：如有拒绝，可提示用户
        for (int i = 0; i < perms.length; i++) {
            if (results[i] != PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this,
                    "必要权限未授予：" + perms[i],
                    Toast.LENGTH_LONG).show();
            }
        }
    }
}

// =================================================
// Class: CallRecorderService
// 说明：前台 Service，监听通话并录音
// =================================================
public class CallRecorderService extends Service {
    private static final String TAG = "CallRecorderService";
    public static boolean isRunning = false;
    private TelephonyManager tm;
    private PhoneStateListener psListener;
    private RecordManager recordManager;
    private NotificationManager notificationManager;
    private static final int NOTIFY_ID = 1002;
    private static final String CHANNEL_ID = "call_recorder_channel";

    @Override
    public void onCreate() {
        super.onCreate();
        isRunning = true;
        tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
        recordManager = new RecordManager(this);
        notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        createNotificationChannel();
        startForeground(NOTIFY_ID, buildNotification("电话录音服务已启动"));

        // 监听电话状态
        psListener = new PhoneStateListener() {
            @Override
            public void onCallStateChanged(int state, String incomingNumber) {
                switch (state) {
                    case TelephonyManager.CALL_STATE_RINGING:
                        Log.d(TAG, "来电响铃: " + incomingNumber);
                        break;
                    case TelephonyManager.CALL_STATE_OFFHOOK:
                        Log.d(TAG, "通话中，启动录音");
                        recordManager.startRecording(incomingNumber);
                        updateNotification("正在录音：" + incomingNumber);
                        break;
                    case TelephonyManager.CALL_STATE_IDLE:
                        Log.d(TAG, "通话结束，停止录音");
                        recordManager.stopRecording();
                        updateNotification("电话录音服务已启动");
                        break;
                }
            }
        };
        tm.listen(psListener, PhoneStateListener.LISTEN_CALL_STATE);

        // 兼容方案2：注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction("android.intent.action.PHONE_STATE");
        registerReceiver(new PhoneStateReceiver(), filter);
    }

    /** 创建通知渠道（Android O+） */
    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel ch = new NotificationChannel(
                    CHANNEL_ID,
                    "电话录音服务",
                    NotificationManager.IMPORTANCE_LOW);
            ch.setDescription("通话过程中录音");
            notificationManager.createNotificationChannel(ch);
        }
    }

    /** 构建前台通知 */
    private Notification buildNotification(String content) {
        PendingIntent pi = PendingIntent.getActivity(
                this, 0,
                new Intent(this, MainActivity.class),
                PendingIntent.FLAG_UPDATE_CURRENT);
        return new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle("CallRecorder")
                .setContentText(content)
                .setSmallIcon(R.drawable.ic_mic)
                .setContentIntent(pi)
                .setOngoing(true)
                .build();
    }

    /** 更新通知内容 */
    private void updateNotification(String content) {
        notificationManager.notify(NOTIFY_ID, buildNotification(content));
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        isRunning = false;
        tm.listen(psListener, PhoneStateListener.LISTEN_NONE);
        recordManager.cleanup();
        unregisterReceiver(new PhoneStateReceiver());
        notificationManager.cancel(NOTIFY_ID);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

// =================================================
// Class: PhoneStateReceiver
// 说明：BroadcastReceiver 兼容监听通话状态
// =================================================
public class PhoneStateReceiver extends BroadcastReceiver {
    private static final String TAG = "PhoneStateReceiver";
    private RecordManager recordManager;

    @Override
    public void onReceive(Context context, Intent intent) {
        if (!CallRecorderService.isRunning) return;
        String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
        String num = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
        recordManager = new RecordManager(context);
        if (TelephonyManager.EXTRA_STATE_OFFHOOK.equals(state)) {
            recordManager.startRecording(num);
        } else if (TelephonyManager.EXTRA_STATE_IDLE.equals(state)) {
            recordManager.stopRecording();
        }
    }
}

// =================================================
// Class: RecordManager
// 说明：封装录音逻辑，支持 MediaRecorder 与 AudioRecord 方案
// =================================================
public class RecordManager {
    private static final String TAG = "RecordManager";
    private Context ctx;
    private MediaRecorder recorder;
    private String currentFilePath;
    private String currentNumber;
    private boolean isRecording = false;
    private AudioRecord audioRecord;
    private Thread recordThread;

    public RecordManager(Context context) {
        this.ctx = context;
    }

    /** 启动录音 */
    public void startRecording(String phoneNumber) {
        if (isRecording) return;
        this.currentNumber = phoneNumber == null ? "unknown" : phoneNumber;
        try {
            // 优先尝试 MediaRecorder 方案
            recorder = new MediaRecorder();
            recorder.setAudioSource(AudioSourceHelper.getAudioSource());
            recorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
            recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
            // 录音文件路径：/sdcard/CallRec/20250426_151200_号码.mp4
            File dir = new File(ctx.getExternalFilesDir(null), "CallRec");
            if (!dir.exists()) dir.mkdirs();
            String ts = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault())
                    .format(new Date());
            currentFilePath = new File(dir,
                    ts + "_" + currentNumber + ".mp4").getAbsolutePath();
            recorder.setOutputFile(currentFilePath);
            recorder.prepare();
            recorder.start();
            isRecording = true;
            Log.d(TAG, "MediaRecorder 开始录音：" + currentFilePath);
        } catch (Exception e) {
            Log.w(TAG, "MediaRecorder 方案失败，切换 AudioRecord", e);
            // 退而求其次：AudioRecord 方案
            startAudioRecord();
        }
    }

    /** 停止录音 */
    public void stopRecording() {
        if (!isRecording) return;
        try {
            if (recorder != null) {
                recorder.stop();
                recorder.reset();
                recorder.release();
                recorder = null;
            }
            if (audioRecord != null) {
                audioRecord.stop();
                audioRecord.release();
                audioRecord = null;
            }
            isRecording = false;
            // 保存记录到数据库
            RecordEntity entity = new RecordEntity(
                    0, currentNumber, currentFilePath, System.currentTimeMillis());
            RecordDatabase.getInstance(ctx).recordDao().insert(entity);
            Log.d(TAG, "录音文件保存：" + currentFilePath);
        } catch (Exception e) {
            Log.e(TAG, "停止录音失败", e);
        }
    }

    /** 清理资源 */
    public void cleanup() {
        stopRecording();
    }

    /** AudioRecord 方案 */
    private void startAudioRecord() {
        int sampleRate = 16000;
        int chConfig = AudioFormat.CHANNEL_IN_MONO;
        int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
        int bufSize = AudioRecord.getMinBufferSize(sampleRate, chConfig, audioFormat) * 2;
        audioRecord = new AudioRecord(
                AudioSourceHelper.getAudioSource(),
                sampleRate, chConfig, audioFormat, bufSize);
        try {
            File dir = new File(ctx.getExternalFilesDir(null), "CallRec");
            if (!dir.exists()) dir.mkdirs();
            String ts = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault())
                    .format(new Date());
            currentFilePath = new File(dir,
                    ts + "_" + currentNumber + ".pcm").getAbsolutePath();
            DataOutputStream dos = new DataOutputStream(
                    new BufferedOutputStream(new FileOutputStream(currentFilePath)));
            audioRecord.startRecording();
            isRecording = true;
            recordThread = new Thread(() -> {
                byte[] buffer = new byte[bufSize];
                while (isRecording) {
                    int len = audioRecord.read(buffer, 0, buffer.length);
                    if (len > 0) {
                        try { dos.write(buffer, 0, len); }
                        catch (IOException ignored) {}
                    }
                }
                try { dos.close(); } catch (IOException ignored) {}
            });
            recordThread.start();
            Log.d(TAG, "AudioRecord 开始录音：" + currentFilePath);
        } catch (Exception e) {
            Log.e(TAG, "AudioRecord 方案失败", e);
        }
    }
}

// =================================================
// Class: AudioSourceHelper
// 说明：根据版本和机型，选择最佳录音音源，并可尝试私有 API
// =================================================
public class AudioSourceHelper {
    /** 动态获取可用音源 */
    public static int getAudioSource() {
        // Android P+ 默认不允许 VOICE_CALL
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            return MediaRecorder.AudioSource.MIC;
        }
        // 低版本尝试通话音源
        try {
            return MediaRecorder.AudioSource.VOICE_CALL;
        } catch (Exception ignored) {}
        return MediaRecorder.AudioSource.MIC;
    }
}

// =================================================
// Entity & Database：Room 持久化录音记录
// =================================================
@Entity(tableName = "records")
public class RecordEntity {
    @PrimaryKey(autoGenerate = true)
    public int id;
    public String phoneNumber;
    public String filePath;
    public long timestamp;

    public RecordEntity(int id, String phoneNumber, String filePath, long timestamp) {
        this.id = id;
        this.phoneNumber = phoneNumber;
        this.filePath = filePath;
        this.timestamp = timestamp;
    }
}

@Dao
interface RecordDao {
    @Query("SELECT * FROM records ORDER BY timestamp DESC")
    List<RecordEntity> getAll();
    @Insert
    void insert(RecordEntity record);
}

@Database(entities = {RecordEntity.class}, version = 1)
abstract class RecordDatabase extends RoomDatabase {
    private static RecordDatabase INSTANCE;
    public abstract RecordDao recordDao();

    public static synchronized RecordDatabase getInstance(Context ctx) {
        if (INSTANCE == null) {
            INSTANCE = Room.databaseBuilder(ctx.getApplicationContext(),
                    RecordDatabase.class, "call_rec_db")
                    .allowMainThreadQueries() // 简化示例：实际请异步
                    .build();
        }
        return INSTANCE;
    }
}

// =================================================
// Adapter: RecordAdapter
// 说明：ListView 适配器，展示历史录音
// =================================================
public class RecordAdapter extends BaseAdapter {
    private Context ctx;
    private List<RecordEntity> list;

    public RecordAdapter(Context ctx, List<RecordEntity> list) {
        this.ctx = ctx;
        this.list = list;
    }

    @Override public int getCount() { return list.size(); }
    @Override public Object getItem(int pos) { return list.get(pos); }
    @Override public long getItemId(int pos) { return list.get(pos).id; }

    @Override
    public View getView(int pos, View convertView, ViewGroup parent) {
        ViewHolder vh;
        if (convertView == null) {
            convertView = LayoutInflater.from(ctx)
                    .inflate(R.layout.item_record, parent, false);
            vh = new ViewHolder();
            vh.tvInfo = convertView.findViewById(R.id.tv_info);
            vh.btnPlay = convertView.findViewById(R.id.btn_play);
            convertView.setTag(vh);
        } else vh = (ViewHolder) convertView.getTag();

        RecordEntity rec = list.get(pos);
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
                .format(new Date(rec.timestamp));
        vh.tvInfo.setText(time + "  " + rec.phoneNumber);
        vh.btnPlay.setOnClickListener(v -> playAudio(rec.filePath));
        return convertView;
    }

    static class ViewHolder {
        TextView tvInfo;
        Button btnPlay;
    }

    /** 播放录音文件 */
    private void playAudio(String path) {
        try {
            MediaPlayer mp = new MediaPlayer();
            mp.setDataSource(path);
            mp.prepare();
            mp.start();
        } catch (Exception e) {
            Toast.makeText(ctx, "播放失败", Toast.LENGTH_SHORT).show();
        }
    }
}

/*
=======================================
XML: res/layout/activity_main.xml
=======================================
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout … >
    <Button
        android:id="@+id/btn_toggle"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="开始电话录音"/>
    <ListView
        android:id="@+id/lv_records"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</LinearLayout>

=======================================
XML: res/layout/item_record.xml
=======================================
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout … >
    <TextView
        android:id="@+id/tv_info"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"/>
    <Button
        android:id="@+id/btn_play"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="播放"/>
</LinearLayout>

=======================================
AndroidManifest.xml
=======================================
<?xml version="1.0" encoding="utf-8"?>
<manifest … >
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
    <!-- Android 9 以下需要写权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
        android:maxSdkVersion="28"/>

    <application … >
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <service
            android:name=".CallRecorderService"
            android:foregroundServiceType="microphone"/>
        <receiver android:name=".PhoneStateReceiver">
            <intent-filter>
                <action android:name="android.intent.action.PHONE_STATE"/>
            </intent-filter>
        </receiver>
    </application>
</manifest>
*/

// End of full code integration

五、代码解读（方法功能说明）

• MainActivity.requestPermissions()
  检查并申请 RECORD_AUDIO、READ_PHONE_STATE、WRITE_EXTERNAL_STORAGE（Android 9 以下）等必要权限，确保录音与通话状态监听能够正常工作。

• MainActivity.btnToggleRecording.OnClickListener
  点击按钮时，启动或停止 CallRecorderService，并更新按钮文案，让用户直观控制录音服务运行状态。

• CallRecorderService.onCreate()

  • 标记服务正在运行，并通过 TelephonyManager.listen() 注册 PhoneStateListener 监听通话状态。

  • 创建并启动前台通知，使服务具有较高优先级，不易被系统回收。

  • 同时注册 PhoneStateReceiver 作为备用机制，兼容某些机型通话状态回调遗漏。

• PhoneStateListener.onCallStateChanged()
  根据 CALL_STATE_RINGING、CALL_STATE_OFFHOOK、CALL_STATE_IDLE 三种状态，分别处理来电响铃、通话中启动录音、通话结束停止录音逻辑。

• PhoneStateReceiver.onReceive()
  监听系统广播 PHONE_STATE，在通话接起（OFFHOOK）时启动录音，在通话挂断（IDLE）时停止录音，确保双保险。

• RecordManager.startRecording(String)

  • 尝试使用 MediaRecorder：设置音源（通过 AudioSourceHelper 动态选择）、输出格式、编码器、文件路径等，启动录音。

  • 如 MediaRecorder 方案失败，则退而求其次调用 AudioRecord：配置采样率、声道、编码格式，启动线程循环读取 PCM 数据并写入文件。

• RecordManager.stopRecording()
  停止并释放 MediaRecorder 或 AudioRecord，写入数据库 RecordEntity，持久化录音元数据。

• AudioSourceHelper.getAudioSource()
  根据系统版本与兼容情况，动态返回最合适的录音音源，例如低版本尝试 VOICE_CALL，高版本强制回退到 MIC。

• RecordDatabase / RecordDao
  使用 Room 持久化录音文件信息，支持查询全部记录与插入新记录。

• RecordAdapter.getView()
  在 ListView 中展示每条录音的时间与电话号码，并提供“播放”按钮，调用 MediaPlayer 播放录音文件。

---

六、项目总结

1. 核心收获

   • 掌握 Android 通话状态监听的双保险机制：PhoneStateListener + BroadcastReceiver。

   • 深入理解 MediaRecorder 和 AudioRecord 两种录音方案的区别与兼容处理。

   • 学会在前台 Service 中维护录音进程，并通过通知与 UI 交互。

   • 熟悉 Room 数据库在小型业务场景下的快速集成方法。

2. 兼容性挑战

   • Android 9 及以上系统大幅限制通话录音音源，只能采集 MIC；需结合厂商私有 API 或 Root 方案。

   • 不同厂商的 ROM 对 VOICE_CALL、VOICE_DOWNLINK 支持不一致，需在 AudioSourceHelper 中增加更多机型判断与私有参数。

3. 可扩展方向

   • 私有 API 解禁：研究并调用 android.media.AudioSystem.setParameters("...") 解除系统对通话音源的屏蔽。

   • Root + Shell：在 Root 设备上，执行 su 并写入 chmod 或修改系统属性，以获得完整通话流。

   • 录音流在线传输：在服务端实时上传录音流，实现云端存储与回放。

   • 智能降噪与转写：结合第三方 SDK，对录音进行降噪处理，并实时转写文字。

   • UI 优化：使用 RecyclerView 与现代架构（MVVM + DataBinding / ViewBinding）重构，支持更多交互。

4. 注意事项

   • 法律与合规：通话录音涉及隐私，务必在录音前提示用户并征得对方同意；在某些地区甚至需要“双方同意”才合法。

   • 性能与稳定：录音线程与主线程要分离，避免卡顿；对异常（如 SD 卡满、权限被撤销）要有容错处理。

   • 电量与资源：持续运行录音服务会增加电量消耗，需在后台策略上设置合适的停止条件。

   • 安全：录音文件可能包含敏感信息，应提供加密存储或访问控制机制。