本篇先从概念上剖析了整个音频处理流程：采样-量化-编码-压缩编码。然后通过实例代码，分析如何使用 AudioRecord & MediaRecorder 在安卓手机上录制音频的详细过程。

基础知识

模拟信号

音频承载着声音信息，而声音是连续变化的信息。物理中把承载信息的载体称为信号，把连续变化的信息称为模拟信号，它在坐标轴中表现为如下形态：

计算机只能处理0和1，即离散值。音频这种模拟信号得转换成离散值才能被计算机处理。这个转化过程称为模拟信号数字化，分为三个步骤：

1. 采样

采样是对连续信号在时间上进行离散，即按照特定的时间间隔在原始的模拟信号上逐点采集瞬时值。采样的可视化效果如下图所示：

原本连续的曲线被一根根离散的竖直线条代替。这些线条越密集，将它们相连后形成的曲线就越接近原始模拟信号。

物理中用采样频率来表示采样的密集程度，即每秒采样次数(采样数/秒)，它用赫兹（Hz）表示

2. 量化

虽然连续值已被采样成若干离散值，但每个离散值的取值可能有无限多个。为了给每一个离散值都对应一个数字码，必须将无限种取值转化为有限种取值（对于只能处理二进制的计算机来说，取值的可能数应该是2的倍数）。物理中把这种通过四舍五入分级取整的方法称为量化。量化后的数字信号如下图所示：

量化后的音频变得死板有棱角，就好像人类和机器人的差别。

3. 编码

模拟信号经过采样变成离散值，每一个离散值经过量化都对应一个二进制，将这些二进制按时间序列组合在一起就称为编码。

经过采样量化编码形成的是音频的原始数据，这种原始数据格式称为PCM（Pulse Code Modulation），即是采样量化编码的英文表示。

.pcm 后缀的文件是非常非常大的，这增加了存储和网络传输的成本。遂 PCM 这样原始的无损音频还得经过一次压缩编码。

音频存在冗余信息，才能被压缩。比如人耳能辨识的声音频率范围为20Hz～20KHz，该频率以外的声音都是冗余信息。再比如强弱信号同时出现，强弱差距过大，以至于弱信号完全被掩盖，弱信号就是冗余信息。

音频有很多压缩编码的格式，以下是 Android 官方支持的格式：

在移动端最为常用的格式是 AAC，即 Advanced Audio Coding，是一种专为声音数据设计的文件压缩格式。它采用了更加高效的编码方式，使得它拥有和 MP3 相当的音质及更小的体积。

压缩编码由两种执行方式，交由 GPU 或是 CPU 执行，前者称为硬编码后者称为软编码，硬编码速度快，但兼容差，会存在编码失败的情况。软编码速度慢，但兼容性好。

录制 PCM 音频

Android 提供了两种录制音频的方式：1. MediaRecorder 2. AudioRecord

如果没有优化音频的需求，完全可以使用 MediaRecorder 直接输出 AAC 格式的音频。

而音频优化，比如降噪，增益算法都是基于 PCM 格式的。这就不得不使用 AudioRecord 来录制音频。

构建 AudioRecord 对象

AudioRecord 的构造函数包含 6 个参数：

音频源：表示从哪里采集音频，通常是麦克风。

采样频率：即每秒钟采用次数，44100 Hz是目前所有安卓设备都支持的采样频率。

声道数：表示声音由几个声道组成，单声道是目前所有安卓设备都支持的声道数。

量化精度：表示采用多少位二进制来表达一次量化的离散值，通常用 16 位。

缓冲区大小：表示在内存开辟一块多大的缓冲区用于存放硬件采集的音频数据。

构建 AudioRecord 的模板代码如下：

const val SOURCE = MediaRecorder.AudioSource.MIC //通过麦克风采集音频
const val SAMPLE_RATE = 44100 // 采样频率为 44100 Hz
const val CHANNEL_IN_MONO = AudioFormat.CHANNEL_IN_MONO // 单声道
const val ENCODING_PCM_16BIT = AudioFormat.ENCODING_PCM_16BIT //量化精度为 16 位
var bufferSize: Int = 0 // 音频缓冲区大小
val audioRecord by lazy {
    // 计算缓冲区大小
    bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
    // 构建 AudioRecord 实例
    AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
}

将构建 AudioRecord 的参数都常量化，以便在其他地方引用。其中缓冲区大小是通过AudioRecord.getMinBufferSize()动态计算的，计算的依据是采样平率、声道数、量化精度。

读取音频数据写入文件

有了 AudioRecord 实例，就可以调用它的方法从硬件设备中读取音频数据了。它提供了 3 个方法来控制音频数据的读取，分别是开始录制startRecording()、读一批音频数据read()、停止录制stop()，这 3 个方法通常用下面的模板来组合：

audioRecord.startRecording()
while(是否继续录制){ audioRecord.read() }
audioRecord.stop()

音频数据的大小以字节为单位，音频数据的读取是一批一批进行的，所以需要一个 while 循环持续不断地读取，每次读取多少字节由申请的缓冲区大小决定。

从硬件设备读取的音频字节先存放在字节数组中，然后再把字节数组写入文件就形成了 PCM 文件：

var bufferSize: Int = 0 // 音频缓冲区大小
val outputFile:File // pcm 文件
val audioRecord: AudioRecord
// 构建 pcm 文件输出流
outputFile.outputStream().use { outputStream ->
    // 开始录制
    audioRecord.startRecording()
    // 构建存放音频数据的字节数组
    val audioData = ByteArray(bufferSize)// 对应 java 中的 byte[]
    // 持续读取音频数据
    while (continueRecord()) {
        // 读一批音频数据到字节数组
        audioRecord.read(audioData, 0, audioData.size)
        // 将字节数组通过输出流写入 pcm 文件
        outputStream.write(audioData)
    }
    // 停止录制
    audioRecord.stop()
}

其中outputStream()是 File 的一个扩展方法，它使得代码语音更清晰，更连续：

public inline fun File.outputStream(): FileOutputStream {
    return FileOutputStream(this)
}

use()是一个 Closeable 的扩展方法，不管发生了什么，最终use()都会调用close()来关闭资源。这就避免了流操作的模板代码，降低了代码的复杂度：

public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    var exception: Throwable? = null
    try {
        // 在 try 代码块中执行传入的 lambda
        return block(this)
    } catch (e: Throwable) {
        exception = e
        throw e
    } finally {
        // 在 finally 中执行 close()
        when {
            apiVersionIsAtLeast(1, 1, 0) -> this.closeFinally(exception)
            this == null -> {}
            exception == null -> close()
            else ->
                try {
                    close()
                } catch (closeException: Throwable) {}
        }
    }
}

IO操作时耗时的，读写音频数据的代码应该在非UI线程中执行。而是否继续录制应该由用户动作触发，即UI线程触发。这里有多线程安全问题，需要一个线程安全的布尔值来控制音频录制：

var isRecording = AtomicBoolean(false) // 线程安全的布尔变量
val audioRecord: AudioRecord
// 是否继续录制
fun continueRecord(): Boolean {
    return isRecording.get() && 
           audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING
}
// 停止录制音频(供业务层调用以停止录音的 while 循环)
fun stop() {
    isRecording.set(false)
}

解耦抽象

将对 AudioRecord 的所有操作都抽象在一个接口中：

interface Recorder {
    var outputFormat: String // 输出音频格式
    fun isRecording(): Boolean // 是否正在录制
    fun getDuration(): Long // 获取音频时长
    fun start(outputFile: File, maxDuration: Int) // 开始录制
    fun stop() // 停止录制
    fun release() // 释放录制资源
}

这个接口提供了录制音频的抽象能力。当上层类和这组接口打交道时，不需要关心录制音频的实现细节，即不和 AudioRecord 耦合。

为啥要多一层这样的抽象？因为具体实现总是易变的，万一哪天业务层需要直接生成 AAC 文件，就可以通过添加一个Recorder的实例方便地地替换原有实现。

给出 AudioRecord 对于Recorder接口的实现：

class AudioRecorder(override var outputFormat: String) : Recorder {
    private var bufferSize: Int = 0 // 音频字节缓冲区大小
    private var isRecording = AtomicBoolean(false) // 用于控制音频录制的线程安全布尔值
    private var startTime = 0L // 记录音频开始录制时间
    private var duration = 0L // 音频时长
    // AudioRecord 实例
    private val audioRecord by lazy {
        bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
        AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
    }
    // 是否正在录制
    override fun isRecording(): Boolean = isRecording.get()
    // 获取音频时长
    override fun getDuration(): Long = duration
    // 开始音频录制
    override fun start(outputFile: File, maxDuration: Int) {
        if (audioRecord.state == AudioRecord.STATE_UNINITIALIZED) return
        isRecording.set(true) // 在异步线程中标记开始录制
        startTime.set(SystemClock.elapsedRealtime()) // 在异步线程中记录开始时间
        // 创建文件输出流
        outputFile.outputStream().use { outputStream ->
            // 开始录制
            audioRecord.startRecording()
            val audioData = ByteArray(bufferSize)
            // 持续读取音频数据到字节数组, 再将字节数组写入文件
            while (continueRecord(maxDuration)) {
                audioRecord.read(audioData, 0, audioData.size)
                outputStream.write(audioData)
            }
            // 循环结束后通知底层结束录制
            if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
                audioRecord.stop()
            }
            // 如果录音长度超过最大时长,则回调给上层
            if (duration >= maxDuration) handleRecordEnd(isSuccess = true, isReachMaxTime = true)
        }
    }
    // 判断录音是否可以继续
    private fun continueRecord(maxDuration: Int): Boolean {
        // 实时计算录音时长
        duration = SystemClock.elapsedRealtime() - startTime.get()
        return isRecording.get() && 
               audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING && 
               duration < maxDuration
    }
    // 停止录音(在UI线程调用)
    override fun stop() {
        isRecording.set(false)
    }
    // 释放录音资源
    override fun release() {
        audioRecord.release()
    }
}

下面是 MediaRecorder 对于Recorder接口的实现：

inner class MediaRecord(override var outputFormat: String) : Recorder {
    private var starTime = AtomicLong() // 音频录制开始时间
    // 监听录制是否超时的回调
    private val listener = MediaRecorder.OnInfoListener { _, what, _ ->
        when (what) {
            MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED -> {
                // 如果录制超时,则停止录制会回调上层
                stop()
                handleRecordEnd(isSuccess = true, isReachMaxTime = true)
            }
            else -> {
                handleRecordEnd(isSuccess = false, isReachMaxTime = false)
            }
        }
    }
    // 录制错误监听器
    private val errorListener = MediaRecorder.OnErrorListener { _, _, _ ->
        handleRecordEnd(isSuccess = false, isReachMaxTime = false)
    }
    private val recorder = MediaRecorder() 
    private var isRecording = AtomicBoolean(false) // 用于控制音频录制的线程安全布尔值
    private var duration = 0L // 音频时长
    // 判断是否正在录制音频
    override fun isRecording(): Boolean = isRecording.get()
    // 录制音频时长
    override fun getDuration(): Long = duration
    // 开始录制音频
    override fun start(outputFile: File, maxDuration: Int) {
        // 枚举音频输出格式
        val format = when (outputFormat) {
            AMR -> MediaRecorder.OutputFormat.AMR_NB
            else -> MediaRecorder.OutputFormat.AAC_ADTS
        }
        // 枚举音频编码格式
        val encoder = when (outputFormat) {
            AMR -> MediaRecorder.AudioEncoder.AMR_NB
            else -> MediaRecorder.AudioEncoder.AAC
        }
        // 开始录制
        starTime.set(SystemClock.elapsedRealtime())
        isRecording.set(true)
        recorder.apply {
            reset()
            setAudioSource(MediaRecorder.AudioSource.MIC)
            setOutputFormat(format)
            setOutputFile(outputFile.absolutePath)
            setAudioEncoder(encoder)
            setOnInfoListener(listener)
            setOnErrorListener(errorListener)
            setMaxDuration(maxDuration)
            prepare()
            start()
        }
    }
    // 停止录制
    override fun stop() {
        recorder.stop()
        isRecording.set(false)
        duration = SystemClock.elapsedRealtime() - starTime.get()
    }
    // 释放录制资源
    override fun release() {
        recorder.release()
    }
}

把和Recorder接口打交道的上层类定义为AudioManager，它是业务层访问音频能力的入口，提供了一组访问接口：

// 构造 AudioManager 时需传入上下文和音频输出格式
class AudioManager(val context: Context, val type: String = AAC) {
    companion object {
        const val AAC = "aac"
        const val AMR = "amr"
        const val PCM = "pcm"
    }
    private var maxDuration = 120 * 1000 // 默认最大音频时长为 120 s
    // 根据输出格式实例化对应 Recorder 实例
    private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
    // 开始录制
    fun start(maxDuration: Int = 120) {
        this.maxDuration = maxDuration * 1000
        startRecord()
    }
    // 停止录制
    fun stop(cancel: Boolean = false) {
        stopRecord(cancel)
    }
    // 释放资源
    fun release() {
        recorder.release()
    }
    // 是否正在录制
    fun isRecording() = recorder.isRecording()
}

其中的startRecord()和stopRecord()包含了AudioManager层控制播放的逻辑：

class AudioManager(val context: Context, val type: String = AAC) :
    // 为了方便启动协程录制,直接继承 CoroutineScope,并调度协程到一个单线程线程池对应的 Dispatcher
    CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
    private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
    // 开始录制
    private fun startRecord() {
        // 请求音频焦点
        audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
        // 若音频正在录制,则返回
        if (recorder.isRecording()) {
            setState(STATE_FAILED) // 设置状态为失败
            return
        }
        // 如果储存卡控件不足,则返回
        if (getFreeSpace() <= 0) {
            setState(STATE_FAILED) // 设置状态为失败
            return
        }
        // 创建音频文件
        audioFile = getAudioFile()
        // 若创建失败,则返回
        if (audioFile == null) setState(STATE_FAILED) // 设置状态为失败
        cancelRecord.set(false)
        try {
            if (! cancelRecord.get()) {
                setState(STATE_READY) // 设置状态为就绪
                if (hasPermission()) { // 拥有录制和存储权限
                    // 启动协程开始录制
                    launch { recorder.start(audioFile !!, maxDuration) }
                    setState(STATE_START) // 设置状态为开始
                } else {
                    stopRecord(false) // 没有权限则停止录制
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
            stopRecord(false) // 发生异常时,停止录制
        }
    }
    // 停止录制,需传入是否是用户主动取消录制
    private fun stopRecord(cancel: Boolean) {
        // 若不在录制中,则返回
        if (! recorder.isRecording()) {
            return
        }
        cancelRecord.set(cancel)
        // 放弃音频焦点
        audioManager.abandonAudioFocus(null)
        try {
            // 停止录音
            recorder.stop()
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            // 录音结束后,回调状态
            handleRecordEnd(isSuccess = true, isReachMaxTime = false)
        }
    }
}

因为AudioManager是和业务层打交道的类，所以这一层就多了些零碎的控制逻辑，包括音频焦点的获取、存储和录音权限的判断、创建时声音文件、录音状态的回调。

其中录音状态的回调被定义成了若干个 lambda：

class AudioManager(val context: Context, val type: String = AAC) :
    CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
    // 状态常量
    private val STATE_FAILED = 1
    private val STATE_READY = 2
    private val STATE_START = 3
    private val STATE_SUCCESS = 4
    private val STATE_CANCELED = 5
    private val STATE_REACH_MAX_TIME = 6
    // 主线程 Handler,用于将状态回调在主线程
    private val callbackHandler = Handler(Looper.getMainLooper())
    // 将录音状态回调给业务层的 lambda
    var onRecordReady: (() -> Unit)? = null
    var onRecordStart: ((File) -> Unit)? = null
    var onRecordSuccess: ((File, Long) -> Unit)? = null
    var onRecordFail: (() -> Unit)? = null
    var onRecordCancel: (() -> Unit)? = null
    var onRecordReachedMaxTime: ((Int) -> Unit)? = null
    // 状态变更
    private fun setState(state: Int) {
        callbackHandler.post {
            when (state) {
                STATE_FAILED -> onRecordFail?.invoke()
                STATE_READY -> onRecordReady?.invoke()
                STATE_START -> audioFile?.let { onRecordStart?.invoke(it) }
                STATE_CANCELED -> onRecordCancel?.invoke()
                STATE_SUCCESS -> audioFile?.let { onRecordSuccess?.invoke(it, recorder.getDuration()) }
                STATE_REACH_MAX_TIME -> onRecordReachedMaxTime?.invoke(maxDuration)
            }
        }
    }
}

将状态分发回调的细节分装在setState()方法中，以降低录音流程控制代码的复杂度。

完整的AudioManager代码如下：

import android.content.Context
import android.content.pm.PackageManager
import android.media.AudioFormat
import android.media.AudioFormat.CHANNEL_IN_MONO
import android.media.AudioFormat.ENCODING_PCM_16BIT
import android.media.AudioManager
import android.media.AudioRecord
import android.media.MediaRecorder
import android.os.*
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.launch
import java.io.File
import java.util.*
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
/**
 * provide the ability to record audio in file.
 * [AudioManager] exists for the sake of the following:
 * 1. launch a thread to record audio in file.
 * 2. control the state of recording and invoke according callbacks in main thread.
 * 3. provide interface for the business layer to control audio recording
 */
class AudioManager(val context: Context, val type: String = AAC) :
    CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
    companion object {
        const val AAC = "aac"
        const val AMR = "amr"
        const val PCM = "pcm"
        const val SOURCE = MediaRecorder.AudioSource.MIC
        const val SAMPLE_RATE = 44100
        const val CHANNEL = 1
    }
    private val STATE_FAILED = 1
    private val STATE_READY = 2
    private val STATE_START = 3
    private val STATE_SUCCESS = 4
    private val STATE_CANCELED = 5
    private val STATE_REACH_MAX_TIME = 6
    /**
     * the callback business layer cares about
     */
    var onRecordReady: (() -> Unit)? = null
    var onRecordStart: ((File) -> Unit)? = null
    var onRecordSuccess: ((File, Long) -> Unit)? = null// deliver audio file and duration to business layer
    var onRecordFail: (() -> Unit)? = null
    var onRecordCancel: (() -> Unit)? = null
    var onRecordReachedMaxTime: ((Int) -> Unit)? = null
    /**
     * deliver recording state to business layer
     */
    private val callbackHandler = Handler(Looper.getMainLooper())
    private var maxDuration = 120 * 1000
    private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
    private var audioFile: File? = null
    private var cancelRecord: AtomicBoolean = AtomicBoolean(false)
    private val audioManager: AudioManager = context.applicationContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
    fun start(maxDuration: Int = 120) {
        this.maxDuration = maxDuration * 1000
        startRecord()
    }
    fun stop(cancel: Boolean = false) {
        stopRecord(cancel)
    }
    fun release() {
        recorder.release()
    }
    fun isRecording() = recorder.isRecording()
    private fun startRecord() {
        audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
        if (recorder.isRecording()) {
            setState(STATE_FAILED)
            return
        }
        if (getFreeSpace() <= 0) {
            setState(STATE_FAILED)
            return
        }
        audioFile = getAudioFile()
        if (audioFile == null) setState(STATE_FAILED)
        cancelRecord.set(false)
        try {
            if (! cancelRecord.get()) {
                setState(STATE_READY)
                if (hasPermission()) {
                    launch { recorder.start(audioFile !!, maxDuration) }
                    setState(STATE_START)
                } else {
                    stopRecord(false)
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
            stopRecord(false)
        }
    }
    private fun hasPermission(): Boolean {
        return context.checkCallingOrSelfPermission(android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
                && context.checkCallingOrSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
    }
    private fun stopRecord(cancel: Boolean) {
        if (! recorder.isRecording()) {
            return
        }
        cancelRecord.set(cancel)
        audioManager.abandonAudioFocus(null)
        try {
            recorder.stop()
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            handleRecordEnd(isSuccess = true, isReachMaxTime = false)
        }
    }
    private fun handleRecordEnd(isSuccess: Boolean, isReachMaxTime: Boolean) {
        if (cancelRecord.get()) {
            audioFile?.deleteOnExit()
            setState(STATE_CANCELED)
        } else if (! isSuccess) {
            audioFile?.deleteOnExit()
            setState(STATE_FAILED)
        } else {
            if (isAudioFileInvalid()) {
                setState(STATE_FAILED)
                if (isReachMaxTime) {
                    setState(STATE_REACH_MAX_TIME)
                }
            } else {
                setState(STATE_SUCCESS)
            }
        }
    }
    private fun isAudioFileInvalid() = audioFile == null || ! audioFile !!.exists() || audioFile !!.length() <= 0
    /**
     * change recording state and invoke according callback to main thread
     */
    private fun setState(state: Int) {
        callbackHandler.post {
            when (state) {
                STATE_FAILED -> onRecordFail?.invoke()
                STATE_READY -> onRecordReady?.invoke()
                STATE_START -> audioFile?.let { onRecordStart?.invoke(it) }
                STATE_CANCELED -> onRecordCancel?.invoke()
                STATE_SUCCESS -> audioFile?.let { onRecordSuccess?.invoke(it, recorder.getDuration()) }
                STATE_REACH_MAX_TIME -> onRecordReachedMaxTime?.invoke(maxDuration)
            }
        }
    }
    private fun getFreeSpace(): Long {
        if (Environment.MEDIA_MOUNTED != Environment.getExternalStorageState()) {
            return 0L
        }
        return try {
            val stat = StatFs(context.getExternalFilesDir(Environment.DIRECTORY_MUSIC)?.absolutePath)
            stat.run { blockSizeLong * availableBlocksLong }
        } catch (e: Exception) {
            0L
        }
    }
    private fun getAudioFile(): File? {
        val audioFilePath = context.getExternalFilesDir(Environment.DIRECTORY_MUSIC)?.absolutePath
        if (audioFilePath.isNullOrEmpty()) return null
        return File("$audioFilePath${File.separator}${UUID.randomUUID()}.$type")
    }
    /**
     * the implementation of [Recorder] define the detail of how to record audio.
     * [AudioManager] works with [Recorder] and dont care about the recording details
     */
    interface Recorder {
        /**
         * audio output format
         */
        var outputFormat: String
        /**
         * whether audio is recording
         */
        fun isRecording(): Boolean
        /**
         * the length of audio
         */
        fun getDuration(): Long
        /**
         * start audio recording, it is time-consuming
         */
        fun start(outputFile: File, maxDuration: Int)
        /**
         * stop audio recording
         */
        fun stop()
        /**
         * release the resource of audio recording
         */
        fun release()
    }
    /**
     * record audio by [android.media.MediaRecorder]
     */
    inner class MediaRecord(override var outputFormat: String) : Recorder {
        private var starTime = AtomicLong()
        private val listener = MediaRecorder.OnInfoListener { _, what, _ ->
            when (what) {
                MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED -> {
                    stop()
                    handleRecordEnd(isSuccess = true, isReachMaxTime = true)
                }
                else -> {
                    handleRecordEnd(isSuccess = false, isReachMaxTime = false)
                }
            }
        }
        private val errorListener = MediaRecorder.OnErrorListener { _, _, _ ->
            handleRecordEnd(isSuccess = false, isReachMaxTime = false)
        }
        private val recorder = MediaRecorder()
        private var isRecording = AtomicBoolean(false)
        private var duration = 0L
        override fun isRecording(): Boolean = isRecording.get()
        override fun getDuration(): Long = duration
        override fun start(outputFile: File, maxDuration: Int) {
            val format = when (outputFormat) {
                AMR -> MediaRecorder.OutputFormat.AMR_NB
                else -> MediaRecorder.OutputFormat.AAC_ADTS
            }
            val encoder = when (outputFormat) {
                AMR -> MediaRecorder.AudioEncoder.AMR_NB
                else -> MediaRecorder.AudioEncoder.AAC
            }
            starTime.set(SystemClock.elapsedRealtime())
            isRecording.set(true)
            recorder.apply {
                reset()
                setAudioSource(MediaRecorder.AudioSource.MIC)
                setOutputFormat(format)
                setOutputFile(outputFile.absolutePath)
                setAudioEncoder(encoder)
                if (outputFormat == AAC) {
                    setAudioSamplingRate(22050)
                    setAudioEncodingBitRate(32000)
                }
                setOnInfoListener(listener)
                setOnErrorListener(errorListener)
                setMaxDuration(maxDuration)
                prepare()
                start()
            }
        }
        override fun stop() {
            recorder.stop()
            isRecording.set(false)
            duration = SystemClock.elapsedRealtime() - starTime.get()
        }
        override fun release() {
            recorder.release()
        }
    }
    /**
     * record audio by [android.media.AudioRecord]
     */
    inner class AudioRecorder(override var outputFormat: String) : Recorder {
        private var bufferSize: Int = 0
        private var isRecording = AtomicBoolean(false)
        private var startTime = AtomicLong()
        private var duration = 0L
        private val audioRecord by lazy {
            bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
            AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
        }
        override fun isRecording(): Boolean = isRecording.get()
        override fun getDuration(): Long = duration
        override fun start(outputFile: File, maxDuration: Int) {
            if (audioRecord.state == AudioRecord.STATE_UNINITIALIZED) return
            isRecording.set(true)
            startTime.set(SystemClock.elapsedRealtime())
            outputFile.outputStream().use { outputStream ->
                audioRecord.startRecording()
                val audioData = ByteArray(bufferSize)
                while (continueRecord(maxDuration)) {
                    audioRecord.read(audioData, 0, audioData.size)
                    outputStream.write(audioData)
                }
                if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
                    audioRecord.stop()
                }
                if (duration >= maxDuration) handleRecordEnd(isSuccess = true, isReachMaxTime = true)
            }
        }
        private fun continueRecord(maxDuration: Int): Boolean {
            duration = SystemClock.elapsedRealtime() - startTime.get()
            return isRecording.get() && audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING && duration < maxDuration
        }
        override fun stop() {
            isRecording.set(false)
        }
        override fun release() {
            audioRecord.release()
        }
    }
}

下一篇会接着这个主题，继续分析如何利用 MediaCodec 将 PCM 文件进行硬编码转换成 AAC 文件。

talk is cheap, show me the code

完整代码在这个repo中的AudioManager类中

Android 音频（一） | 采样量化编码 & AudioRecord 录制音频

基础知识

模拟信号

1. 采样

2. 量化

3. 编码

录制 PCM 音频

构建 AudioRecord 对象

读取音频数据写入文件

解耦抽象

talk is cheap, show me the code

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Android 音频（一） | 采样量化编码 & AudioRecord 录制音频

基础知识

模拟信号

1. 采样

2. 量化

3. 编码

录制 PCM 音频

构建 AudioRecord 对象

读取音频数据写入文件

解耦抽象

talk is cheap, show me the code

热门文章

最新文章

相关课程

相关电子书