android 最近任务多进程调度逻辑分析

android自从把最近任务改为一个activity后，最近任务的内部逻辑的复杂程度就在不停地快速增长着。android是支持多用户的，最近任务在每个用户空间都有一个单独运行的进程。而只有主用户空间的SystemUI进程才能收到PhoneWindowManager发过来的事件，比如showRecents，hideRecents等，所以副用户空间的systemui进程就需要主用户空间的systemui来通知副用户的systemui来做显示最近任务和隐藏最近任务等操作。这就需要有一些调度逻辑了，到android 7.0后，google将原本通过的broadcast来调度的逻辑改为了用service调用，更加难以理清，在这篇博客里，我来单独分析一下最近任务对于多用户多进程的调度逻辑。

1.首先，system_server在系统刚刚启动时，就显示的把systemui里的SystemUIService启动

    static final void startSystemUi(Context context) {        Intent intent = new Intent();        intent.setComponent(new ComponentName("com.android.systemui",                    "com.android.systemui.SystemUIService"));        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);        //Slog.d(TAG, "Starting service: " + intent);        context.startServiceAsUser(intent, UserHandle.SYSTEM);    }

2.然后SystemUIService启动后，在onCreate里面启动SystemUI里所有的service。
注意，这里所谓的“service”并不是真正的android service，而是sytemui里自定义的一个类型SystemUI.class
所有的systemui都继承这个类型，并且在startServicesIfNeeded里面实例化各个service，然后调用相应service的start方法来做初始化操作。

    @Override    public void onCreate() {        super.onCreate();        ((SystemUIApplication) getApplication()).startServicesIfNeeded();    }

3.这里只看Recents.class这个service，在Recents.class的start方法里，有如下一段代码。

    if (sSystemServicesProxy.isSystemUser(processUser)) {        // For the system user, initialize an instance of the interface that we can pass to the        // secondary user        mSystemToUserCallbacks = new RecentsSystemUser(mContext, mImpl);    } else {        // For the secondary user, bind to the primary user's service to get a persistent        // interface to register its implementation and to later update its state        registerWithSystemUser();    }

先判断当前进程是否是主用户进程，如果是主用户，就实例化一个RecentsSystemUser类。
这个类继承IRecentsSystemUserCallbacks这个AIDL，并且传入的参数是一个context和一个RecentsImpl mImpl，这个RecentsImpl里有最近任务许多功能的具体实现。

/** * An implementation of the system user's Recents interface to be called remotely by secondary * users. */public class RecentsSystemUser extends IRecentsSystemUserCallbacks.Stub {

package com.android.systemui.recents;import android.graphics.Rect;/** * Due to the fact that RecentsActivity is per-user, we need to establish an * interface (this) for the non-system user to register itself for callbacks and to * callback to the system user to update internal state. */oneway interface IRecentsSystemUserCallbacks {    void registerNonSystemUserCallbacks(IBinder nonSystemUserCallbacks, int userId);    void updateRecentsVisibility(boolean visible);    void startScreenPinning(int taskId);    void sendRecentsDrawnEvent();    void sendDockingTopTaskEvent(int dragMode, in Rect initialRect);    void sendLaunchRecentsEvent();}

这个AIDL是用于副用户进程的最近任务想主用户进程发送事件的。

4.如果没有副用户启动的话,这部分逻辑就已经结束了。
如果有副用户进程的systemui启动的话，就需要让副用户进程的systemui来和之前这个mSystemToUserCallbacks取得联系。最直接的方式，让副用户进程绑定一个主用户进程的service，
这个service的名字是RecentsSystemUserService。

/** * A strictly system-user service that is started by the secondary user's Recents (with a limited * lifespan), to get the interface that the secondary user's Recents can call through to the system * user's Recents. */public class RecentsSystemUserService extends Service {    private static final String TAG = "RecentsSystemUserService";    private static final boolean DEBUG = false;    @Override    public void onCreate() {        super.onCreate();    }    @Override    public IBinder onBind(Intent intent) {        SystemUIApplication app = (SystemUIApplication) getApplication();        Recents recents = app.getComponent(Recents.class);        if (DEBUG) {            Log.d(TAG, "onBind: " + recents);        }        if (recents != null) {            return recents.getSystemUserCallbacks();        }        return null;    }

5.现在来分析副用户进程的Recents的启动逻辑。
在切换用户的时候，systemui会监听android.intent.action.USER_SWITCHED这个广播，接收到这个广播后，会在副用户空间启动一个新的service，SystemUISecondaryUserService，通过启动这个service，启动了一个新的进程。这部分逻辑在UserSwitcherController这个类里，代码在下面，就不具体分析了。

if (Intent.ACTION_USER_SWITCHED.equals(intent.getAction())) {     if (mExitGuestDialog != null && mExitGuestDialog.isShowing()) {         mExitGuestDialog.cancel();         mExitGuestDialog = null;     }     final int currentId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);     final UserInfo userInfo = mUserManager.getUserInfo(currentId);     final int N = mUsers.size();     for (int i = 0; i < N; i++) {         UserRecord record = mUsers.get(i);         if (record.info == null) continue;         boolean shouldBeCurrent = record.info.id == currentId;         if (record.isCurrent != shouldBeCurrent) {             mUsers.set(i, record.copyWithIsCurrent(shouldBeCurrent));         }         if (shouldBeCurrent && !record.isGuest) {             mLastNonGuestUser = record.info.id;         }         if ((userInfo == null || !userInfo.isAdmin()) && record.isRestricted) {             // Immediately remove restricted records in case the AsyncTask is too slow.             mUsers.remove(i);             i--;         }     }     notifyAdapters();     // Disconnect from the old secondary user's service     if (mSecondaryUser != UserHandle.USER_NULL) {         context.stopServiceAsUser(mSecondaryUserServiceIntent,                 UserHandle.of(mSecondaryUser));         mSecondaryUser = UserHandle.USER_NULL;     }     // Connect to the new secondary user's service (purely to ensure that a persistent     // SystemUI application is created for that user)     if (userInfo != null && !userInfo.isPrimary()) {         context.startServiceAsUser(mSecondaryUserServiceIntent,                 UserHandle.of(userInfo.id));         mSecondaryUser = userInfo.id;     }     if (UserManager.isSplitSystemUser() && userInfo != null && !userInfo.isGuest()             && userInfo.id != UserHandle.USER_SYSTEM) {         showLogoutNotification(currentId);     }     if (userInfo != null && userInfo.isGuest()) {         showGuestNotification(currentId);     }     unpauseRefreshUsers = true; }

6.上面启动了SystemUISecondaryUserService这个service后，这个service的onCreate里面去启动分用户的Recents，和主用户空间的逻辑类似，只是在副用户的systemui进程里，只有两个SystemUI的实例。

    /**     * The classes of the stuff to start for each user.  This is a subset of the services listed     * above.     */    private final Class<?>[] SERVICES_PER_USER = new Class[] {            com.android.systemui.recents.Recents.class,            com.android.systemui.tv.pip.PipUI.class    };

现在，Recents.class已经有两个实例了，分别在两个用户的SystemUI进程中。

7.副用户进程的Recents，执行start方法后，这次判断自身不是主用户了，会执行registerWithSystemUser方法。

    /**     * Attempts to register with the system user.     */    private void registerWithSystemUser() {        final int processUser = sSystemServicesProxy.getProcessUser();        postToSystemUser(new Runnable() {            @Override            public void run() {                try {                    mUserToSystemCallbacks.registerNonSystemUserCallbacks(                            new RecentsImplProxy(mImpl), processUser);                } catch (RemoteException e) {                    Log.e(TAG, "Failed to register", e);                }            }        });    }    /**     * Runs the runnable in the system user's Recents context, connecting to the service if     * necessary.     */    private void postToSystemUser(final Runnable onConnectRunnable) {        mOnConnectRunnables.add(onConnectRunnable);        if (mUserToSystemCallbacks == null) {            Intent systemUserServiceIntent = new Intent();            systemUserServiceIntent.setClass(mContext, RecentsSystemUserService.class);            boolean bound = mContext.bindServiceAsUser(systemUserServiceIntent,                    mUserToSystemServiceConnection, Context.BIND_AUTO_CREATE, UserHandle.SYSTEM);            EventLog.writeEvent(EventLogTags.SYSUI_RECENTS_CONNECTION,                    EventLogConstants.SYSUI_RECENTS_CONNECTION_USER_BIND_SERVICE,                    sSystemServicesProxy.getProcessUser());            if (!bound) {                // Retry after a fixed duration                mHandler.postDelayed(new Runnable() {                    @Override                    public void run() {                        registerWithSystemUser();                    }                }, BIND_TO_SYSTEM_USER_RETRY_DELAY);            }        } else {            runAndFlushOnConnectRunnables();        }    }    /**     * Runs all the queued runnables after a service connection is made.     */    private void runAndFlushOnConnectRunnables() {        for (Runnable r : mOnConnectRunnables) {            r.run();        }        mOnConnectRunnables.clear();    }

8.registerWithSystemUser这个方法的作用是与主用户空间的mSystemToUserCallbacks建立联系。先要执行
postToSystemUser方法，并且把mUserToSystemCallbacks.registerNonSystemUserCallbacks(
new RecentsImplProxy(mImpl), processUser);作为一个Runnable传进去。
一点点分析吧。
这个postToSystemUser方法里，先把参数里的Runnable放到一个全局变量里，然后在mUserToSystemCallbacks不为空的时候调用runAndFlushOnConnectRunnables来把这些Runnable执行并清空。
而mUserToSystemCallbacks是在onServiceConnected里赋值的。总结起来就是绑定service后会把之前的Runnable执行并清空。而这个要绑定的服务就是主用户进程里的RecentsSystemUserService。

再来看这个绑定service传入的ServiceConnection是怎么写的。

    // Only for secondary users, this is the service connection we use to connect to the system user    private final ServiceConnection mUserToSystemServiceConnection = new ServiceConnection() {        @Override        public void onServiceConnected(ComponentName name, IBinder service) {            if (service != null) {                mUserToSystemCallbacks = IRecentsSystemUserCallbacks.Stub.asInterface(                        service);                EventLog.writeEvent(EventLogTags.SYSUI_RECENTS_CONNECTION,                        EventLogConstants.SYSUI_RECENTS_CONNECTION_USER_SYSTEM_BOUND,                        sSystemServicesProxy.getProcessUser());                // Listen for system user's death, so that we can reconnect later                try {                    service.linkToDeath(mUserToSystemCallbacksDeathRcpt, 0);                } catch (RemoteException e) {                    Log.e(TAG, "Lost connection to (System) SystemUI", e);                }                // Run each of the queued runnables                runAndFlushOnConnectRunnables();            }            // Unbind ourselves now that we've registered our callbacks.  The            // binder to the system user are still valid at this point.            mContext.unbindService(this);        }        @Override        public void onServiceDisconnected(ComponentName name) {            // Do nothing        }    };

这个mUserToSystemCallbacks = IRecentsSystemUserCallbacks.Stub.asInterface(
service);可以看出，mUserToSystemCallbacks是RecentsSystemUserService的onBind返回值，
从之前贴过的源码里，可以看到onBind的返回值，是recents.getSystemUserCallbacks()，这个值就是主用户进程里的mSystemToUserCallbacks。所以mUserToSystemCallbacks在这里就被赋值为了mSystemToUserCallbacks（当然不是直接赋值，是一个binder代理）。

所以总结一下这部分的逻辑，就是副用户进程的systemui启动后，绑定主用户进程的RecentsSystemUserService，通过绑定这个service的返回值，拿到了主用户进程里的mSystemToUserCallbacks的代理。再通过这个代理，调用主用户空间的registerNonSystemUserCallbacks，把自身的RecentsImplProxy传到主用户进程去。这样，两个进程就分别拿到对方进程的一个代理，就可以通过这两个代理来相互调用了。
绑定成功后，副用户进程会调用runAndFlushOnConnectRunnables把之前存的Runnable执行并清空，这里的Runnable会有很多，不仅仅是这一个注册的Runnable，还有有最近任务显示状态的变化，开启分屏等等的Runnable。
还通过linkToDeath做了断线重连，重连时间是5秒。

registerNonSystemUserCallbacks的源码在下面。

    @Override    public void registerNonSystemUserCallbacks(final IBinder nonSystemUserCallbacks,            final int userId) {        try {            final IRecentsNonSystemUserCallbacks callback =                    IRecentsNonSystemUserCallbacks.Stub.asInterface(nonSystemUserCallbacks);            nonSystemUserCallbacks.linkToDeath(new IBinder.DeathRecipient() {                @Override                public void binderDied() {                    mNonSystemUserRecents.removeAt(mNonSystemUserRecents.indexOfValue(callback));                    EventLog.writeEvent(EventLogTags.SYSUI_RECENTS_CONNECTION,                            EventLogConstants.SYSUI_RECENTS_CONNECTION_SYSTEM_UNREGISTER_USER,                            userId);                }            }, 0);            mNonSystemUserRecents.put(userId, callback);            EventLog.writeEvent(EventLogTags.SYSUI_RECENTS_CONNECTION,                    EventLogConstants.SYSUI_RECENTS_CONNECTION_SYSTEM_REGISTER_USER, userId);        } catch (RemoteException e) {            Log.e(TAG, "Failed to register NonSystemUserCallbacks", e);        }    }

把副用户的代理SparseArray mNonSystemUserRecents保存在这个列表里，以用户id为key，代理为value。

加深一下记忆，这个时候，主用户进程拿到的副用户代理保存在mSystemToUserCallbacks里的mNonSystemUserRecents列表里，可以通过mSystemToUserCallbacks.getNonSystemUserRecentsForUser(currentUser)得到。代理的实际对象是副用户进程里在registerWithSystemUser方法里的一个new RecentsImplProxy(mImpl)。
副用户进程拿到的主用户代理是Recents里的mUserToSystemCallbacks。代理的实际对象是主用户进程的mSystemToUserCallbacks，是通过new RecentsSystemUser(mContext, mImpl)得到的。

---

---

下面来实际分析一个调度过程

在副用户空间里，按MENU键启动最近任务。

主用户进程向副用户进程传递事件

主用户进程先从PhoneWindowManager里获得toggleRecents事件，经过很多层的调用后，传到Recents里的toggleRecents方法来，这个时候判断当前用户是副用户，主用户进程就调用 IRecentsNonSystemUserCallbacks callbacks =
mSystemToUserCallbacks.getNonSystemUserRecentsForUser(currentUser);拿到副用户的代理，然后调用callbacks.toggleRecents(growTarget);来通知副用户该启动最近任务了。
副用户进程的RecentsImplProxy收到toggleRecents事件，会调用副用户进程里的RecentsImpl的toggleRecents
方法。然后又经过一些处理，调用了 mContext.startActivityAsUser(intent, UserHandle.CURRENT);
来启动RecentsActivity。

副用户进程向主用户进程传递事件

RecentsActivity在触发onStart后，会发送一个RecentsVisibilityChangedEvent事件，这里用了EventBus，Recents里有一个接受RecentsVisibilityChangedEvent事件的地方，在这里判断如果本进程是副用户进程，就执行mUserToSystemCallbacks.updateRecentsVisibility(event.visible)。就触发了主用户进程里mSystemToUserCallbacks的updateRecentsVisibility，再经过一些调用调到了mIwm.setRecentsVisibility(visible)，这一次事件传递就完成了。

本来只是解决一个问题想要顺带写写博客，结果稍微一写就一大篇，继续解决问题去了！