Step 10. ActivityManagerService.attachApplicationLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

1. public final class ActivityManagerService extends ActivityManagerNative
2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
3. ......
4. private final boolean attachApplicationLocked(IApplicationThread thread,
5. int pid) {
6. // Find the application record that is being attached...  either via
7. // the pid if we are running in multiple processes, or just pull the
8. // next app record if we are emulating process with anonymous threads.
9. ProcessRecord app;
10. if (pid != MY_PID && pid >= 0) {
11. synchronized (mPidsSelfLocked) {
12. app = mPidsSelfLocked.get(pid);
13. }
14. } else if (mStartingProcesses.size() > 0) {
15. app = mStartingProcesses.remove(0);
16. app.setPid(pid);
17. } else {
18. app = null;
19. }
20. ......
21. String processName = app.processName;
22. ......
23. app.thread = thread;
24. ......
25. boolean badApp = false;
26. ......
27. // Find any services that should be running in this process...
28. if (!badApp && mPendingServices.size() > 0) {
29. ServiceRecord sr = null;
30. try {
31. for (int i=0; i<mPendingServices.size(); i++) {
32. sr = mPendingServices.get(i);
33. if (app.info.uid != sr.appInfo.uid
34. || !processName.equals(sr.processName)) {
35. continue;
36. }
37. mPendingServices.remove(i);
38. i--;
39. realStartServiceLocked(sr, app);
40. didSomething = true;
41. }
42. } catch (Exception e) {
43. ......
44. }
45. }
46. ......
47. return true;
48. }
49. ......
50. }

回忆一下在上面的Step 4中，以新进程的pid值作为key值保存了一个ProcessRecord在mPidsSelfLocked列表中，这里先把它取出来，存放在本地变量app中，并且将app.processName保存在本地变量processName中。

再回忆一下在上面的Step 3中，在成员变量mPendingServices中，保存了一个ServiceRecord，这里通过进程uid和进程名称将它找出来，然后通过realStartServiceLocked函数来进一步处理。

Step 11. ActivityManagerService.realStartServiceLocked
        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

1. class ActivityManagerProxy implements IActivityManager
2. {
3. ......
4. private final void realStartServiceLocked(ServiceRecord r,
5. ProcessRecord app) throws RemoteException {
6. ......
7. r.app = app;
8. ......
9. try {
10. ......
11. app.thread.scheduleCreateService(r, r.serviceInfo);
12. ......
13. } finally {
14. ......
15. }
16. ......
17. }
18. ......
19. }

这里的app.thread是一个ApplicationThread对象的远程接口，它是在上面的Step 6创建ActivityThread对象时作为ActivityThread对象的成员变量同时创建的，然后在Step 9中传过来的。然后调用这个远程接口的scheduleCreateService函数回到原来的ActivityThread对象中执行启动服务的操作。

Step 12. ApplicationThreadProxy.scheduleCreateService

这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

1. class ApplicationThreadProxy implements IApplicationThread {
2. ......
3. public final void scheduleCreateService(IBinder token, ServiceInfo info)
4. throws RemoteException {
5. Parcel data = Parcel.obtain();
6. data.writeInterfaceToken(IApplicationThread.descriptor);
7. data.writeStrongBinder(token);
8. info.writeToParcel(data, 0);
9. mRemote.transact(SCHEDULE_CREATE_SERVICE_TRANSACTION, data, null,
10. IBinder.FLAG_ONEWAY);
11. data.recycle();
12. }
13. ......
14. }

这里通过Binder驱动程序回到新进程的ApplicationThread对象中去执行scheduleCreateService函数。

Step 13. ApplicationThread.scheduleCreateService

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
2. ......
3. private final class ApplicationThread extends ApplicationThreadNative {
4. ......
5. public final void scheduleCreateService(IBinder token,
6. ServiceInfo info) {
7. CreateServiceData s = new CreateServiceData();
8. s.token = token;
9. s.info = info;
10. queueOrSendMessage(H.CREATE_SERVICE, s);
11. }
12. ......
13. }
14. ......
15. }

这里调用ActivityThread的queueOrSendMessage将一个CreateServiceData数据放到消息队列中去，并且分开这个消息。注意，这里已经是在上面Step 4创建的新进程中执行了。

Step 14. ActivityThread.queueOrSendMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
2. ......
3. private final void queueOrSendMessage(int what, Object obj) {
4. queueOrSendMessage(what, obj, 0, 0);
5. }
6. private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
7. synchronized (this) {
8. ......
9. Message msg = Message.obtain();
10. msg.what = what;
11. msg.obj = obj;
12. msg.arg1 = arg1;
13. msg.arg2 = arg2;
14. mH.sendMessage(msg);
15. }
16. }
17. ......
18. }

这里调用成员变量mH的sendMessage函数进行消息分发。这里的mH的类型为H，它继承于Handler类。

Step 15. H.sendMessage

这个函数继承于Handle类的sendMessage函数中，定义在frameworks/base/core/java/android/os/Handler.java文件中。这个函数我们就不看了，有兴趣的读者可以自己研究一下。消息分发以后，就进入到H.handleMessage函数进行处理了。

Step 16. H.handleMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
2. ......
3. private final class H extends Handler {
4. ......
5. public void handleMessage(Message msg) {
6. ......
7. switch (msg.what) {
8. ......
9. case CREATE_SERVICE:
10. handleCreateService((CreateServiceData)msg.obj);
11. break;
12. ......
13. }
14. ......
15. }
16. ......
17. }
18. ......
19. }

这里要处理的消息是CREATE_SERVICE，它调用ActivityThread类的handleCreateService成员函数进一步处理。

Step 17. ActivityThread.handleCreateService

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
2. ......
3. private final void handleCreateService(CreateServiceData data) {
4. // If we are getting ready to gc after going to the background, well
5. // we are back active so skip it.
6. unscheduleGcIdler();
7. LoadedApk packageInfo = getPackageInfoNoCheck(
8. data.info.applicationInfo);
9. Service service = null;
10. try {
11. java.lang.ClassLoader cl = packageInfo.getClassLoader();
12. service = (Service) cl.loadClass(data.info.name).newInstance();
13. } catch (Exception e) {
14. if (!mInstrumentation.onException(service, e)) {
15. throw new RuntimeException(
16. "Unable to instantiate service " + data.info.name
17. + ": " + e.toString(), e);
18. }
19. }
20. try {
21. if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);
22. ContextImpl context = new ContextImpl();
23. context.init(packageInfo, null, this);
24. Application app = packageInfo.makeApplication(false, mInstrumentation);
25. context.setOuterContext(service);
26. service.attach(context, this, data.info.name, data.token, app,
27. ActivityManagerNative.getDefault());
28. service.onCreate();
29. mServices.put(data.token, service);
30. try {
31. ActivityManagerNative.getDefault().serviceDoneExecuting(
32. data.token, 0, 0, 0);
33. } catch (RemoteException e) {
34. // nothing to do.
35. }
36. } catch (Exception e) {
37. if (!mInstrumentation.onException(service, e)) {
38. throw new RuntimeException(
39. "Unable to create service " + data.info.name
40. + ": " + e.toString(), e);
41. }
42. }
43. }
44. ......
45. }

这里的data.info.name就是自定义的服务类shy.luo.ashmem.Server了。

Step 18. ClassLoader.loadClass

这一步实现在上面的ActivityThread.handleCreateService函数中：

1. java.lang.ClassLoader cl = packageInfo.getClassLoader();
2. service = (Service) cl.loadClass(data.info.name).newInstance();

Step 19. Obtain Service

这一步也是实现在上面的ActivityThread.handleCreateService函数中。上面通过ClassLoader.loadClass来导入自定义的服务类shy.luo.ashmem.Server并且创建它的一个实例后，就通过强制类型转换得到一个Service类实例。前面我们说过，自己的服务类必须要继承于Service类，这里就体现出来了为什么要这样做了。

Step 20. Service.onCreate

这一步继续实现在上面的ActivityThread.handleCreateService函数中：

1. service.onCreate();

因为这里的service实际上是一个shy.luo.ashmem.Server类实例，因此，这里就是执行shy.luo.ashmem.Server类的onCreate函数了：

1. public class Server extends Service {
2. ......
3. @Override
4. public void onCreate() {
5. ......
6. }
7. ......
8. }

至此，这个自定义的服务就启动起来了。

这样，Android系统在新进程中启动服务的过程就分析完成了，虽然很复杂，但是条理很清晰。它通过三次Binder进程间通信完成了服务的启动过程，分别是：

一. Step 1至Step 7，从主进程调用到ActivityManagerService进程中，完成新进程的创建；

二. Step 8至Step 11，从新进程调用到ActivityManagerService进程中，获取要在新进程启动的服务的相关信息；

三. Step 12至Step 20，从ActivityManagerService进程又回到新进程中，最终将服务启动起来。

学习完Android系统在新进程中启动服务的过程后，希望读者对Android系统的Service有一个深刻的理解。在编写Android应用程序的时候，尽量把一些计算型的逻辑以Service在形式来实现，使得这些耗时的计算能在一个独立的进程中进行，这样就能保持主进程流畅地响应界面事件，提高用户体验。

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/965589，如需转载请自行联系原作者