Android中会有多个应用需要支持音频的播放。当同一时间内有多个应用需要输出音频的时候，到底是全部输出？还是输出其中一个？假如输出其中一个，那到底输出哪个？以什么标准去界定？为了处理这些关系。Android在2.3的时候引入了AudioFocus机制并沿用到现在。
1 AudioFocus简介
AudioFocus是一个没有优先级概念的抢占式的机制。一般情况下，最后申请使用AudioFoucs的应用或取得当前的AudioFocus从而将前面申请的应用给停掉。但是，有一种情况是特殊的，就是通话。通话作为手机的重要功能，从响铃到通话接受，Telephony都会申请AudioFocus，所有应用都不能从Telephony中获取音频焦点，但Telephony可以从任何应用中获取到AudioFocus。
当前Android6.0下AudioFocus有几种状态，分别为：
从上面AudioFocus的状态可以看出，其实AudioFocus的状态是对应的。当后一个应用去GainAudioFocus时，前一个应用就相对应地LossAudioFocus。后一个应用以什么形式去Gain，前一个应该就会受到相应Loss的通知。但是，当前一个应用收到这个Loss通知时，应用怎么处理是应用内部的事情。因为AudioFoucs机制是一个建议性而不是强制性的机制。应用使用这种机制只是使用户体验更加好，而不采用这套机制，甚至不遵循这套机制，对应用与系统本身来是，是没有什么影响的。
再补充说明一下，当应用通过AudioFocus机制去输出音频的时候，它可以因为其他应用通过获取AudioFocus去暂停输出。但是，应用也可以不通过AudioFocus去输出音频。此时该应用的一切音频输出逻辑由本身控制。不受AudioFocus机制影响。
2 AudioFocus的实现
AudioFocus机制其实相当于一个栈。
如上图所示，AudioFocus机制是以栈的形式实现，位于栈顶的应用能获取到AudioFocus从而能输出音频。非栈顶应用会暂时失去AudioFocus直至位于其上面的全部应用关闭或主动丢失AudioFocus。
AudioFocus的实现是从AudioManager.java开始的。
一般来说，应用内部会通过调用AudioManager的requestAudioFocus()方法去获取AudioFocus。AudioManager这一次，与以往不同，不只是作为一个类似于传递者的角色直接获取AudioService的句柄然后将参数传递过去，而是先通过一系列的判断和封装，通过2次重载，将应用的相关消息保存并调用AudioSercvice中的requestAudioFocus（），进一步处理获取AudioFocus操作。
所以我们来看一下AudioManager的requestAudioFocus()的主要内容：
1. <span style="font-size:14px;"><span style="font-size:12px;">public int requestAudioFocus (OnAudioFocusChangeListener l,
2. @NonNull AudioAttributes requestAttributes,
3. int durationHint,
4. int flags,
5. throws IllegalArgumentException {
6. //一系列的参数判断
7. int status = AUDIOFOCUS_REQUEST_FAILED;
8. //将申请AudioFocus的应用的listener放进mAudioFocusIdListenerMap中
9. registerAudioFocusListener(l);
10. IAudioService service = getService();
11. try {
12. //调用AudioService的requestAudioFocus()
13. status = service.requestAudioFocus(requestAttributes, durationHint, mICallBack,
14. mAudioFocusDispatcher, getIdForAudioFocusListener(l),
15. /* package name */, flags,
16. null ? ap.cb() : null);
17. catch (RemoteException e) {
18. "Can't call requestAudioFocus() on AudioService:", e);
19. }
20. return status;
21. }
22. </span></span>
在requestAudioFocus()中，与以往的稍有不同的是，requestAudioFocus()先一步对传入的参数进行处理，并将申请应用的listener放进了mAudioFocusIdListenerMap中保存。而传入的参数中，多了mAudioFocusDispatcher和getIdForAudioFocusListener(l)。getIdForAudioFocusListener(l)很明显，就是将这个listener的名字传进去。那mAudioFocusDispatcher到底是干什么的呢？
接下来，我们先来关注一下mAudioFocusDispatcher：
1. <span style="font-size:14px;"><span style="font-size:12px;"> private final IAudioFocusDispatcher mAudioFocusDispatcher = new IAudioFocusDispatcher.Stub() {
2.
3. public void dispatchAudioFocusChange(int focusChange, String id) {
4. Message m = mAudioFocusEventHandlerDelegate.getHandler().obtainMessage(focusChange, id);
5. mAudioFocusEventHandlerDelegate.getHandler().sendMessage(m);
6. }
7. };
8. </span></span>
从上面我们可以看出，mAudioFocusDispatcher是IaudioFocusDispatcher的一个实现。他里面有一个方法，负责调用mAudioFocusEventHandlerDelegate去处理消息的内容。那mAudioFocusEventHandlerDelegate又是干什么呢？我们继续往下看。
<span style="font-size:14px;"><span style="font-size:12px;"> private class FocusEventHandlerDelegate {
1. private final Handler mHandler;
2. FocusEventHandlerDelegate() {
3. Looper looper;
4. if ((looper = Looper.myLooper()) == null) {
5. looper = Looper.getMainLooper();
6. }
7. if (looper != null) {
8. // implement the event handler delegate to receive audio focus events
9. new Handler(looper) {
10. @Override
11. public void handleMessage(Message msg) {
12. null;
13. synchronized(mFocusListenerLock) {
14. listener = findFocusListener((String)msg.obj);
15. }
16. if (listener != null) {
17. "AudioManager dispatching onAudioFocusChange("
18. ") for " + msg.obj);
19. listener.onAudioFocusChange(msg.what);
20. }
21. }
22. };
23. else {
24. null;
25. }
26. }
27. Handler getHandler() {
28. return mHandler;
29. }
30. }
31. </span></span>
从上面我们可以看出，调用mAudioFocusEventHandlerDelegate就是为了回调传入的listener的onAudioFocusChange方法去处理相关的内容。那明明可以直接通过l.onAudioFocusChange(focusChange)去处理这些信息，为什么要多此一举专门用一个handle去处理了？于是我去查了一下啊，原因如下：因为这个回调尚在Binder的调用线程中，如果在这里因为用户传入的listener的代码有问题而爆出异常或阻塞甚至恶意拖延，则会导致Binder的另一端因异常而崩溃或阻塞。所以到此为止，AudioService已经尽到了通知的义务，应该通过Handler将后续的操作发往另外一个线程，使AudioService尽可能远离回调现实的影响。
所以，现在我们可以进入AudioService去看一下到底AudioService是怎样处理的。
AudioService. requestAudioFocus()如下：
1. <span style="font-size:14px;"><span style="font-size:12px;">public int requestAudioFocus(AudioAttributes aa, int durationHint, IBinder cb,
2. int flags,
3. IAudioPolicyCallback pcb) {
4. // 检测权限
5. if ((flags & AudioManager.AUDIOFOCUS_FLAG_LOCK) == AudioManager.AUDIOFOCUS_FLAG_LOCK) { //奇怪的地方1
6. if (AudioSystem.IN_VOICE_COMM_FOCUS_ID.equals(clientId)) {
7. if (PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(
8. android.Manifest.permission.MODIFY_PHONE_STATE)) {
9. "Invalid permission to (un)lock audio focus", new Exception());
10. return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
11. }
12. else {
13. //注册一个AudioPolicy去获取AudioFocus
14. synchronized (mAudioPolicies) { //奇怪的地方2
15. if (!mAudioPolicies.containsKey(pcb.asBinder())) {
16. "Invalid unregistered AudioPolicy to (un)lock audio focus");
17. return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
18. }
19. }
20. }
21. }
22.
23. return mMediaFocusControl.requestAudioFocus(aa, durationHint, cb, fd,
24. clientId, callingPackageName, flags);
25. }
26. </span></span>
在上面假如仔细看的话，有2个地方会觉得很奇怪。第一个，AudioManager.AUDIOFOCUS_FLAG_LOCK ，第二个mAudioPolicies。AudioManager.AUDIOFOCUS_FLAG_LOCK代表着AudioFocus被锁定的状态。处于这种状态下假如应用需要获取AudioFoucs，首先得去registerAudioPolicy。这就和AudioPolicy相关。
在这里AudioPolicy与AudioPolicyService一点关系的没有。前者在java层，只是负责提供简单的音频路由和音频焦点的管理；后者处于C++层负责处理音频相关的路由策略。在这里，由于我们一般不会用到AudioPoluicy和AudioManager.AUDIOFOCUS_FLAG_LOCK，所以这个会在4.3稍作解析就过了。
回到AudioService. requestAudioFocus(),我们其实可以发现，真正处理AudioFocus的，是MediaFocusControl……
所以现在就来看一下MediaFocusControl是怎么处理的。
1. <span style="font-size:14px;"><span style="font-size:12px;"> protected int requestAudioFocus(AudioAttributes aa, int focusChangeHint, IBinder cb,
2. int flags) {
3. ……
4. //跳过各种判断
5. synchronized(mAudioFocusLock) {
6. ……
7. //通过AudioFocusDeathHandler对申请AudioFocus的应用进行监听
8. new AudioFocusDeathHandler(cb);
9. try {
10. 0);
11. catch (RemoteException e) {
12. ……
13. return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
14. }
15.
16. // mFocusStack就是AudioFocus机制所在的栈
17. // 如果申请AudioFocus的应用已经获取的AudioFocus，不作任何处理
18. if (!mFocusStack.empty() && mFocusStack.peek().hasSameClient(clientId)) {
19. ……
20. }
21.
22. // 如果已经在Stack中已经存在去这个应用的请求，就先remove掉它
23. false /* signal */, false /*notifyFocusFollowers*/);
24.
25. //新建一个FocusRequester对象
26. final FocusRequester nfr = new FocusRequester(aa, focusChangeHint, flags, fd, cb,
27. this);
28. if (focusGrantDelayed) {
29. //处于可延迟获取AudioFocus状态（正在通话）下，先把它放进Stack中
30. final int requestResult = pushBelowLockedFocusOwners(nfr);
31. if (requestResult != AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
32. notifyExtPolicyFocusGrant_syncAf(nfr.toAudioFocusInfo(), requestResult);
33. }
34. return requestResult;
35. else {
36.
37. if (!mFocusStack.empty()) {
38. //使上一个占有AudioFocus的应用失去AudioFocus
39. propagateFocusLossFromGain_syncAf(focusChangeHint);
40. }
41.
42. //将当前的request放在栈顶
43. mFocusStack.push(nfr);
44. }
45. //通知系统该应用获取AudioFocus
46. notifyExtPolicyFocusGrant_syncAf(nfr.toAudioFocusInfo(),
47. AudioManager.AUDIOFOCUS_REQUEST_GRANTED);
48.
49. //synchronized(mAudioFocusLock)
50.
51. return AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
52. }
53. </span></span>
在这里我们可以看到真正的requestAudioFocus()处理。其实主要的流程就是：
1） 判断是否需要延迟获取AudioFocus（通话状态），判断应用是否已经拥有AudioFocus等等。
2） 让上一个占有AudioFocus的应用失去AudioFocus，并通过一系列的操作回调它的onAudioFocusChange方法。（流程较简单，不详细叙述了）
3） 将当前应用FocusRequester放到栈顶，并通知系统当前应用获取AudioFocus
失去AudioFocus的操作（abandonAudioFocus）和requestAudioFocus是大同小异的。所以在这里也不详细说明了。
3 AudioPolicy的使用
最后在这里简单说一下java层的AudioPolicy的理解。AudioService会有一个HashMap的对象mAudioPolicies，里面保存着所有registerAudioPolicy()过的应用的信息。通过registerAudioPolicy()我们可以对AudioFocus进行锁定并不允许不注册AudioPolicy的应用修改。但是这个功能其实我们大部分时候都不会用到。
音频调用相关就简单分析到这。再重申一下，AudioFocus是一个建议非强制机制，我们不适用AudioFocus都不会影响应用的音频输出与输入。
