本文属于Android局域网内的语音对讲项目系列，《通过UDP广播实现Android局域网Peer Discovering》实现了局域网内的广播及多播通信，本文将重点说明系统架构，音频信号的实时录制、播放及编解码相关技术。

本文主要包含以下内容：

1. AudioRecord、AudioTrack
2. Speex编解码
3. Android语音对讲系统架构

一、AudioRecord、AudioTrack

AudioRecorder和AudioTracker是Android中获取实时音频数据的接口。在网络电话、语音对讲等场景中，由于实时性的要求，不能采用文件传输，因此，MediaRecorder和MediaPlayer就无法使用。

AudioRecorder和AudioTracker是Android在Java层对libmedia库的封装，所以效率较高，适合于实时语音相关处理的应用。在使用时，AudioRecorder和AudioTracker的构造器方法入参较多，这里对其进行详细的解释。

AudioRecord

public AudioRecord(int audioSource, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes)

其中，audioSource表示录音来源，在AudioSource中列举了不同的音频来源，包括：

1. AudioSource.DEFAULT:默认音频来源

2. AudioSource.MIC:麦克风（常用）

3. AudioSource.VOICE_UPLINK:电话上行

4. AudioSource.VOICE_DOWNLINK:电话下行

5. AudioSource.VOICE_CALL:电话、含上下行

6. AudioSource.CAMCORDER:摄像头旁的麦克风

7. AudioSource.VOICE_RECOGNITION:语音识别

8. AudioSource.VOICE_COMMUNICATION:语音通信

这里比较常用的有MIC，VOICE_COMMUNICATION和VOICE_CALL。

sampleRateInHz表示采样频率。音频的采集过程要经过抽样、量化和编码三步。抽样需要关注抽样率。声音是机械波，其特征主要包括频率和振幅（即音调和音量），频率对应时间轴线，振幅对应电平轴线。采样是指间隔固定的时间对波形进行一次记录，采样率就是在1秒内采集样本的次数。量化过程就是用数字表示振幅的过程。编码是一个减少信息量的过程，任何数字音频编码方案都是有损的。PCM编码（脉冲编码调制）是一种保真水平较高的编码方式。在Android平台，44100Hz是唯一目前所有设备都保证支持的采样频率。但比如22050、16000、11025也在大多数设备上得到支持。8000是针对某些低质量的音频通信使用的。

channelConfig表示音频通道，即选择单声道、双声道等参数。系统提供的选择如下：

1. public static final int CHANNEL_IN_DEFAULT = 1;

2. // These directly match native

3. public static final int CHANNEL_IN_LEFT = 0x4;

4. public static final int CHANNEL_IN_RIGHT = 0x8;

5. public static final int CHANNEL_IN_FRONT = 0x10;

6. public static final int CHANNEL_IN_BACK = 0x20;

7. public static final int CHANNEL_IN_LEFT_PROCESSED = 0x40;

8. public static final int CHANNEL_IN_RIGHT_PROCESSED = 0x80;

9. public static final int CHANNEL_IN_FRONT_PROCESSED = 0x100;

10. public static final int CHANNEL_IN_BACK_PROCESSED = 0x200;

11. public static final int CHANNEL_IN_PRESSURE = 0x400;

12. public static final int CHANNEL_IN_X_AXIS = 0x800;

13. public static final int CHANNEL_IN_Y_AXIS = 0x1000;

14. public static final int CHANNEL_IN_Z_AXIS = 0x2000;

15. public static final int CHANNEL_IN_VOICE_UPLINK = 0x4000;

16. public static final int CHANNEL_IN_VOICE_DNLINK = 0x8000;

17. public static final int CHANNEL_IN_MONO = CHANNEL_IN_FRONT;

18. public static final int CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT);

常用的是CHANNEL_IN_MONO和CHANNEL_IN_STEREO分别表示单通道输入和左右两通道输入。

audioFormat指定返回音频数据的格式，常见的选择包括ENCODING_PCM_16BIT、ENCODING_PCM_8BIT和ENCODING_PCM_FLOAT。ENCODING_PCM_16BIT表示PCM 16bits每个样本，所有设备保证支持。ENCODING_PCM_8BIT自然表示PCM 8bits每个样本。ENCODING_PCM_FLOAT表示一个单精度浮点数表示一个样本。

bufferSizeInBytes表示录音时音频数据写入的buffer的大小。这个数值是通过另一个方法来获取的：getMinBufferSize。getMinBufferSize是AudioRecord类的静态方法，返回值就是bufferSizeInBytes。这里我们来看下它的入参：

static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat)

sampleRateInHz, channelConfig, audioFormat三个参数与上面的含义完全一样，代表录音的采样率、通道以及数据输出的格式。综上，AudioRecord的初始化方法如下：

1. // 获取音频数据缓冲段大小

2. inAudioBufferSize = AudioRecord.getMinBufferSize(

3. Constants.sampleRateInHz, Constants.inputChannelConfig, Constants.audioFormat);

4. // 初始化音频录制

5. audioRecord = new AudioRecord(Constants.audioSource,

6. Constants.sampleRateInHz, Constants.inputChannelConfig, Constants.audioFormat, inAudioBufferSize);

其中，参数设置如下：

1. // 采样频率，44100保证兼容性

2. public static final int sampleRateInHz = 44100;

3. // 音频数据格式:PCM 16位每个样本，保证设备支持。

4. public static final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;

5. // 音频获取源

6. public static final int audioSource = MediaRecorder.AudioSource.MIC;

7. // 输入单声道

8. public static final int inputChannelConfig = AudioFormat.CHANNEL_IN_MONO;

AudioTrack

1. public AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat,

2. int bufferSizeInBytes, int mode) throws IllegalArgumentException {

3. this(streamType, sampleRateInHz, channelConfig, audioFormat,

4. bufferSizeInBytes, mode, AudioManager.AUDIO_SESSION_ID_GENERATE);

5. }

与AudioRecord类似，AudioTrack的构造器方法依然有很多需要选择的参数。其中，streamType表示音频流播放类型，AudioManager中列出了可选的类型如下：

1. /** The audio stream for phone calls */

2. public static final int STREAM_VOICE_CALL = AudioSystem.STREAM_VOICE_CALL;

3. /** The audio stream for system sounds */

4. public static final int STREAM_SYSTEM = AudioSystem.STREAM_SYSTEM;

5. /** The audio stream for the phone ring */

6. public static final int STREAM_RING = AudioSystem.STREAM_RING;

7. /** The audio stream for music playback */

8. public static final int STREAM_MUSIC = AudioSystem.STREAM_MUSIC;

9. /** The audio stream for alarms */

10. public static final int STREAM_ALARM = AudioSystem.STREAM_ALARM;

11. /** The audio stream for notifications */

12. public static final int STREAM_NOTIFICATION = AudioSystem.STREAM_NOTIFICATION;

13. /** @hide The audio stream for phone calls when connected to bluetooth */

14. public static final int STREAM_BLUETOOTH_SCO = AudioSystem.STREAM_BLUETOOTH_SCO;

15. /** @hide The audio stream for enforced system sounds in certain countries (e.g camera in Japan) */

16. public static final int STREAM_SYSTEM_ENFORCED = AudioSystem.STREAM_SYSTEM_ENFORCED;

17. /** The audio stream for DTMF Tones */

18. public static final int STREAM_DTMF = AudioSystem.STREAM_DTMF;

19. /** @hide The audio stream for text to speech (TTS) */

20. public static final int STREAM_TTS = AudioSystem.STREAM_TTS;

常用的有STREAM_VOICE_CALL，STREAM_MUSIC等，需要根据应用特点进行选择。

sampleRateInHz和audioFormat需与AudioRecord中的参数保持一致，这里不再介绍。

channelConfig与AudioRecord中的参数保持对应，比如AudioRecord选择了AudioFormat.CHANNEL_IN_MONO（单通道音频输入），这里需要选择AudioFormat.CHANNEL_OUT_MONO（单通道音频输出）。

bufferSizeInBytes表述音频播放缓冲区大小，同样，也需要根据AudioTrack的静态方法getMinBufferSize来获取。

static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) 

sampleRateInHz, channelConfig, audioFormat三个参数与上面的含义完全一样，代表输出音频的采样率、通道以及数据输出的格式。

最后说明下mode和AudioManager.AUDIO_SESSION_ID_GENERATE。mode代表音频输出的模式：MODE_STATIC或MODE_STREAM，分别表示静态模式和流模式。AudioManager.AUDIO_SESSION_ID_GENERATE表示AudioSessionId，即AudioTrack依附到哪个音频会话。

比如，要给AudioRecord添加回声消除AcousticEchoCanceler，AcousticEchoCanceler的构建方法create的入参就是sessionId，通过AudioRecord实例的getAudioSessionId()方法获取。

综上，AudioTrack的初始化方法如下：

1. public Tracker() {

2. // 获取音频数据缓冲段大小

3. outAudioBufferSize = AudioTrack.getMinBufferSize(

4. Constants.sampleRateInHz, Constants.outputChannelConfig, Constants.audioFormat);

5. // 初始化音频播放

6. audioTrack = new AudioTrack(Constants.streamType,

7. Constants.sampleRateInHz, Constants.outputChannelConfig, Constants.audioFormat,

8. outAudioBufferSize, Constants.trackMode);

9. }

其中，参数设置如下：

1. // 音频播放端

2. public static final int streamType = AudioManager.STREAM_VOICE_CALL;

3. // 输出单声道

4. public static final int outputChannelConfig = AudioFormat.CHANNEL_OUT_MONO;

5. // 音频输出模式

6. public static final int trackMode = AudioTrack.MODE_STREAM;

二、Speex编解码

Speex是一个声音编码格式，目标是用于网络电话、线上广播使用的语音编码，基于CELP（一种语音编码算法）开发，Speex宣称可以免费使用，以BSD授权条款开放源代码。

Speex是由C语言开发的音频处理库，在Android中使用，需要通过JNI来调用。因此，对NDK开发不熟悉的朋友，可以先了解下文档：向您的项目添加 C 和 C++ 代码。

在Android Studio中使用C/C++库有两种方式：cmake和ndk-build。cmake是最新支持的方法，通过配置CMakeLists.txt文件来实现；ndk-build是传统的方式，通过配置Android.mk文件来实现。具体语法参考相关文档，这里不做深入介绍。配置完上述文件之后，需要将Gradle关联到原生库，通过AS的Link C++ Project with Gradle功能实现。

完成上述配置之后，正式开始在Android中使用Speex进行音频编解码。主要包括以下步骤：

1. 下载Speex源码。推荐使用Speex 1.2.0稳定版，由于目前Speex 已不再继续维护，官方建议使用Opus。但在某些场合，使用Speex已然足够满足需求。
2. 在src/main下创建jni文件夹，将上述Speex源码中include和libspeex文件夹拷贝到jni文件夹下。

3. 编写Android.mk文件和Application.mk文件。
   Android.mk：

   1. LOCAL_PATH := $(call my-dir)

   2. include $(CLEAR_VARS)

   3. LOCAL_LDLIBS :=-llog

   4. LOCAL_MODULE := libspeex

   5. LOCAL_CFLAGS = -DFIXED_POINT -DUSE_KISS_FFT -DEXPORT="" -UHAVE_CONFIG_H

   6. LOCAL_C_INCLUDES := $(LOCAL_PATH)/include

   7. LOCAL_SRC_FILES := speex_jni.cpp \

   8. ./libspeex/bits.c \

   9. ./libspeex/cb_search.c \

   10. ./libspeex/exc_10_16_table.c \

   11. ./libspeex/exc_10_32_table.c \

   12. ./libspeex/exc_20_32_table.c \

   13. ./libspeex/exc_5_256_table.c \

   14. ./libspeex/exc_5_64_table.c \

   15. ./libspeex/exc_8_128_table.c \

   16. ./libspeex/filters.c \

   17. ./libspeex/gain_table_lbr.c \

   18. ./libspeex/gain_table.c \

   19. ./libspeex/hexc_10_32_table.c \

   20. ./libspeex/hexc_table.c \

   21. ./libspeex/high_lsp_tables.c \

   22. ./libspeex/kiss_fft.c \

   23. ./libspeex/kiss_fftr.c \

   24. ./libspeex/lpc.c \

   25. ./libspeex/lsp_tables_nb.c \

   26. ./libspeex/lsp.c \

   27. ./libspeex/ltp.c \

   28. ./libspeex/modes_wb.c \

   29. ./libspeex/modes.c \

   30. ./libspeex/nb_celp.c \

   31. ./libspeex/quant_lsp.c \

   32. ./libspeex/sb_celp.c \

   33. ./libspeex/smallft.c \

   34. ./libspeex/speex_callbacks.c \

   35. ./libspeex/speex_header.c \

   36. ./libspeex/speex.c \

   37. ./libspeex/stereo.c \

   38. ./libspeex/vbr.c \

   39. ./libspeex/vorbis_psy.c \

   40. ./libspeex/vq.c \

   41. ./libspeex/window.c \

   42. include $(BUILD_SHARED_LIBRARY)

   Application.mk：

   APP_ABI := armeabi armeabi-v7a

4. 新建speex_config_types.h文件。在jni中speex源码目录下的include/speex文件夹下，有一个speex_config_types.h.in文件，在include/speex目录下创建speex_config_types.h，把speex_config_types.h.in的内容拷贝过来，然后把@SIZE16@改成short,把@SIZE32@改成int，对应标准C/C++数据类型。这个文件的内容如下：

   1. #ifndef __SPEEX_TYPES_H__

   2. #define __SPEEX_TYPES_H__

   3. typedef short spx_int16_t;

   4. typedef unsigned short spx_uint16_t;

   5. typedef int spx_int32_t;

   6. typedef unsigned int spx_uint32_t;

   7. #endif

5. 在Java层定义编解码需要的接口。

   1. public class Speex {

   2. static {

   3. try {

   4. System.loadLibrary("speex");

   5. } catch (Throwable e) {

   6. e.printStackTrace();

   7. }

   8. }

   9. public native int open(int compression);

   10. public native int getFrameSize();

   11. public native int decode(byte encoded[], short lin[], int size);

   12. public native int encode(short lin[], int offset, byte encoded[], int size);

   13. public native void close();

   14. }

6. 在C层实现上述方法（以encode为例）。

   1. extern "C"

   2. JNIEXPORT jint JNICALL Java_com_jd_wly_intercom_audio_Speex_encode

   3. (JNIEnv *env, jobject obj, jshortArray lin, jint offset, jbyteArray encoded, jint size) {

   4. jshort buffer[enc_frame_size];

   5. jbyte output_buffer[enc_frame_size];

   6. int nsamples = (size-1)/enc_frame_size + 1;

   7. int i, tot_bytes = 0;

   8. if (!codec_open)

   9. return 0;

   10. speex_bits_reset(&ebits);

   11. for (i = 0; i < nsamples; i++) {

   12. env->GetShortArrayRegion(lin, offset + i*enc_frame_size, enc_frame_size, buffer);

   13. speex_encode_int(enc_state, buffer, &ebits);

   14. }

   15. tot_bytes = speex_bits_write(&ebits, (char *)output_buffer, enc_frame_size);

   16. env->SetByteArrayRegion(encoded, 0, tot_bytes, output_buffer);

   17. return (jint)tot_bytes;

   18. }

7. 命令行到Android.mk文件夹下，执行命令ndk-build：

   1. D:\dev\study\intercom\WlyIntercom\app\src\main\jni>ndk-build

   2. [armeabi] Compile++ thumb: speex <= speex_jni.cpp

   3. [armeabi] Compile thumb : speex <= bits.c

   4. [armeabi] Compile thumb : speex <= cb_search.c

   5. [armeabi] Compile thumb : speex <= exc_10_16_table.c

   6. [armeabi] Compile thumb : speex <= exc_10_32_table.c

   7. [armeabi] Compile thumb : speex <= exc_20_32_table.c

   8. [armeabi] Compile thumb : speex <= exc_5_256_table.c

   9. [armeabi] Compile thumb : speex <= exc_5_64_table.c

   10. [armeabi] Compile thumb : speex <= exc_8_128_table.c

   11. [armeabi] Compile thumb : speex <= filters.c

   12. [armeabi] Compile thumb : speex <= gain_table_lbr.c

   13. [armeabi] Compile thumb : speex <= gain_table.c

   14. [armeabi] Compile thumb : speex <= hexc_10_32_table.c

   15. [armeabi] Compile thumb : speex <= hexc_table.c

   16. [armeabi] Compile thumb : speex <= high_lsp_tables.c

   17. [armeabi] Compile thumb : speex <= kiss_fft.c

   18. [armeabi] Compile thumb : speex <= kiss_fftr.c

   19. [armeabi] Compile thumb : speex <= lpc.c

   20. [armeabi] Compile thumb : speex <= lsp_tables_nb.c

   21. [armeabi] Compile thumb : speex <= lsp.c

   22. [armeabi] Compile thumb : speex <= ltp.c

   23. [armeabi] Compile thumb : speex <= modes_wb.c

   24. [armeabi] Compile thumb : speex <= modes.c

   25. [armeabi] Compile thumb : speex <= nb_celp.c

   26. [armeabi] Compile thumb : speex <= quant_lsp.c

   27. [armeabi] Compile thumb : speex <= sb_celp.c

   28. [armeabi] Compile thumb : speex <= smallft.c

   29. [armeabi] Compile thumb : speex <= speex_callbacks.c

   30. [armeabi] Compile thumb : speex <= speex_header.c

   31. [armeabi] Compile thumb : speex <= speex.c

   32. [armeabi] Compile thumb : speex <= stereo.c

   33. [armeabi] Compile thumb : speex <= vbr.c

   34. [armeabi] Compile thumb : speex <= vorbis_psy.c

   35. [armeabi] Compile thumb : speex <= vq.c

   36. [armeabi] Compile thumb : speex <= window.c

   37. [armeabi] StaticLibrary : libstdc++.a

   38. [armeabi] SharedLibrary : libspeex.so

   39. [armeabi] Install : libspeex.so => libs/armeabi/libspeex.so

   生成libs/armeabi/libspeex.so和对应的obj文件，如需单独使用，将上述过程生成的*.so包拷贝至jniLibs文件夹中。

8. 最后，在Android中通过Java去调用encode方法进行音频数据的编码。

1. /**

2. * 将raw原始音频文件编码为Speex格式

3. *

4. * @param audioData 原始音频数据

5. * @return 编码后的数据

6. */

7. public static byte[] raw2spx(short[] audioData) {

8. // 原始数据中包含的整数个encFrameSize

9. int nSamples = audioData.length / encFrameSize;

10. byte[] encodedData = new byte[((audioData.length - 1) / encFrameSize + 1) * encodedFrameSize];

11. short[] rawByte;

12. // 将原数据转换成spx压缩的文件

13. byte[] encodingData = new byte[encFrameSize];

14. int readTotal = 0;

15. for (int i = 0; i < nSamples; i++) {

16. rawByte = new short[encFrameSize];

17. System.arraycopy(audioData, i * encFrameSize, rawByte, 0, encFrameSize);

18. int encodeSize = Speex.getInstance().encode(rawByte, 0, encodingData, rawByte.length);

19. System.arraycopy(encodingData, 0, encodedData, readTotal, encodeSize);

20. readTotal += encodeSize;

21. }

22. rawByte = new short[encFrameSize];

23. System.arraycopy(audioData, nSamples * encFrameSize, rawByte, 0, audioData.length - nSamples * encFrameSize);

24. int encodeSize = Speex.getInstance().encode(rawByte, 0, encodingData, rawByte.length);

25. System.arraycopy(encodingData, 0, encodedData, readTotal, encodeSize);

26. return encodedData;

27. }

这里设置了每帧处理160个short型数据，压缩比为5，每帧输出为28个byte型数据。Speex压缩模式特征如下：

原文综合考虑音频质量、压缩比和算法复杂度，最后选择了Mode 5。

private static final int DEFAULT_COMPRESSION = 5;

三、Android语音对讲项目系统架构

再次说明，本文实现参考了论文：Android real-time audio communications over local wireless，因此系统架构如下图所示：

数据包要经过Record、Encoder、Transmission、Decoder、Play这一链条的处理，这种数据流转就是对讲机核心抽象。鉴于这种场景，本文的实现采用了责任链设计模式。责任链模式属于行为型模式，表征对对象的某种行为。

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

责任链设计模式的使用场景：在责任链模式里，很多对象里由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。下面来看下具体的代码：

首先定义一个JobHandler，代表每个对象，其中包含抽象方法handleRequest()：

1. /**

2. * 数据处理节点

3. *

4. * @param <I> 输入数据类型

5. * @param <O> 输出数据类型

6. * @author yanghao1

7. */

8. public abstract class JobHandler<I, O> {

9. private JobHandler<O, ?> nextJobHandler;

10. public JobHandler<O, ?> getNextJobHandler() {

11. return nextJobHandler;

12. }

13. public void setNextJobHandler(JobHandler<O, ?> nextJobHandler) {

14. this.nextJobHandler = nextJobHandler;

15. }

16. public abstract void handleRequest(I audioData);

17. /**

18. * 释放资源

19. */

20. public void free() {

21. }

22. }

JobHandler<I, O>表示输入数据类型为I，输出类型为O。nextJobHandler表示下一个处理请求的节点，其类型为JobHandler<O, ?>，即输入数据类型必须为上一个处理节点的输出数据类型。

继承类必须实现抽象方法handleRequest()，参数类型为I，实现对数据包的处理。free()方法实现资源的释放，继承类可根据情况重写该方法。这里分别定义Recorder、Encoder、Sender、Receiver、Decoder、Tracker，均继承自JobHandler。

以Recorder、Encoder、Sender为例说明输入侧数据的处理（这里仅列出部分代码，具体代码参考github地址）：

1. /**

2. * 音频录制数据格式ENCODING_PCM_16BIT，返回数据类型为short[]

3. *

4. * @author yanghao1

5. */

6. public class Recorder extends JobHandler<short[], short[]> {

7. @Override

8. public void handleRequest(short[] audioData) {

9. if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_STOPPED) {

10. audioRecord.startRecording();

11. }

12. // 实例化音频数据缓冲

13. audioData = new short[inAudioBufferSize];

14. audioRecord.read(audioData, 0, inAudioBufferSize);

15. getNextJobHandler().handleRequest(audioData);

16. }

17. }

Recorder完成音频采集之后，通过getNextJobHandler()方法获取对下一个处理节点的引用，然后调用其方法handleRequest()，并且入参类型为short[]。Recorder的下一个处理节点是Encoder，在Encoder的handleRequest()方法中，实现音频数据的编码，其输入类型为short[]，输出为byte[]。

1. /**

2. * 音频编码，输入类型为short[]，输出为byte[]

3. *

4. * @author yanghao1

5. */

6. public class Encoder extends JobHandler<short[], byte[]> {

7. @Override

8. public void handleRequest(short[] audioData) {

9. byte[] encodedData = AudioDataUtil.raw2spx(audioData);

10. getNextJobHandler().handleRequest(encodedData);

11. }

12. }

Encoder的下一个处理节点是Sender，在Sender的handleRequest()方法中，通过多播（组播），将音频编码数据发送给局域网内的其它设备。

1. /**

2. * UDP多播发送

3. *

4. * @author yanghao1

5. */

6. public class Sender extends JobHandler<byte[], byte[]> {

7. @Override

8. public void handleRequest(byte[] audioData) {

9. DatagramPacket datagramPacket = new DatagramPacket(

10. audioData, audioData.length, inetAddress, Constants.MULTI_BROADCAST_PORT);

11. try {

12. multicastSocket.send(datagramPacket);

13. } catch (IOException e) {

14. e.printStackTrace();

15. }

16. }

17. }

最后，在AudioInput类的构造函数中执行对象之间的关系：

1. /**

2. * 音频录制、编码、发送线程

3. *

4. * @author yanghao1

5. */

6. public class AudioInput implements Runnable {

7. private Recorder recorder;

8. private Encoder encoder;

9. private Sender sender;

10. private Handler handler;

11. // 录制状态

12. private boolean recording = false;

13. public AudioInput(Handler handler) {

14. this.handler = handler;

15. initJobHandler();

16. }

17. /**

18. * 初始化录制、编码、发送，并指定关联

19. */

20. private void initJobHandler() {

21. recorder = new Recorder();

22. encoder = new Encoder();

23. sender = new Sender(handler);

24. recorder.setNextJobHandler(encoder);

25. encoder.setNextJobHandler(sender);

26. }

27. }

即：在界面初始化AudioInput对应的线程的时候，就完成这些类的实例化，并指定Recorder的下一个处理者是Encoder，Encoder的下一个处理者是Sender。这样使得整个处理流程非常灵活，比如，如果暂时没有开发编解码的过程，在Encoder的handleRequest()方法中直接指定下一个处理者：

1. public class Encoder extends JobHandler {

2. @Override

3. public void handleRequest(byte[] audioData) {

4. getNextJobHandler().handleRequest(audioData);

5. }

6. }

同样的，在初始化AudioOutput对应的线程时，完成Receiver、Decoder、Tracker的实例化，并且指定Receiver的下一个处理者是Decoder、Decoder的下一个处理者是Tracker。

在Activity中，分别申明输入、输出Runable、线程池对象、界面更新Handler：

1. // 界面更新Handler

2. private AudioHandler audioHandler = new AudioHandler(this);

3. // 音频输入、输出Runable

4. private AudioInput audioInput;

5. private AudioOutput audioOutput;

6. // 创建缓冲线程池用于录音和接收用户上线消息（录音线程可能长时间不用，应该让其超时回收）

7. private ExecutorService inputService = Executors.newCachedThreadPool();

8. // 创建循环任务线程用于间隔的发送上线消息，获取局域网内其他的用户

9. private ScheduledExecutorService discoverService = Executors.newScheduledThreadPool(1);

10. // 设置音频播放线程为守护线程

11. private ExecutorService outputService = Executors.newSingleThreadExecutor(new ThreadFactory() {

12. @Override

13. public Thread newThread(@NonNull Runnable r) {

14. Thread thread = Executors.defaultThreadFactory().newThread(r);

15. thread.setDaemon(true);

16. return thread;

17. }

18. });

可能有的同学会觉得这里的责任链设计模式用法并非真正的责任链，真正的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个：一是承担责任，而是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又把责任向下传的情况。
本文中责任链设计模式的用法确实不是严格的责任链模式，但学习的目的不就是活学活用吗？

Android线程池

上述代码涉及Android中的线程池，与Android线程池相关的类包括：Executor，Executors，ExecutorService，Future，Callable，ThreadPoolExecutor等，为了理清它们之间的关系，首先从Executor开始：

• Executor接口中定义了一个方法 execute(Runnable command)，该方法接收一个 Runable实例，它用来执行一个任务，任务即一个实现了Runnable 接口的类。
• ExecutorService接口继承自Executor 接口，它提供了更丰富的实现多线程的方法，比如，ExecutorService提供了关闭自己的方法，以及可为跟踪一个或多个异步任务执行状况而生成Future 的方法。 可以调用ExecutorService 的shutdown()方法来平滑地关闭 ExecutorService，调用该方法后，将导致 ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭 ExecutorService。因此我们一般用该接口来实现和管理多线程。
• Executors 提供了一系列工厂方法用于创建线程池，返回的线程池都实现了 ExecutorService接口。包括：

1. newCachedThreadPool()
   创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程；
2. newFixedThreadPool(int)
   创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3. newScheduledThreadPool(int)
   创建一个定长线程池，支持定时及周期性任务执行。
4. newSingleThreadExecutor()
   创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

• Callable接口与Runnable接口类似，ExecutorService的<T> Future<T> submit(Callable<T> task)方法接受Callable作为入参，在 Java 5 之后，任务分两类：一类是实现了 Runnable接口的类，一类是实现了 Callable 接口的类。两者都可以被 ExecutorService 执行，但是 Runnable任务没有返回值，而 Callable任务有返回值。并且Callable 的call()方法只能通过ExecutorService 的 submit(Callable task)方法来执行，并且返回一个 Future，是表示任务等待完成的Future。
• ThreadPoolExecutor继承自AbstractExecutorService，AbstractExecutorService实现了ExecutorService接口。ThreadPoolExecutor的构造器由于参数较多，不宜直接暴露给使用者。所以，Executors 中定义 ExecutorService实例的工厂方法，其实是通过定义ThreadPoolExecutor不同入参来实现的。

下面来看下ThreadPoolExecutor的构造器方法：

1. public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,

2. BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {

3. if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0)

4. throw new IllegalArgumentException();

5. if (workQueue == null || threadFactory == null || handler == null)

6. throw new NullPointerException();

7. this.corePoolSize = corePoolSize;

8. this.maximumPoolSize = maximumPoolSize;

9. this.workQueue = workQueue;

10. this.keepAliveTime = unit.toNanos(keepAliveTime);

11. this.threadFactory = threadFactory;

12. this.handler = handler;

13. }

其中，corePoolSize表示线程池中所保存的核心线程数，包括空闲线程；maximumPoolSize表示池中允许的最大线程数；keepAliveTime表示线程池中的空闲线程所能持续的最长时间；unit表示时间的单位；workQueue表示任务执行前保存任务的队列，仅保存由execute 方法提交的Runnable任务；threadFactory表示线程创建的工厂，指定线程的特性，比如前面代码中设置音频播放线程为守护线程；handler表示队列容量满之后的处理方法。

ThreadPoolExecutor对于传入的任务Runnable有如下处理流程：

1. 如果线程池中的线程数量少于corePoolSize，即使线程池中有空闲线程，也会创建一个新的线程来执行新添加的任务；
2. 如果线程池中的线程数量大于等于corePoolSize，但缓冲队列workQueue 未满，则将新添加的任务放到 workQueue中，按照 FIFO 的原则依次等待执行（线程池中有线程空闲出来后依次将缓冲队列中的任务交付给空闲的线程执行）；
3. 如果线程池中的线程数量大于等于 corePoolSize，且缓冲队列 workQueue 已满，但线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务；
4. 如果线程池中的线程数量等于了maximumPoolSize，交由RejectedExecutionHandler handler处理。

ThreadPoolExecutor主要用于某些特定场合，即上述工厂方法无法满足的时候，自定义线程池使用。本文使用了三种特性的线程池工厂方法：newCachedThreadPool()、newScheduledThreadPool(int)和newSingleThreadExecutor。

首先，对于录音线程，由于对讲机用户大部分时间可能是在听，而不是说。录音线程可能长时间不用，应该让其超时回收，所以录音线程宜使用CachedThreadPool；
其次，对于发现局域网内的其它用户的功能，该功能需要不断循环执行，相当于循环的向局域网内发送心跳信号，因此宜使用ScheduledThreadPool；
最后，对于音频播放线程，该线程需要一直在后台执行，且播放需要串行执行，因此使用SingleThreadExecutor，并设置为守护线程，在UI线程（主线程是最后一个用户线程）结束之后结束。

1. // 设置音频播放线程为守护线程

2. private ExecutorService outputService = Executors.newSingleThreadExecutor(new ThreadFactory() {

3. @Override

4. public Thread newThread(@NonNull Runnable r) {

5. Thread thread = Executors.defaultThreadFactory().newThread(r);

6. thread.setDaemon(true);

7. return thread;

8. }

9. });

以上。详细代码请移步github：intercom 。

【转】 实时Android语音对讲系统架构相关推荐

1. 智能会议系统（34）---Android语音通话实现方案及相关技术介绍

   Android语音通话实现方案及相关技术介绍 Android语音通话实现方案及相关技术介绍 语音通话 Step1语音采集和输出 Step2编解码方式 Step3网络传输 Step4去噪声消回音 语音通 ...

2. Android语音通话实现方案及相关技术介绍

   Android语音通话实现方案及相关技术介绍 Android语音通话实现方案及相关技术介绍 语音通话 Step1语音采集和输出 Step2编解码方式 Step3网络传输 Step4去噪声消回音 语音通 ...

3. Android App的架构设计：从VM、MVC、MVP到MVVM

   随着Android应用开发规模的扩大,客户端业务逻辑也越来越复杂,已然不是简单的数据展示了.如同后端开发遇到瓶颈时采用的组件拆分思想,客户端也需要进行架构设计,拆分视图和数据,解除模块之间的耦合,提高 ...

4. 使用ZEGO SDK零基础搭建Android语音聊天应用

   2021年初,Clubhouse引爆了在线语音聊天应用,字节跳动.小米.快手.映客等国内泛娱乐社交厂商已纷纷跟进,那么搭建一个类Clubhouse的语音聊天软件难吗? 其实Clubhouse的技术原理 ...

5. 局域网语音对讲系统_IP广播对讲系统停车场解决方案

   IP广播对讲系统停车场解决方案 一.需求分析及行业痛点 需求分析: 随着国民经济和社会的发展, 选择坐车出行的民众越来越多.在保护交通安全的同时,也给停车场服务部门提出了更高的要求.人们对停车场系统提 ...

6. 防欺凌IP网络语音对讲系统特点有哪些？

   防欺凌IP网络语音对讲系统特点有哪些? ip网络对讲‍系统通过运用相应的大数据和人工智能技术,让对讲能够在更远的距离范围内以及更复杂的网络环境中使用.从而保证用户能够在网络状况不佳的环境中确保对讲清晰 ...

7. android融云自定义通知,Android SDK 体系架构 - 融云 RongCloud

   Android SDK 体系架构和消息体系 本文档将详细介绍融云的 SDK 产品架构和消息体系,以便于您更深入的了解融云并更快速的开发自己的产品. 融云 SDK 系统架构 IMKit IMKit 的功 ...

8. Android Qcom Audio架构学习

   总结: Android Audio不简单呀,一个人摸索入门不容易的,研究了一段时间,感觉还不是很懂,但以下的知识对入门还是有帮助的. Audio架构中的名词 FE(Front End) 提供pcm的设 ...

9. 太空狼人杀火爆的背后 实时游戏语音有哪些技术难点

   太空版狼人杀游戏<Among Us>在海外的爆红也已延伸到了国内,在国内App Store免费游戏榜,<Among Us>曾一度进入榜单Top5,国产太空版狼人杀游戏<狼 ...

最新文章

1. Robust principal component analysis?(RPCA简单理解)
2. 喜报！天虹股份签约神策数据
3. python —skleran分类示例（全流程）
4. jquery ajax post请求连续多个问号特殊数据异常问题
5. 【OS学习笔记】二十二 保护模式六：保户模式下操作系统内核如何加载用户程序并运行 对应的汇编代码之用户程序
6. 将html对象转换成jq,2js对象与jq对象之间互转.html
7. 游戏筑基开发之C语言回调函数使用实例及其.h库封装实例
8. 获得Azure订阅LoadBalancer的脚本
9. matlab cramer法则,玩转线性代数(8)第一章第七节_克拉姆法则与秘密武器
10. ADO访问Excel 2007
11. 「python爬虫之路day9」:实战之使用正则表达式爬取抓狂网，古诗文网信息
12. 程序员的忧桑：有人向你反馈了一个Bug！
13. 如何实现算法中的公平性
14. hinge_在Swift中在iOS上重新创建Hinge的配置文件过渡
15. 【附源码】25个Python实战项目，超适合零基础练手，建议码住
16. 虚拟机打电话发短信方法
17. 关于 Glide 加载图片圆角问题
18. 读《了不起的盖兹比》于海生译版 有感
19. MAC +python+mitmdump爬取香哈菜谱app端信息
20. java.lang.UnsatisfiedLinkError:sayHello()

热门文章

1. 升级版本-汇编码转机器码万能转换工具(支持32种CPU架构指令16/32/64位的转码)
2. Java shared data_Java多个线程之间处理共享数据的方式
3. 网络浏览器 Microsoft Edge 32/64 位 v79.0.309.7 绿色便携版
4. c语言输入系统 -- 全拼汉字输入
5. EF and our country
6. JavaWeb复习——task04：JavaBean 动作标签和作用域
7. 深入理解js中的事件委托
8. 计算机毕业设计 SSM+MySQL毕业设计 疫情期间医院门诊管理系统
9. 【附源码】计算机毕业设计SSM农产品追溯系统设计与实现
10. j = j ++ 和 j = ++ j的区别