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)，这一次事件传递就完成了。

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