Android java层音频相关的分析与理解（三）调用相关

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()的主要内容：

<span style="font-size:14px;"><span style="font-size:12px;">public int requestAudioFocus (OnAudioFocusChangeListener l,
            @NonNull AudioAttributes requestAttributes,
            int durationHint,
            int flags,
            AudioPolicy ap) throws IllegalArgumentException {
        ……//一系列的参数判断
        int status = AUDIOFOCUS_REQUEST_FAILED;
        //将申请AudioFocus的应用的listener放进mAudioFocusIdListenerMap中
registerAudioFocusListener(l);
        IAudioService service = getService();
        try {
            //调用AudioService的requestAudioFocus()
            status = service.requestAudioFocus(requestAttributes, durationHint, mICallBack,
                    mAudioFocusDispatcher, getIdForAudioFocusListener(l),
                    getContext().getOpPackageName() /* package name */, flags,
                    ap != null ? ap.cb() : null);
        } catch (RemoteException e) {
            Log.e(TAG, "Can't call requestAudioFocus() on AudioService:", e);
        }
        return status;
    }
</span></span>

在requestAudioFocus()中，与以往的稍有不同的是，requestAudioFocus()先一步对传入的参数进行处理，并将申请应用的listener放进了mAudioFocusIdListenerMap中保存。而传入的参数中，多了mAudioFocusDispatcher和getIdForAudioFocusListener(l)。getIdForAudioFocusListener(l)很明显，就是将这个listener的名字传进去。那mAudioFocusDispatcher到底是干什么的呢？

 

接下来，我们先来关注一下mAudioFocusDispatcher：

<span style="font-size:14px;"><span style="font-size:12px;">    private final IAudioFocusDispatcher mAudioFocusDispatcher = new IAudioFocusDispatcher.Stub() {

        public void dispatchAudioFocusChange(int focusChange, String id) {
            Message m = mAudioFocusEventHandlerDelegate.getHandler().obtainMessage(focusChange, id);
            mAudioFocusEventHandlerDelegate.getHandler().sendMessage(m);
        }
    };
</span></span>

从上面我们可以看出，mAudioFocusDispatcher是IaudioFocusDispatcher的一个实现。他里面有一个方法，负责调用mAudioFocusEventHandlerDelegate去处理消息的内容。那mAudioFocusEventHandlerDelegate又是干什么呢？我们继续往下看。

<span style="font-size:14px;"><span style="font-size:12px;">    private class FocusEventHandlerDelegate {
        private final Handler mHandler;
        FocusEventHandlerDelegate() {
            Looper looper;
            if ((looper = Looper.myLooper()) == null) {
                looper = Looper.getMainLooper();
            }
            if (looper != null) {
                // implement the event handler delegate to receive audio focus events
                mHandler = new Handler(looper) {
                    @Override
                    public void handleMessage(Message msg) {
                        OnAudioFocusChangeListener listener = null;
                        synchronized(mFocusListenerLock) {
                            listener = findFocusListener((String)msg.obj);
                        }
                        if (listener != null) {
                            Log.d(TAG, "AudioManager dispatching onAudioFocusChange("
                                    + msg.what + ") for " + msg.obj);
                            listener.onAudioFocusChange(msg.what);
                        }
                    }
                };
            } else {
                mHandler = null;
            }
        }
        Handler getHandler() {
            return mHandler;
        }
    }
</span></span>

从上面我们可以看出，调用mAudioFocusEventHandlerDelegate就是为了回调传入的listener的onAudioFocusChange方法去处理相关的内容。那明明可以直接通过l.onAudioFocusChange(focusChange)去处理这些信息，为什么要多此一举专门用一个handle去处理了？于是我去查了一下啊，原因如下：因为这个回调尚在Binder的调用线程中，如果在这里因为用户传入的listener的代码有问题而爆出异常或阻塞甚至恶意拖延，则会导致Binder的另一端因异常而崩溃或阻塞。所以到此为止，AudioService已经尽到了通知的义务，应该通过Handler将后续的操作发往另外一个线程，使AudioService尽可能远离回调现实的影响。

 

所以，现在我们可以进入AudioService去看一下到底AudioService是怎样处理的。

AudioService. requestAudioFocus()如下：

<span style="font-size:14px;"><span style="font-size:12px;">public int requestAudioFocus(AudioAttributes aa, int durationHint, IBinder cb,
            IAudioFocusDispatcher fd, String clientId, String callingPackageName, int flags,
            IAudioPolicyCallback pcb) {
        // 检测权限
        if ((flags & AudioManager.AUDIOFOCUS_FLAG_LOCK) == AudioManager.AUDIOFOCUS_FLAG_LOCK) {     //奇怪的地方1
            if (AudioSystem.IN_VOICE_COMM_FOCUS_ID.equals(clientId)) {
                if (PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(
                            android.Manifest.permission.MODIFY_PHONE_STATE)) {
                    Log.e(TAG, "Invalid permission to (un)lock audio focus", new Exception());
                    return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
                }
            } else {
                //注册一个AudioPolicy去获取AudioFocus
                synchronized (mAudioPolicies) {    //奇怪的地方2
                    if (!mAudioPolicies.containsKey(pcb.asBinder())) {
                        Log.e(TAG, "Invalid unregistered AudioPolicy to (un)lock audio focus");
                        return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
                    }
                }
            }
        }

        return mMediaFocusControl.requestAudioFocus(aa, durationHint, cb, fd,
                clientId, callingPackageName, flags);
    }
</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是怎么处理的。

<span style="font-size:14px;"><span style="font-size:12px;">   protected int requestAudioFocus(AudioAttributes aa, int focusChangeHint, IBinder cb,
            IAudioFocusDispatcher fd, String clientId, String callingPackageName, int flags) {
         ……
        //跳过各种判断
        synchronized(mAudioFocusLock) {
          ……
            //通过AudioFocusDeathHandler对申请AudioFocus的应用进行监听
            AudioFocusDeathHandler afdh = new AudioFocusDeathHandler(cb);
            try {
                cb.linkToDeath(afdh, 0);
            } catch (RemoteException e) {
                ……
                return AudioManager.AUDIOFOCUS_REQUEST_FAILED;
            }
            
// mFocusStack就是AudioFocus机制所在的栈
// 如果申请AudioFocus的应用已经获取的AudioFocus，不作任何处理
            if (!mFocusStack.empty() && mFocusStack.peek().hasSameClient(clientId)) {
                ……
            }

            // 如果已经在Stack中已经存在去这个应用的请求，就先remove掉它
            removeFocusStackEntry(clientId, false /* signal */, false /*notifyFocusFollowers*/);
            
            //新建一个FocusRequester对象
            final FocusRequester nfr = new FocusRequester(aa, focusChangeHint, flags, fd, cb,
                    clientId, afdh, callingPackageName, Binder.getCallingUid(), this);
            if (focusGrantDelayed) {
                //处于可延迟获取AudioFocus状态（正在通话）下，先把它放进Stack中
                final int requestResult = pushBelowLockedFocusOwners(nfr);
                if (requestResult != AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
                    notifyExtPolicyFocusGrant_syncAf(nfr.toAudioFocusInfo(), requestResult);
                }
                return requestResult;
            } else {
                
                if (!mFocusStack.empty()) {
                    //使上一个占有AudioFocus的应用失去AudioFocus
                    propagateFocusLossFromGain_syncAf(focusChangeHint);
                }

                //将当前的request放在栈顶
                mFocusStack.push(nfr);
            }
            //通知系统该应用获取AudioFocus
            notifyExtPolicyFocusGrant_syncAf(nfr.toAudioFocusInfo(),
                    AudioManager.AUDIOFOCUS_REQUEST_GRANTED);

        }//synchronized(mAudioFocusLock)

        return AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
    }
</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都不会影响应用的音频输出与输入。