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都不会影响应用的音频输出与输入。

更多相关文章

随机推荐