ActivityManagerService框架粗略分析

前言

AMS是系统的引导服务，应用进程的启动、切换和调度、四大组件的启动和管理都需要AMS的支持。Android应用各个组件都是通过AMS调度，Android进程也是AMS创建，Android应用程序启动之前先启动进程，然后启动对应的Activity

AMS框架

从Launcher开始

应用启动可以通过adb启动，可以通过其他应用启动（包括Launcher），也可以通过监听广播启动。一般启动一个Android应用都是从Launcher开始，通过点击桌面图标启动一个应用程序。

1. 点击Launcher启动图标，执行Activity的startActivityForResults

Activity.java

   public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {    
    ...
    Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);...
    ...
    }

2. startActivityForResults中Instrumentation对象执行execStartActivity,其中注意mMainThread.getApplicationThread()这个参数,这个是所启动这个Activity应用里面的ApplicationThread,继承IApplicationThread.Stub,显然这是一个用于跨进程通讯的类.其中ApplicationThread是服务端,它传输到AMS,那么AMS对于ApplicationThread就是客户端.因为Binder是客户服务模式,只能从客户端主动请求,传入对于binder到AMS客户让AMS能够主动与应用交互,
3. execStartActivity中通过ActivityManger与ActivityManagerService跨进程通讯

Instrumentation.java

    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, String resultWho,
            Intent intent, int requestCode, Bundle options, UserHandle user) {
        IApplicationThread whoThread = (IApplicationThread) contextThread; //1
       ...
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityManager.getService() //2
                .startActivityAsUser(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, resultWho,
                        requestCode, 0, null, options, user.getIdentifier());
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

Instrumentation：

• 在ActivityThread中实例化
• 用于监控系统与应用程序交互
• 用于单元测试

ActivityManager：

• ActivityManager是一个和AMS相关联的类，它主要对运行中的Activity进行管理，这些管理工作并不是由ActivityManager来处理的，而是交由AMS来处理
• AMS作为系统核心服务，很多API是不会暴露给ActivityManager的
• Activity通过binder与AMS交互
• binder的service_server可以向service_client提供service服务，但反过来不行。所以binder service其实是单向的,上面1传入的当前应用的IApplicationThread，如果该IApplicationThread就是此时启动的Activity，那么AMS会使用该IApplicationThread与这个应用的ActivityThread交互。
  上面注2,int result = ActivityManager.getService() //2 这里对应代码
  ActivityManager.java

    /**
     * @hide
     */
    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

    private static final Singleton IActivityManagerSingleton =
            new Singleton() {
                @Override
                protected IActivityManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };

IActivityManager.Stub.asInterface(b);如果此时调用与实际实现不在一个进程会生成一个可供跨进程通讯的接口,应用里面写AIDL也有同样的操作.

然后调用IActivityManager的startActivity方法,把数据传递到AMS中

@Override public int startActivity(android.app.IApplicationThread caller, java.lang.String callingPackage, android.content.Intent intent, java.lang.String resolvedType, android.os.IBinder resultTo, java.lang.String resultWho, int requestCode, int flags, android.app.ProfilerInfo profilerInfo, android.os.Bundle options) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((((caller!=null))?(caller.asBinder()):(null)));
_data.writeString(callingPackage);
if ((intent!=null)) {
_data.writeInt(1);
intent.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
_data.writeString(resolvedType);
_data.writeStrongBinder(resultTo);
_data.writeString(resultWho);
_data.writeInt(requestCode);
_data.writeInt(flags);
if ((profilerInfo!=null)) {
_data.writeInt(1);
profilerInfo.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
if ((options!=null)) {
_data.writeInt(1);
options.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_startActivity, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}

ActivityManagerService

1. ActivityManagerService调用startActivityAsUser

    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
            boolean validateIncomingUser) {
        enforceNotIsolatedCaller("startActivity");

        userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        return mActivityStartController.obtainStarter(intent, "startActivityAsUser")//3
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

上面3处的mActivityStartController.obtainStarter返回的是ActivityStarter

ActivityStartController

    ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }

2. ActivityStarter管理Activity的launchmode，ActivityStarter下一步通过ActivityStackSupervisor完成与ActivityThread（应用端）交互。ActivityStackSupervisor由AMS创建，如下：

ActivityManagerService.java

    protected ActivityStackSupervisor createStackSupervisor() {
        final ActivityStackSupervisor supervisor = new ActivityStackSupervisor(this, mHandler.getLooper());
        supervisor.initialize();
        return supervisor;
    }

ActivityStarter通过ActivityStackSupervisor，判断应用进程是否存在

ActivityStackSupervisor.java

    void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,//4
                r.info.applicationInfo.uid, true);

        getLaunchTimeTracker().setLaunchTime(r);

        if (app != null && app.thread != null) {//5
            try {
                if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                        || !"android".equals(r.info.packageName)) {
                    // Don't add this if it is a platform component that is marked
                    // to run in multiple processes, because this is actually
                    // part of the framework so doesn't make sense to track as a
                    // separate apk in the process.
                    app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
                            mService.mProcessStats);
                }
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }

            // If a dead object exception was thrown -- fall through to
            // restart the application.
        }

        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,//5
                "activity", r.intent.getComponent(), false, false, true);
    }

在4处，查询应用进程是否存在，如果不存在,在5处会开始新的进程,这是一个十分重要的步骤，否则在4处执行完成后直接return。

ActivityManagerService

• ActivityManagerService负责四大组件的调用和应用进程的创建

ActivityStarter

• ActivityStarter管理Activity的启动模式：singleTask，SIngtop等等，还有flag也是在其中处理的

ActivityStackSupervisor

• ActivityStack从名称来看是跟栈相关的类，其实它是一个管理类，用来管理系统所有Activity的各种状态。它由ActivityStackSupervisor来进行管理的，而ActivityStackSupervisor在AMS中的构造方法中被创建。
• ActivityStackSupervisor管理了当前应用的Activitytaskh和HomeActivityTask
• ActivityStack是应用的activity的task
• ActivityStack保存的TaskRecord，Task里面保存着ActivityRecord

AMS创建进程与应用启动

在上面提到如果启动的Activity进程不存在，AMS就会创建进程。AMS创建进程是AMS通过Zygoted socket通讯。Zygoted通过传过来的信息fork新的进程，启动应用ActivityThread的main方法，把IApplication保存在AMS中。

Zygote：

• zygote在系统启动时启动的，他在孵化出SystemService后循环等待AMS的socket通讯
• zygote启动的时候创建的虚拟机，但是没有创建binder，因为zygote只需要与AMS进行socket通讯
• RuntimeInit创建的binder线程池，他在zygote孵化新的进程后运行。通过反射启动ActivityThread

ActivityThread

• 启动消息循环，通过消息循环控制Activity主线程与其他线程交互
• 创建Applcaition，通过ApplcaitionThread的binder与AMS交互，AMS通过IApplaction管理Activit的生命周期

…看不下去了…

总结

1. 了解Instumentation，ActivityManager，AMS，ActivityStacSuperVisor，ActivityTask，ActivityThread，ApplcaitionThread，zygote，ActivityStarter作用和功能
2. 了解相关流程
3. 知道binder是单向通讯，所以AMS与Activity交互除了用AMS的binder，还得用ApplicationThread的binder