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