ActivityManagerService梳理，以及涉及AMS的Activity启动流程分析

AMS概览

ActivityManagerService是android系统中一个特别重要的系统服务，也是和上层APP打交道最多的系统服务之一。AMS主要负责四大组建的启动、切换、调度以及应用进程的管理和调度工作。所有的APP应用都需要与AMS打交道。

ActivityManager的组成主要分为以下几个部分：

1.服务代理：ActivityManagerProxy实现，用于与server端提供的系统服务进行进程间通信

2.服务中枢：ActivityManagerNative继承自Binder，并实现IActivityManager，它提供了服务接口和Binder接口相互转化功能，并在内部存储服务代理对象，并提供了getDefault方法返回服务代理

3.Client：由ActivityManager封装一部分服务接口供Client调用。ActivityManager内部通过调用ActivityManagerNative的getDefault方法，可以得到一个ActivityManagerProxy对象的引用，进而通过该代理对象调用远程服务的方法

4.Server：由ActivityManagerService实现，提供Server端的系统服务

ActivityManagerService的启动过程

AMS是在SystemServer中被添加的，AMS在SystemServer中初始化过程

public static void main(String[] args) {
    new SystemServer().run();
}

run函数 startBootstrapServices

private void run() {
    //...........省略部分代码
    // Initialize the system context.
    createSystemContext();

    // Create the system service manager.
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
    // Start services.
    try {
        startBootstrapServices(); //在这里面启动了AMS
        startCoreServices();
        startOtherServices();
    } catch (Throwable ex) {
        //..................
    }
    //..........省略部分代码
    // Loop forever.
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

startBootstrapService

private void startBootstrapServices() {
    // Wait for installd to finish starting up so that it has a chance to
    // create critical directories such as /data/user with the appropriate
    // permissions.  We need this to complete before we initialize other services.
    Installer installer = mSystemServiceManager.startService(Installer.class);

    // Activity manager runs the show.
    mActivityManagerService = mSystemServiceManager.startService( //启动AMS
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);//设置SystemServiceManager
    mActivityManagerService.setInstaller(installer); //设置安装器 Installer

    // Power manager needs to be started early because other services need it.
    // Native daemons may be watching for it to be registered so it must be ready
    // to handle incoming binder calls immediately (including being able to verify
    // the permissions for those calls).
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class); //启动PowerManagerService

    // Now that the power manager has been started, let the activity manager
    // initialize power management features.
    mActivityManagerService.initPowerManagement();//初始化AMS中的PowerManager

    // Display manager is needed to provide display metrics before package manager
    // starts up.
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class); //启动DisplayManagerService

    // We need the default display before we can initialize the package manager.
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

    // Only run "core" apps if we're encrypting the device.
    String cryptState = SystemProperties.get("vold.decrypt");
    if (ENCRYPTING_STATE.equals(cryptState)) {
        Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
        mOnlyCore = true;
    } else if (ENCRYPTED_STATE.equals(cryptState)) {
        Slog.w(TAG, "Device encrypted - only parsing core apps");
        mOnlyCore = true;
    }

    // Start the package manager.
    Slog.i(TAG, "Package Manager");
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();

    Slog.i(TAG, "User Service");
    ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

    // Initialize attribute cache used to cache resources from packages.
    AttributeCache.init(mSystemContext);

    // Set up the Application instance for the system process and get started.
    mActivityManagerService.setSystemProcess();
}

SystemServiceManager.java ------ mSystemServiceManager.startService

public <T extends SystemService> T startService(Class<T> serviceClass) {
    //.........省略部分代码
    // Register it.
    mServices.add(service);  //将service加入到mServices ArraryList中
    // Start it.
    try {
        service.onStart();  //调用service的onStart函数
    } catch (RuntimeException ex) {
        throw new RuntimeException("Failed to start service " + name
                + ": onStart threw an exception", ex);
    }
    return service;
}

以PowerManagerService为例 ------ public final class PowerManagerService extends SystemService

public void onStart() {
    publishBinderService(Context.POWER_SERVICE, new BinderService());
    publishLocalService(PowerManagerInternal.class, new LocalService());
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

SystemService.java ----- publishBinderService

protected final void publishBinderService(String name, IBinder service,
        boolean allowIsolated) {
    ServiceManager.addService(name, service, allowIsolated); 将sevice注册到ServiceManager,之后就可以由serviceManager将service 获取到
}

AMS构造方法里面做了些什么

public ActivityManagerService(Context systemContext) {
    mContext = systemContext;
    mFactoryTest = FactoryTest.getMode();
    mSystemThread = ActivityThread.currentActivityThread(); //获取当前的thread
    mHandlerThread = new ServiceThread(TAG,  //创建Handler线程，THREAD_PRIORITY_FOREGROUND //标准前台线程优先级
            android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper()); //获取绑定主线程Looper
    //初始化管理前台、后台广播队列， 系统会优先遍历发送前台广播。
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "foreground", BROADCAST_FG_TIMEOUT, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "background", BROADCAST_BG_TIMEOUT, true);
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;
    //初始化管理service的ActiveServices对象
    mServices = new ActiveServices(this);
    mProviderMap = new ProviderMap(this); //初始化provider的管理者

    // TODO: Move creation of battery stats service outside of activity manager service.
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    mBatteryStatsService = new BatteryStatsService(systemDir, mHandler); //创建电池统计服务，并输出到指定目录
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.getActiveStatistics().writeAsyncLocked();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery(); //创建进程统计分析服务，追踪统计哪些进程有滥用或者不良行为
    mBatteryStatsService.getActiveStatistics().setCallback(this);

    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
    //加载Uri的授权文件
    mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

    // User 0 is the first and only user that runs at boot.
    mStartedUsers.put(0, new UserStartedState(new UserHandle(0), true));
    mUserLru.add(Integer.valueOf(0));
    updateStartedUserArrayLocked();

    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", //初始化openGL版本号
        ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));

    mConfiguration.setToDefaults();
    mConfiguration.locale = Locale.getDefault();

    mConfigurationSeq = mConfiguration.seq = 1;
    mProcessCpuTracker.init();

    mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
    mStackSupervisor = new ActivityStackSupervisor(this); //管理ActivityStack的重要类，这里面记录Activity状态信息，是AMS中的核心类
    mTaskPersister = new TaskPersister(systemDir, mStackSupervisor);
    //启动一个线程专门跟进cpu的当前状态信息，AMS对当前cpu状态了如指掌，可以高效的分配工作
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            while (true) {
                try {
                    try {
                        synchronized(this) {
                            final long now = SystemClock.uptimeMillis();
                            long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                            long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                            //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
                            //        + ", write delay=" + nextWriteDelay);
                            if (nextWriteDelay < nextCpuDelay) {
                                nextCpuDelay = nextWriteDelay;
                            }
                            if (nextCpuDelay > 0) {
                                mProcessCpuMutexFree.set(true);
                                this.wait(nextCpuDelay);
                            }
                        }
                    } catch (InterruptedException e) {
                    }
                    updateCpuStatsNow();
                } catch (Exception e) {
                    Slog.e(TAG, "Unexpected exception collecting process stats", e);
                }
            }
        }
    };

    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

继续看SystemServer run中的setSystemProcess函数

public void setSystemProcess() {
    try {
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true); //将ActivityManagerService注册到ServiceManager中
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats); //下面将几个与系统性能调试相关的服务注册到ServiceManager中
        ServiceManager.addService("meminfo", new MemBinder(this));
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        ServiceManager.addService("dbinfo", new DbBinder(this));
        if (MONITOR_CPU_USAGE) {
            ServiceManager.addService("cpuinfo", new CpuBinder(this));
        }
        ServiceManager.addService("permission", new PermissionController(this));
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo( //通过pkms查询包名为"android"的应用程序的applicationinfo，对应于
                "android", STOCK_PM_FLAGS);                                     //framework-res.apk。
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());//以info为参数调用installSystemApplicationInfo
        synchronized (this) {
            ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0); //创建processRecord。并保存该对象
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            mProcessNames.put(app.processName, app.uid, app);
            synchronized (mPidsSelfLocked) {
                mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }
}

AMS是什么？？？

1.从java的角度来看，AMS就是一个java对象，实现了Ibinder接口，所以它是一个用于进程间通信的接口，在SystemServer.java的run()里面初始化

2.AMS是一个服务，用来管理Activity，并且它是一个系统服务，包管理服务，电池管理服务，震动管理服务

3.AMS是一个Binder

AMS实现了Ibinder接口，它是一个Binder，意味着它不但可以用于进程间通信，它还是一个线程，因为Binder就是一个线程。

如果我们启动一个Hello word安卓应用程序，里面不启动其它线程，这里面最少要启动4个线程。

<1>main线程，ActivityThread，每个应用都有分配属于自己的一个虚拟机，都有自己的main函数，这个主线程也叫UI线程，因为android的组件是非线程安全的，所以只允许UI/MAIN线程来更新UI。

<2>GC线程，java有垃圾回收机制，每一个java程序都有专门负责垃圾回收的线程

<3>Binder1就是ApplicationThread, 这个类也实现了IBinder接口，用于进程间通信，具体来说就是我们应用程序和AMS通信的工具。

<4>Binder2就是我们ViewRootImpl.W对象，它也实现了IBinder接口，用于我们的应用程序和WMS(WindowManagerService)通信。

AMS相关类介绍

与Activity管理有关的数据结构

ActivityRecord

ActivityRecord历史栈中的一个条目，代表一个Activity

final class ActivityRecord extends ConfigurationContainer implements AppWindowContainerListener {
    final ActivityManagerService service; // owner
    final IApplicationToken.Stub appToken; // window manager token
    AppWindowContainerController mWindowContainerController;
    final ActivityInfo info; // all about me
    final ApplicationInfo appInfo; // information about activity's app
    //.........省略其它成员变量
    //ActivityRecord所在的TaskRecord
    private TaskRecord task;        // the task this is in.
}

ActivityRecord中存在着大量的成员变量，包含了一个Activity的所有信息，ActivityRecord中的成员变量task表示其所在的TaskRecord，在这里ActivityRecord和TaskRecord建立了联系。

TaskRecord

TaskRecord内部维护一个ArrayList<ActivityRecord>来保存ActivityRecord。

frameworks/base/services/core/java/com/android/server/am/TaskRecord.java

final class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
    final int taskId;       // Unique identifier for this task. 任务ID
    final ArrayList<ActivityRecord> mActivities; //使用一个ArrayList来保存所有的ActivityRecord
    private ActivityStack mStack; //TaskRecord所在的ActivityStack
}

添加activity到栈顶

void addActivityToTop(ActivityRecord r) {
        addActivityAtIndex(mActivities.size(), r);
    }

添加activity到指定的索引位置

void addActivityAtIndex(int index, ActivityRecord r) {
   //......省略部分代码
        r.setTask(this);//为ActivityRecord设置TaskRecord，在这里建立两者之间的联系

        index = Math.min(size, index);
        mActivities.add(index, r); //将ActivityRecord添加到ArrayList<ActivityRecord> mActivities

    }

可以看到TaskRecord中使用了一个ArrayList来保存所有的ActivityRecord。同样TaskRecord中的mStack代表其所在的ActivityStack。startActivity()时也会创建一个TaskRecord。

ActitityStarter

frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java

class ActivityStarter {
    private int setTaskFromReuseOrCreateNewTask(
            TaskRecord taskToAffiliate, int preferredLaunchStackId, ActivityStack topStack) {
       //private ActivityStack mTargetStack;  是ActivityStack
        mTargetStack = computeStackFocus(
                mStartActivity, true, mLaunchBounds, mLaunchFlags, mOptions);

        if (mReuseTask == null) {
            //由ActivityStack来创建TaskRecord
            final TaskRecord task = mTargetStack.createTaskRecord(
                    mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
                    mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
                    mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
                    mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity.mActivityType);
            
        }
        return START_SUCCESS;
    }
}

ActivityStack

ActivityStack内部维护了一个ArrayList<TaskRecord>，用来管理TaskRecod

class ActivityStack<T extends StackWindowController> extends ConfigurationContainer implements StackWindowListener {
    private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();//使用一个ArrayList来保存TaskRecord
    protected final ActivityStackSupervisor mStackSupervisor; //持有一个ActivityStackSupervisior，所有运行中的ActivityStacks都通过它来进行管理
}

createTaskRecord

TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            boolean toTop, int type) {
        TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession,voiceInteractor, type); //床将一个TaskRecord
        // add the task to stack first, mTaskPositioner might need the stack association
        addTask(task, toTop, "createTaskRecord"); //将task添加到ActivityStack中去
        final boolean isLockscreenShown = mService.mStackSupervisor.mKeyguardController
                .isKeyguardShowing(mDisplayId != INVALID_DISPLAY ? mDisplayId : DEFAULT_DISPLAY);
        if (!layoutTaskInStack(task, info.windowLayout) && mBounds != null && task.isResizeable()
                && !isLockscreenShown) {
            task.updateOverrideConfiguration(mBounds);
        }
        task.createWindowContainer(toTop, (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
        return task;
    }

addTask

void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
            String reason) {
        // TODO: Is this remove really needed? Need to look into the call path for the other addTask
        mTaskHistory.remove(task); //如果ArrayList<TaskRecord> mTaskHistory中有这个task就先移除
        position = getAdjustedPositionForTask(task, position, null /* starting */);
        final boolean toTop = position >= mTaskHistory.size();
        final ActivityStack prevStack = preAddTask(task, reason, toTop); 之前TaskRecord中的ActivityStack先移除
        mTaskHistory.add(position, task); //将TaskRecord添加到mTaskHistory的指定位置上
        task.setStack(this); //为TaskRecord设置ActivityStack
        if (toTop) {
            updateTaskReturnToForTopInsertion(task);
        }
        updateTaskMovement(task, toTop);
        postAddTask(task, prevStack, schedulePictureInPictureModeChange);
    }

可以看到ActivityStack使用了一个ArrayList来保存TaskRecord。另外ActivityStack中还持有ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisior就是用来管理ActivityStack的。

ActivityStackSupervisior

/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {
    ActivityStack mHomeStack; //管理Launcher相关的任务
    ActivityStack mFocusedStack; //管理非Launcher相关的任务
}

createStack

ActivityStack createStack(int stackId, ActivityDisplay display, boolean onTop) {
        switch (stackId) {
            case PINNED_STACK_ID:
                //PinnedActivityStack是ActivityStack的子类
                return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
            default:
                //创建一个ActivityStack
                return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
        }
    }

ActivityStackSupervisior内部有两个不同的AcvityStack对象，mHomeStack、mFocusedStack，用来管理不同的任务。ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。AMS初始化时会创建一个ActivityStackSupervisor对象

Actvity启动流程相关

Launcher请求AMS阶段

AMS到ApplicationThread阶段

ApplicationThread到Activity阶段