Android 关于解决mediabutton学习到的media控制流程

问题背景：话机连接了头戴式的耳机，在通话过程中短按按钮是挂断电话，长按按钮是通话静音。客户需求是把长按改成挂断功能，短按是静音功能。

android版本：8.1

在通话中，测试打印信息，可以看到button的Keycode 是79， 对应着按键KEYCODE_HEADSETHOOK。

Phonewindowmanager -->interceptKeyBeforeQueueing() -->case KEYCODE_HEADSETHOOK 

mBroadcastWakeLock.acquire();
Message msg = mHandler.obtainMessage(MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK,
        new KeyEvent(event));
msg.setAsynchronous(true);
msg.sendToTarget();

在这里将message发送出去，在handlemessage里处理MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK

case MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK:
    dispatchMediaKeyWithWakeLock((KeyEvent)msg.obj);
    break;

在dispatchMediaKeyWithWakeLock()方法里，

void dispatchMediaKeyWithWakeLock(KeyEvent event) {
    ...
    dispatchMediaKeyWithWakeLockToAudioService(event);
    ...
}

接着在把event传给了dispatchMediaKeyWithWakeLockToAudioService(event)。

接着调用了

MediaSessionLegacyHelper.getHelper(mContext).sendMediaButtonEvent(event, true);

继续传递event给了mediasession，MediaSessionLegacyHelper.getHelper(mContext)获得了一个MediaSessionLegacyHelper对象，接着看MediaSessionLegacyHelper的sendMediaButtonEvent()

public void sendMediaButtonEvent(KeyEvent keyEvent, boolean needWakeLock) {
    if (keyEvent == null) {
        Log.w(TAG, "Tried to send a null key event. Ignoring.");
        return;
    }
    mSessionManager.dispatchMediaKeyEvent(keyEvent, needWakeLock);
    if (DEBUG) {
        Log.d(TAG, "dispatched media key " + keyEvent);
    }
}

又把event传给了msessionmanager，的dispatchMediaKeyEvent

public void dispatchMediaKeyEvent(@NonNull KeyEvent keyEvent, boolean needWakeLock) {
    try {
        mService.dispatchMediaKeyEvent(keyEvent, needWakeLock);
    } catch (RemoteException e) {
        Log.e(TAG, "Failed to send key event.", e);
    }
}

这个mService的对象是ISessionManager，发现这个是应用了AIDL的进程通信方式，ISessionManager只是个接口，它的实现类是class SessionManagerImpl extends ISessionManager.Stub{}，这个SessionManagerImpl是MediaSessionService.java的内部类，MediaSessionService是一个系统服务，控制了很多关于media的功能。

接着看SessionManagerImpl 的dispatchMediaKeyEvent()

@Override
public void dispatchMediaKeyEvent(KeyEvent keyEvent, boolean needWakeLock) {
    。。。
     if (!isGlobalPriorityActive && isVoiceKey(keyEvent.getKeyCode())) {
        Log.i(TAG, "dispatchMediaKeyEvent: handleVoiceKeyEventLocked");

        handleVoiceKeyEventLocked(keyEvent, needWakeLock);
     } else {
        Log.i(TAG, "dispatchMediaKeyEventLocked");
        dispatchMediaKeyEventLocked(keyEvent, needWakeLock);
     }
    。。。
}

中间省略了一些代码，在传递event的时候，做了个判断传递的方式是否是voicekey， 我们的headset是只有一个按钮，于是接着走dispatchMediaKeyEventLocked()

private void dispatchMediaKeyEventLocked(KeyEvent keyEvent, boolean needWakeLock) {
    MediaSessionRecord session = mCurrentFullUserRecord.getMediaButtonSessionLocked();
    if (session != null) {

        。。。。
        // If we don't need a wakelock use -1 as the id so we won't release it later.
        session.sendMediaButton(keyEvent,
                needWakeLock ? mKeyEventReceiver.mLastTimeoutId : -1,
                mKeyEventReceiver, Process.SYSTEM_UID,
                getContext().getPackageName());
        。。。。
    }
}

这里会把keyevent传递个一个session，这个session是什么呢？我也不知道，应该是类似于一个token之类的，记录了当前media信息的一个类MediaSessionRecord.java

进MediaSessionRecord.java看看，其中有许多设置方法，找到sendMediaButton

public void sendMediaButton(KeyEvent ke, int sequenceId,
        ResultReceiver cb, int uid, String packageName) {
    updateCallingPackage(uid, packageName);
    mSessionCb.sendMediaButton(ke, sequenceId, cb);
}

这里的mSessionCb也是个特殊的类，在这一段，会发现有很多进程间通信的痕迹，各种AIDL输出。

class SessionCb {
    private final ISessionCallback mCb;

    public SessionCb(ISessionCallback cb) {
        mCb = cb;
    }

    public boolean sendMediaButton(KeyEvent keyEvent, int sequenceId, ResultReceiver cb) {
        Intent mediaButtonIntent = new Intent(Intent.ACTION_MEDIA_BUTTON);
        mediaButtonIntent.putExtra(Intent.EXTRA_KEY_EVENT, keyEvent);
        try {
            mCb.onMediaButton(mediaButtonIntent, sequenceId, cb);
            return true;
        } catch (RemoteException e) {
            Slog.e(TAG, "Remote failure in sendMediaRequest.", e);
        }
        return false;
    }

在这里，sendMediaButton又接着把keyevent转换为一个Intent，传给了mCb.onMediaButton

这个mCb是个AIDL实现，ISessionCallback是个接口，需要找到真实的继承它的类，全局搜索找到

public static class CallbackStub extends ISessionCallback.Stub 实现了这个接口，这里在MediaSession.java的内部类，看看路径，会发现MediaSessionRecord.java在framwork/service/子目录下，而MediaSession.java却在framwork/base/media/子目录下，跨进程通信很明显必然要用到AIDL。

在onMediaButton里

@Override
public void onMediaButton(Intent mediaButtonIntent, int sequenceNumber,
        ResultReceiver cb) {
    MediaSession session = mMediaSession.get();
    try {
        if (session != null) {
            session.dispatchMediaButton(mediaButtonIntent);
        }
    }
}

会继续走dispatchMediaButton

private void dispatchMediaButton(Intent mediaButtonIntent) {
    postToCallback(CallbackMessageHandler.MSG_MEDIA_BUTTON, mediaButtonIntent);
}

postToCallback就把intent传给了CallbackMessageHandler

在这个handler里，处理了msg和intent

handlemessage里

case MSG_MEDIA_BUTTON:
    mCallback.onMediaButtonEvent((Intent) msg.obj);
    break;

这个mCallback回调，是在创建CallbackMessageHandler的时候传来的，

public CallbackMessageHandler(Looper looper, MediaSession.Callback callback) {
    super(looper, null, true);
    mCallback = callback;
    mCallback.mHandler = this;
}

这里，需要找到是谁调用了构造方法，才能从callback里找到那个调用onMediaButtonEvent的地方。

全局搜索之后，就在MediaSession.java里的setCallback有调用

public void setCallback(@Nullable Callback callback, @Nullable Handler handler) {
    。。。

        if (handler == null) {
            handler = new Handler();
        }
        callback.mSession = this;
        CallbackMessageHandler msgHandler = new CallbackMessageHandler(handler.getLooper(),
                callback);
        mCallback = msgHandler;
    。。。
}

这里就需要再找找谁调用了mediasession的setcallback方法，全局搜索，发现只要在HeadsetMediaButton.java里有调用这个方法，并且这里是属于一个叫mMediaSessionHandler的handler里，

case MSG_MEDIA_SESSION_INITIALIZE: {
    MediaSession session = new MediaSession(
            mContext,
            HeadsetMediaButton.class.getSimpleName());
    session.setCallback(mSessionCallback);
    session.setFlags(MediaSession.FLAG_EXCLUSIVE_GLOBAL_PRIORITY
            | MediaSession.FLAG_HANDLES_MEDIA_BUTTONS);
    session.setPlaybackToLocal(AUDIO_ATTRIBUTES);
    mSession = session;
    break;
}

那就是它了，HeadsetMediaButton.class。

在它的构造方法里，有个发送message的动作，从一开始创建就存在去产生了Mediasession

public HeadsetMediaButton(
        Context context,
        CallsManager callsManager,
        TelecomSystem.SyncRoot lock) {
    mContext = context;
    mCallsManager = callsManager;
    mLock = lock;

    // Create a MediaSession but don't enable it yet. This is a
    // replacement for MediaButtonReceiver
    mMediaSessionHandler.obtainMessage(MSG_MEDIA_SESSION_INITIALIZE).sendToTarget();
}

在setcallback里设置的是mSessionCallback，于是继续看它是什么。

private final MediaSession.Callback mSessionCallback = new MediaSession.Callback() {
    @Override
    public boolean onMediaButtonEvent(Intent intent) {
        KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        Log.v(this, "SessionCallback.onMediaButton()...  event = %s.", event);
        if ((event != null) && ((event.getKeyCode() == KeyEvent.KEYCODE_HEADSETHOOK) ||
                                (event.getKeyCode() == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE))) {
            synchronized (mLock) {
                Log.v(this, "SessionCallback: HEADSETHOOK/MEDIA_PLAY_PAUSE");
                boolean consumed = handleCallMediaButton(event);
                Log.v(this, "==> handleCallMediaButton(): consumed = %b.", consumed);
                return consumed;
            }
        }
        return true;
    }
};

这个回调，有个我们熟悉的方法，onMediaButtonEvent，

在MediaSession里处理MSG_MEDIA_BUTTON这个case的时候，就是调用了mcallback的onMediaButtonEvent，而这个回调实现对象就是这里的mSessionCallback，这里onMediaButtonEvent把intent给处理了，走到handleCallMediaButton。

private boolean handleCallMediaButton(KeyEvent event) {


    if (event.isLongPress()) {
        return mCallsManager.onMediaButton(LONG_PRESS);
    } else if (event.getAction() == KeyEvent.ACTION_UP) {
        // We should not judge SHORT_PRESS by ACTION_UP event repeatCount, because it always
        // return 0.
        // Actually ACTION_DOWN event repeatCount only increases when LONG_PRESS performed.
        if (mLastHookEvent != null && mLastHookEvent.getRepeatCount() == 0) {
            return mCallsManager.onMediaButton(SHORT_PRESS);
        }
    }


    return true;
}

这里走到了CallManager，是的，这是管理通话控制的地方，在callmanager里，

boolean onMediaButton(int type) {
    if (hasAnyCalls()) {
        Call ringingCall = getFirstCallWithState(CallState.RINGING);
        if (HeadsetMediaButton.SHORT_PRESS == type) {
            if (ringingCall == null) {
                Call callToHangup = getFirstCallWithState(CallState.RINGING, CallState.DIALING,
                        CallState.PULLING, CallState.ACTIVE, CallState.ON_HOLD);
                Log.addEvent(callToHangup, LogUtils.Events.INFO,
                        "media btn short press - end call.");
                if (callToHangup != null) {
                    callToHangup.disconnect();
                    return true;
                }
            } else {
                ringingCall.answer(VideoProfile.STATE_AUDIO_ONLY);
                return true;
            }
        } else if (HeadsetMediaButton.LONG_PRESS == type) {
            if (ringingCall != null) {
                Log.addEvent(getForegroundCall(),
                        LogUtils.Events.INFO, "media btn long press - reject");
                ringingCall.reject(false, null);
            } else {
                Log.addEvent(getForegroundCall(), LogUtils.Events.INFO,
                        "media btn long press - mute");
                mCallAudioManager.toggleMute();
            }
            return true;
        }
    }
    return false;
}

就是我们要找的地方，短按，和长按的处理，在这里，SHORT_PRESS 是接听和挂断，LONG_PRESS是拒绝和静音控制。

于是,我们只需要在这里更改对应if条件下的控制，就能完成短按和长按的客户定制功能。

总结：整个流程，从按键监听，到走到callmanager里，饶了很久，中间遇到了很多Mediasession和进程间通信知识，这里只是记录一下解bug的过程，感觉像猜谜游戏一样，这也是一段技术成长的过程。挺有意义的。