activity的启动流程及框架

最新推荐文章于 2024-07-03 16:21:03 发布

huabuduo

最新推荐文章于 2024-07-03 16:21:03 发布

阅读量948

点赞数

本文链接：https://blog.csdn.net/huabuduo/article/details/51278848

版权

看了activity的启动流程及相关的框架，记录下自己的理解。有些内容直接取自参考文章。

一、几个概念与框架：

1、ActivityManagerService

AMS作为一种系统级服务管理所有Activity，当操作某个Activity时，例如：启动一个新的Activity、停止当前Activity，必须报告给AMS，而不能“擅自处理”。当AMS接受到具体通知时，会根据该通知的类型，首先会更新内部记录，然后在通知相应客户进程（可能有好几个去运行一个新的Activity或者停止指定的Activity。另外，由于AMS记录了所有Activity的信息，当然能够主动的调度这些Activity，甚至在内存不足时，主动杀死后台的Activity。可以把它看做android系统的服务端，客户端当然就是应用程序。

2、ActivityThread

activity对应的主线程（UI线程）类，在主线程用Runnable机制创建的异步线程就没有这个东西。ActivityThread类中实现了一个static main()函数，它是activity的执行入口。

3、 Instrumentation

工具类，有两个主要作用：（1）单向给AMS发消息（下面activity的启动可以看到）；（2）统计、测量应用程序的开销。

4、ApplicationThread

ActivityThread的内部类，该类是一个Binder类，即可实现跨进程通信。主要用于接受从AMS传递过来的消息（貌似跟Instrumentation方向相反），然后做相应处理（比如ApplicationThread收到消息后再由handler机制发给主线程消息队列，继而调用handleMessage做相应处理）。

activity启动时对应的ApplicationThread对象会登记到AMS，AMS根据这个ApplicationThread对象就能给对应的activity回消息。

5、Binder

用于进程间通信的机制，比如客户进程和AMS的消息传递，双向的。Instrumentation和ApplicationThread底层也是用了它。

6、looper / handler

每一个activity都有一个消息队列，looper用于跟这个消息队列绑定。当要创建一个新handler对象（new handler()），如果不指定默认会传一个该activity的looper，在Runnable机制创建的异步线程用新建的handler对象发消息（handler.sendMessage(msg)）就会发到该looper对应的消息队列，主线程收到消息后调用handler的handleMessage来处理。

7、activity对应的主线程（UI线程）最后都会守护在消息队列上，有消息取出来处理，没消息阻塞。

这个不就是linux的线程实现吗，呵呵。

下面这段伪码：

protected void onCreate(Bundle savedInstanceState) {
action a；
//异步线程handler.sendMessage(msg)发给主线程的消息，等到主线执行完onCreate后守护在消息队列上才会被处理到。
Runnable起异步线程去做版本更新；
action b；
}

8、框架图

取自下面参考文章，做了小修改。

二、activity的启动流程

在Android系统中，应用程序是由Launcher启动起来的，其实，Launcher本身也是一个应用程序，其它的应用程序安装后，就会在Launcher的界面上出现一个相应的图标，点击这个图标时，Launcher就会对应的应用程序启动起来。

1、Launcher通过Binder进程间通信机制通知ActivityManagerService，它要启动一个Activity。ActivityManagerService做相关工作，然后通过Binder进程间通信通知Launcher让它进入Paused状态。

Launcher extends 自Activity，本质上也是一Activity。

（1）Launcher主线程中

Launcher.OnClick --> Launcher.startActivitySafely --> Activity.startActivity (可以看到与代码中直接调用startActivity 殊途同归)

--> Activity.startActivityForResult --> Instrumentation.execStartActivity (Instrumentation单向给AMS发消息)

--> ActivityManagerNative.getDefault().startActivity(ActivityManagerNative.getDefault返回ActivityManagerService的远程接口　　

　　　　　ActivityManagerProxy)

-->ActivityManagerProxy.startActivity->mRemote.transact

通过Binder驱动发远程消息给ActivityManagerService，包括待启动Activity的信息，调用者Launcher的一些信息比如它的ApplicationThread对象，ActivityManagerService将使用这个对象来和调用者的ApplicationThread回消息。

（2）ActivityManagerService中

上一步通过Binder驱动程序就进入到ActivityManagerService的startActivity函数来了。

ActivityManagerService.startActivity -->ActivityStack.startActivityMayWait

-->ActivityStack.startActivityLocked -->ActivityStack.startActivityUncheckedLocked

-->Activity.resumeTopActivityLocked --> ActivityStack.startPausingLocked

--> ApplicationThreadProxy.schedulePauseActivity --> mRemote.transact

这一步记录待启动Activity的信息、调用者Launcher的一些信息比如它的ApplicationThread，然后创建一个新的Task并做相应初始化，为后面启动Activity做好准备。然后通过Binder进程间通信（之前保存的Launcher的ApplicationThread派上用场了）通知Launcher让它进入Paused状态。

2、Launcher的ApplicationThread收到来自ActivityManagerService的Pause消息，通过handler机制发给Launcher主线程，Launcher主线程让本身Activity进入Paused状态，然后通过通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去。

上一步ActivityManagerService通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。

(1)Launcher的ApplicationThread收到来自ActivityManagerService的Pause消息，通过handler机制发给Launcher主线程

ApplicationThread.schedulePauseActivity --> ActivityThread.queueOrSendMessage

public final class ActivityThread {
	
	......

	private final void queueOrSendMessage(int what, Object obj, int arg1) {
		queueOrSendMessage(what, obj, arg1, 0);
	}

	private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
		synchronized (this) {
			......
			Message msg = Message.obtain();
			msg.what = what;
			msg.obj = obj;
			msg.arg1 = arg1;
			msg.arg2 = arg2;
			mH.sendMessage(msg);
		}
	}

	......

}

(2)Launcher主线程调用handleMessage处理Pause消息，让本身Activity进入Paused状态，然后通过通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去。

ActivityThread.H.handleMessage-->ActivityThread.handlePauseActivity

-->ActivityManagerProxy.activityPaused-->mRemote.transact

3、ActivityManagerService知道Launcher已经准备就绪进入Paused状态，于是ActivityManagerService就创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行它的main函数。

ActivityManagerService.activityPaused-->ActivityStack.activityPaused

-->ActivityStack.completePauseLocked --> ActivityStack.resumeTopActivityLokced

--> ActivityStack.startSpecificActivityLocked --> ActivityManagerService.startProcessLocked

public final class ActivityManagerService extends ActivityManagerNative
		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

	......

	private final void startProcessLocked(ProcessRecord app,
				String hostingType, String hostingNameStr) {

		......

		try {
			int uid = app.info.uid;
			int[] gids = null;
			try {
				gids = mContext.getPackageManager().getPackageGids(
					app.info.packageName);
			} catch (PackageManager.NameNotFoundException e) {
				......
			}
			
			......

			int debugFlags = 0;
			
			......
			
			int pid = Process.start("android.app.ActivityThread",
				mSimpleProcessManagement ? app.processName : null, uid, uid,
				gids, debugFlags, null);
			
			......

		} catch (RuntimeException e) {
			
			......

		}
	}

	......

}

这里主要是调用Process.start接口来创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行它的main函数。

4、main函数中，创建looper、handler、ActivityThread对象，即将要启动的Activity就是在这个ActivityThread实例中运行。然后将ActivityThread对象中的ApplicationThread成员变量发给ActivityManagerService。

public final class ActivityThread { 

      ......

	private final void attach(boolean system) {
		......

		mSystemThread = system;
		if (!system) {

			......

			IActivityManager mgr = ActivityManagerNative.getDefault();
			try {
                               /*ActivityManagerProxy.attachApplication-->mRemote.transact，将ApplicationThread对象发给*/        

                               /*ActivityManagerService，便于ActivityManagerService与新创建的activity通信。*/
				mgr.attachApplication(mAppThread);  
			} catch (RemoteException ex) {
			}
		} else {

			......

		}
	}

      ......

      public static final void main(String[] args) {
        SamplingProfilerIntegration.start();

       ……

        Looper.prepareMainLooper(); //创建looper，绑定消息队列
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler(); //创建handler，默认参数是looper
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(false); //将ApplicationThread对象发给ActivityManagerService

       ……

        Looper.loop(); //循环，守护在消息队列上。

       ……

        thread.detach(); 

        ……

        Slog.i(TAG, "Main thread of " + name + " is now exiting");
    }
    ......
}

ActivityThread 有几个比较重要的成员变量，会在创建ActivityThread对象时初始化。

（1）final ApplicationThread mAppThread = new ApplicationThread();

ApplicationThread通过binder与Ams通信，并将Ams的调用Pause、Launch等，通过下面的H类（也就是Hnalder）将消息发送到消息队列，然后handleMessage进行相应的处理，最终走入activity的start、 stop等函数。

（2）final H mH = new H();

public final class ActivityThread {

	......

	private final class H extends Handler {

		......

		public void handleMessage(Message msg) {
			......
			switch (msg.what) {
			case LAUNCH_ACTIVITY: {
				ActivityClientRecord r = (ActivityClientRecord)msg.obj;

				r.packageInfo = getPackageInfoNoCheck(
					r.activityInfo.applicationInfo);
				handleLaunchActivity(r, null);
			} break;
			......
			}

		......

	}

	......
}

5、ActivityManagerService登记新创建的Activity的ApplicationThread，然后通过Binder驱动程序进入到新的Activity的ApplicationThread的scheduleLaunchActivity函数中。

ActivityManagerService.attachApplication--> ActivityManagerService.attachApplicationLocked

-->ActivityStack.realStartActivityLocked-->ApplicationThreadProxy.scheduleLaunchActivity

-->mRemote.transact

6、新Activity的ApplicationThread收到来自ActivityManagerService的Launch消息，通过handler机制发给新Activity的主线程，新Activity主线程调用handleMessage处理Launch消息，最终调用MainActivity.onCreate，进入了大多数应用开发的入口。

<1>ApplicationThread.scheduleLaunchActivity-->ActivityThread.queueOrSendMessage:

public final class ActivityThread {

	......

	private final class ApplicationThread extends ApplicationThreadNative {

		......

		// if the thread hasn't started yet, we don't have the handler, so just
		// save the messages until we're ready.
		private final void queueOrSendMessage(int what, Object obj) {
			queueOrSendMessage(what, obj, 0, 0);
		}

		......

		private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
			synchronized (this) {
				......
				Message msg = Message.obtain();
				msg.what = what;
				msg.obj = obj;
				msg.arg1 = arg1;
				msg.arg2 = arg2;
				mH.sendMessage(msg);
			}
		}

		......

	}

	......
}

<2>H.handleMessage-->ActivityThread.handleLaunchActivity-->ActivityThread.performLaunchActivity
-->Instrumentation.callActivityOnCreate-->MainActivity.onCreate

public final class ActivityThread {

	......

	private final class H extends Handler {

		......

		public void handleMessage(Message msg) {
			......
			switch (msg.what) {
			case LAUNCH_ACTIVITY: {
				ActivityClientRecord r = (ActivityClientRecord)msg.obj;

				r.packageInfo = getPackageInfoNoCheck(
					r.activityInfo.applicationInfo);
				handleLaunchActivity(r, null);
			} break;
			......
			}

		......

	}

	......
}

参考文章：
1、Android中ActivityManagerService与应用程序(客户端)通信模型分析

http://blog.csdn.net/qinjuning/article/details/7262769

2、Android应用程序启动过程源代码分析

http://blog.csdn.net/luoshengyang/article/details/6689748