this.getHolder().addCallback();
this.getHolder().getSurface()

setSurfaceTextureListener();
Surface surface = new Surface(getSurfaceTexture());

// 根据指定采样率、声道数、位数获取最小需要的缓冲区大小，后续再创建AudioTrack时设置的缓冲区大小必须大于这个值
// 如果想要将缓冲区设大一点，比如 bufferSizeFactor = 1.5
final int minBufferSizeInBytes = (int) (AudioTrack.getMinBufferSize(sampleRate, channelConfig,
                                                AudioFormat.ENCODING_PCM_16BIT) * bufferSizeFactor);

// 一个音频帧的字节大小 = 声道数 *（位数 /8）  
final int bytesPerFrame = channels * (BITS_PER_SAMPLE / 8);

// 创建buffer用来存放每一次要写入的数据，使用堆外内存，避免JNI内存拷贝
// BUFFERS_PER_SECOND = 100，预测一秒钟回调100次
// 那么44100的采样率，每次回调应该给的数据帧个数为4410个
byteBuffer = ByteBuffer.allocateDirect(bytesPerFrame * (sampleRate / BUFFERS_PER_SECOND));
    
AudioTrack audioTrack;
if (Build.VERSION.SDK_INT >= 21) {
    // AudioFormat是对音频的格式进行封装，包括采样率、声道数、位数等。
    // AudioAttributes是对播放内容的描述
    audioTrack = new AudioTrack(
            new AudioAttributes.Builder()
                    // 音频的用途
                    .setUsage(usageAttribute)
                    // 音频内容的类型
                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                    .build(),
            new AudioFormat.Builder()
                    // 位数
                    .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
                    // 采样率
                    .setSampleRate(sampleRateInHz)
                    // 声道数
                    .setChannelMask(channelConfig)
                    .build(),
            bufferSizeInBytes,// 缓冲区大小
            AudioTrack.MODE_STREAM,// 模式
            // 生成新的会话ID
            AudioManager.AUDIO_SESSION_ID_GENERATE );


} else {
    // 构造参数：
    //      音频流类型
    //      采样率
    //      声道数
    //      位数
    //      缓冲区大小
    //      模式 : MODE_STATIC 预先将需要播放的音频数据读取到内存中，然后才开始播放。MODE_STREAM 边读边播，不会将数据直接加载到内存
    audioTrack = new AudioTrack(AudioManager.STREAM_VOICE_CALL, sampleRateInHz, channelConfig,
            AudioFormat.ENCODING_PCM_16BIT, bufferSizeInBytes, AudioTrack.MODE_STREAM);
   
}

if (audioTrack == null || audioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
    // 创建失败
}

// 遍历所有的camera设备
for (int index = 0; index < android.hardware.Camera.getNumberOfCameras(); ++index) {
  // 获取camera设备信息
  android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
  android.hardware.Camera.getCameraInfo(index, info);
  String facing =
        (info.facing == android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT) ? "front" : "back"; 
  final android.hardware.Camera camera;
  try {
      // 开启camera设备，获取camera实例
      camera = android.hardware.Camera.open(cameraId);
  } catch (RuntimeException e) {
      callback.onFailure(FailureType.ERROR, e.getMessage());
      return;
  }
}

// 一个音频帧的字节大小 = 声道数 *（位数 /8）
final int bytesPerFrame = channels * (BITS_PER_SAMPLE / 8);
// BUFFERS_PER_SECOND = 100，预测一秒钟回调100次
// 那么44100的采样率，每次回调应该给的数据帧个数为4410个
final int framesPerBuffer = sampleRate / BUFFERS_PER_SECOND;
// 一次回调给的总数据字节大小 = 一次给的数据帧个数 * 一个数据帧的字节大小
// 创建一个buffer用来接收回调数据，使用堆外内存，在通过JNI传递的时候避免内存拷贝
byteBuffer = ByteBuffer.allocateDirect(bytesPerFrame * framesPerBuffer);
   
emptyBytes = new byte[byteBuffer.capacity()];
// 避免每次读取数据都需要传递buffer到JNI层，这里提前将buffer的地址保存在JNI层
nativeCacheDirectBufferAddress(byteBuffer, nativeAudioRecord);

final int channelConfig = channelCountToConfiguration(channels);
// 根据音频参数(采样率，声道数，位数)得到系统最小需要的缓冲区大小，创建AudioRecord时设置的缓冲区大小必须大于这个值
int minBufferSize =
    AudioRecord.getMinBufferSize(sampleRate, channelConfig, AudioFormat.ENCODING_PCM_16BIT); 

// BUFFER_SIZE_FACTOR = 2
// 缓冲区一般要大一点，所以下面比较了两倍的最小缓冲区和我们自己计算的缓冲区大小
// 也就是说设置的缓冲区大小最小也要是最小缓冲区的两倍。
int bufferSizeInBytes = Math.max(BUFFER_SIZE_FACTOR * minBufferSize, byteBuffer.capacity());
try {
  // 根据音频参数创建AudioRecord，audioSource是指音频采集的来源
  audioRecord = new AudioRecord(audioSource, sampleRate, channelConfig,
      AudioFormat.ENCODING_PCM_16BIT, bufferSizeInBytes);
} catch (IllegalArgumentException e) {
  return -1;
}
if (audioRecord == null || audioRecord.getState() != AudioRecord.STATE_INITIALIZED) {
  return -1;
}