文章转载至CSDN社区罗升阳的安卓之旅，原文地址：http://blog.csdn.net/luoshengyang/article/details/6677029

在 编写Android应用程序时，我们一般将一些计算型的逻辑放在一个独立的进程来处理，这样主进程仍然可以流畅地响应界面事件，提高用户体验。 Android系统为我们提供了一个Service类，我们可以实现一个以Service为基类的服务子类，在里面实现自己的计算型逻辑，然后在主进程通 过startService函数来启动这个服务。在本文中，将详细分析主进程是如何通过startService函数来在新进程中启动自定义服务的。

在主进程调用startService函数时，会通过Binder进程间通信机制来通知ActivitManagerService来创建新进程，并且 启动指定的服务。在Android系统中，Binder进程间通信机制使用非常广泛，因此，希望读者在继续阅读下面的内容之前，对Android系统和 Binder进程间通信机制有一定的了解，具体可以参考前面Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。

关于startService的具体用法，可以参考前面Android系统匿名共享内存Ashmem（Anonymous Shared Memory）简要介绍和学习计划一文中用到的实例，它是Activity类的一个成员函数：

[java] view plaincopy
  1. package shy.luo.ashmem;
  2. ......
  3. public class Client extends Activity implements OnClickListener {
  4. ......
  5. IMemoryService memoryService = null;
  6. ......
  7. @Override
  8. public void onCreate(Bundle savedInstanceState) {
  9. ......
  10. IMemoryService ms = getMemoryService();
  11. if(ms == null) {
  12. startService(new Intent("shy.luo.ashmem.server"));
  13. } else {
  14. Log.i(LOG_TAG, "Memory Service has started.");
  15. }
  16. ......
  17. Log.i(LOG_TAG, "Client Activity Created.");
  18. }
  19. ......
  20. }

这里的“shy.luo.ashmem.server”是在程序配置文件AndroidManifest.xml配置的Service的名字，用来告诉Android系统它所要启动的服务的名字：

[java] view plaincopy
  1. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  2. package="shy.luo.ashmem"
  3. android:sharedUserId="android.uid.system"
  4. android:versionCode="1"
  5. android:versionName="1.0">
  6. <application android:icon="@drawable/icon" android:label="@string/app_name">
  7. ......
  8. <service
  9. android:enabled="true"
  10. android:name=".Server"
  11. android:process=".Server" >
  12. <intent-filter>
  13. <action android:name="shy.luo.ashmem.server"/>
  14. <category android:name="android.intent.category.DEFAULT"/>
  15. </intent-filter>
  16. </service>
  17. </application>
  18. </manifest>

这里，名字“shy.luo.ashmem.server”对应的服务类为shy.luo.ashmem.Server，下面语句：

[java] view plaincopy
  1. startService(new Intent("shy.luo.ashmem.server"));

就表示要在一个新的进程中启动shy.luo.ashmem.Server这个服务类，它必须继承于Android平台提供的Service类：

[java] view plaincopy
  1. package shy.luo.ashmem;
  2. ......
  3. public class Server extends Service {
  4. ......
  5. @Override
  6. public IBinder onBind(Intent intent) {
  7. return null;
  8. }
  9. @Override
  10. public void onCreate() {
  11. ......
  12. }
  13. ......
  14. }

下面，我们来看看Activity类中的startService成员函数是如何实现的。

先来看看Activity的类图：


        从图中可以看出，Activity继承了ContextWrapper类，而在ContextWrapper类中，实现了startService函 数。在ContextWrapper类中，有一个成员变量mBase，它是一个ContextImpl实例，而ContextImpl类和 ContextWrapper类一样继承于Context类，ContextWrapper类的startService函数最终过调用 ContextImpl类的startService函数来实现。这种类设计方法在设计模式里面，就称之为装饰模式（Decorator），或者包装模式 （Wrapper）。

在ContextImpl类的startService类，最终又调用了ActivityManagerProxy类的startService来实现启动服务的操作，看到这里的Proxy关键字，回忆一下前面Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码分析这篇文章，就会知道ActivityManagerProxy是一个Binder对象的远程接口了，而这个Binder对象就是我们前面所说的ActivityManagerService了。

这个ActivityManagerService类实现在frameworks/base/services/java/com/android /server/am/ActivityManagerService.java文件中，它是Binder进程间通信机制中的Server角色，它是随机 启动的。随机启动的Server是在frameworks/base/services/java/com/android/server /SystemServer.java文件里面进行启动的，我们来看一下ActivityManagerService启动相关的代码：

[java] view plaincopy
  1. class ServerThread extends Thread {
  2. ......
  3. @Override
  4. public void run() {
  5. ......
  6. // Critical services...
  7. try {
  8. ......
  9. context = ActivityManagerService.main(factoryTest);
  10. ......
  11. ActivityManagerService.setSystemProcess();
  12. ......
  13. } catch (RuntimeException e) {
  14. Slog.e("System", "Failure starting core service", e);
  15. }
  16. ......
  17. }
  18. ......
  19. }

首先是调用ActivityManagerService.main函数来创建一个ActivityManagerService实例，然后通过调用 ActivityManagerService.setSystemProcess函数把这个Binder实例添加Binder进程间通信机制的守护进程 ServiceManager中去：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. static ActivityManagerService mSelf;
  5. ......
  6. public static void setSystemProcess() {
  7. try {
  8. ActivityManagerService m = mSelf;
  9. ServiceManager.addService("activity", m);
  10. ......
  11. } catch (PackageManager.NameNotFoundException e) {
  12. ......
  13. }
  14. }
  15. ......
  16. public static final Context main(int factoryTest) {
  17. ......
  18. ActivityManagerService m = thr.mService;
  19. mSelf = m;
  20. ......
  21. }
  22. }

这样，ActivityManagerService就启动起来了。

回到ActivityManagerProxy类的startService函数中，它定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

[java] view plaincopy
  1. class ActivityManagerProxy implements IActivityManager
  2. {
  3. ......
  4. public ComponentName startService(IApplicationThread caller, Intent service,
  5. String resolvedType) throws RemoteException
  6. {
  7. Parcel data = Parcel.obtain();
  8. Parcel reply = Parcel.obtain();
  9. data.writeInterfaceToken(IActivityManager.descriptor);
  10. data.writeStrongBinder(caller != null ? caller.asBinder() : null);
  11. service.writeToParcel(data, 0);
  12. data.writeString(resolvedType);
  13. mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
  14. reply.readException();
  15. ComponentName res = ComponentName.readFromParcel(reply);
  16. data.recycle();
  17. reply.recycle();
  18. return res;
  19. }
  20. ......
  21. }

参数service是一个Intent实例，它里面指定了要启动的服务的名称，就是前面我们所说的“shy.luo.ashmem.server”了。

参数caller是一个IApplicationThread实例，它是一个在主进程创建的一个Binder对象。在Android应用程序中，每一个进 程都用一个ActivityThread实例来表示，而在ActivityThread类中，有一个成员变量mAppThread，它是一个 ApplicationThread实例，实现了IApplicationThread接口，它的作用是用来辅助ActivityThread类来执行一 些操作，这个我们在后面会看到它是如何用来启动服务的。

参数resolvedType是一个字符串，它表示service这个Intent的MIME类型，它是在解析Intent时用到的。在这个例子中，我们没有指定这个Intent 的MIME类型，因此，这个参数为null。

ActivityManagerProxy类的startService函数把这三个参数写入到data本地变量去，接着通过 mRemote.transact函数进入到Binder驱动程序，然后Binder驱动程序唤醒正在等待Client请求的 ActivityManagerService进程，最后进入到ActivityManagerService的startService函数中。

ActivityManagerService的startService函数的处理流程如下图所示：

点击查看大图

在这个序列图中，一共有20个步骤，下面说明每一步。

Step 1. ActivityManagerService.startService

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

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public ComponentName startService(IApplicationThread caller, Intent service,
  5. String resolvedType) {
  6. // Refuse possible leaked file descriptors
  7. if (service != null && service.hasFileDescriptors() == true) {
  8. throw new IllegalArgumentException("File descriptors passed in Intent");
  9. }
  10. synchronized(this) {
  11. final int callingPid = Binder.getCallingPid();
  12. final int callingUid = Binder.getCallingUid();
  13. final long origId = Binder.clearCallingIdentity();
  14. ComponentName res = startServiceLocked(caller, service,
  15. resolvedType, callingPid, callingUid);
  16. Binder.restoreCallingIdentity(origId);
  17. return res;
  18. }
  19. }
  20. ......
  21. }

这里的参数caller、service和resolvedType分别对应ActivityManagerProxy.startService传进来的三个参数。

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

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. ComponentName startServiceLocked(IApplicationThread caller,
  5. Intent service, String resolvedType,
  6. int callingPid, int callingUid) {
  7. synchronized(this) {
  8. ......
  9. ServiceLookupResult res =
  10. retrieveServiceLocked(service, resolvedType,
  11. callingPid, callingUid);
  12. ......
  13. ServiceRecord r = res.record;
  14. ......
  15. if (!bringUpServiceLocked(r, service.getFlags(), false)) {
  16. return new ComponentName("!", "Service process is bad");
  17. }
  18. return r.name;
  19. }
  20. }
  21. ......
  22. }

函数首先通过retrieveServiceLocked来解析service这个Intent，就是解析前面我们在 AndroidManifest.xml定义的Service标签的intent-filter相关内容，然后将解析结果放在res.record中，然 后继续调用bringUpServiceLocked进一步处理。

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

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. private final boolean bringUpServiceLocked(ServiceRecord r,
  5. int intentFlags, boolean whileRestarting) {
  6. ......
  7. final String appName = r.processName;
  8. ......
  9. // Not running -- get it started, and enqueue this service record
  10. // to be executed when the app comes up.
  11. if (startProcessLocked(appName, r.appInfo, true, intentFlags,
  12. "service", r.name, false) == null) {
  13. ......
  14. return false;
  15. }
  16. if (!mPendingServices.contains(r)) {
  17. mPendingServices.add(r);
  18. }
  19. return true;
  20. }
  21. ......
  22. }

这里的appName便是我们前面在AndroidManifest.xml文件定义service标签时指定的android:process属性值了，即“.Server”。

接着调用startProcessLocked函数来创建一个新的进程，以便加载自定义的Service类。最后将这个ServiceRecord保存在成员变量mPendingServices列表中，后面会用到。

Step 4. ActivityManagerService.startProcessLocked

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

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. private final void startProcessLocked(ProcessRecord app,
  5. String hostingType, String hostingNameStr) {
  6. ......
  7. try {
  8. ......
  9. int pid = Process.start("android.app.ActivityThread",
  10. mSimpleProcessManagement ? app.processName : null, uid, uid,
  11. gids, debugFlags, null);
  12. ......
  13. if (pid == 0 || pid == MY_PID) {
  14. ......
  15. } else if (pid > 0) {
  16. app.pid = pid;
  17. app.removed = false;
  18. synchronized (mPidsSelfLocked) {
  19. this.mPidsSelfLocked.put(pid, app);
  20. ......
  21. }
  22. } else {
  23. ......
  24. }
  25. } catch (RuntimeException e) {
  26. ......
  27. }
  28. }
  29. ......
  30. }

这里调用Process.start函数创建了一个新的进程，指定新的进程执行android.app.ActivityThread类。最后将表示这个新进程的ProcessRecord保存在mPidSelfLocked列表中，后面会用到。

Step 5. Process.start

这个函数定义在frameworks/base/core/java/android/os/Process.java文件中，这个函数我们就不看了，有 兴趣的读者可以自己研究一下。在这个场景中，它就是新建一个进程，然后导入android.app.ActivityThread这个类，然后执行它的 main函数。

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

[java] view plaincopy
  1. public final class ActivityThread {
  2. ......
  3. public static final void main(String[] args) {
  4. ......
  5. Looper.prepareMainLooper();
  6. ......
  7. ActivityThread thread = new ActivityThread();
  8. thread.attach(false);
  9. ......
  10. Looper.loop();
  11. ......
  12. thread.detach();
  13. ......
  14. }
  15. }

注意，执行到这里的时候，已经是在上一步创建的新进程里面了，即这里的进程是用来启动服务的，原来的主进程已经完成了它的命令，返回了。

前面我们提到，在Android应用程序中，每一个进程对应一个ActivityThread实例，所以，这个函数会创建一个thread实例，然后调用ActivityThread.attach函数进一步处理。

Step 7. ActivityThread.attach

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

[java] view plaincopy
  1. public final class ActivityThread {
  2. ......
  3. private final void attach(boolean system) {
  4. ......
  5. if (!system) {
  6. ......
  7. IActivityManager mgr = ActivityManagerNative.getDefault();
  8. try {
  9. mgr.attachApplication(mAppThread);
  10. } catch (RemoteException ex) {
  11. }
  12. } else {
  13. ......
  14. }
  15. ......
  16. }
  17. ......
  18. }

从Step 6中，这里传进来的参数system为false。成员变量mAppThread是一个ApplicationThread实例，我们在前面已经描述过这个实例的作用，它是用来辅助ActivityThread来执行一些操作的。

调用ActivityManagerNative.getDefault函数得到ActivityManagerService的远程接口，即ActivityManagerProxy，接着调用它的attachApplication函数。

Step 8. ActivityManagerProxy.attachApplication
         这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

[java] view plaincopy
  1. class ActivityManagerProxy implements IActivityManager
  2. {
  3. ......
  4. public void attachApplication(IApplicationThread app) throws RemoteException
  5. {
  6. Parcel data = Parcel.obtain();
  7. Parcel reply = Parcel.obtain();
  8. data.writeInterfaceToken(IActivityManager.descriptor);
  9. data.writeStrongBinder(app.asBinder());
  10. mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
  11. reply.readException();
  12. data.recycle();
  13. reply.recycle();
  14. }
  15. ......
  16. }

这个函数主要是将新进程里面的IApplicationThread实例通过Binder驱动程序传递给ActivityManagerService。

Step 9. ActivityManagerService.attachApplication

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

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public final void attachApplication(IApplicationThread thread)
  5. {
  6. synchronized (this) {
  7. int callingPid = Binder.getCallingPid();
  8. final long origId = Binder.clearCallingIdentity();
  9. attachApplicationLocked(thread, callingPid);
  10. Binder.restoreCallingIdentity(origId);
  11. }
  12. }
  13. ......
  14. }

这里通过调用attachApplicationLocked函数进一步处理。

Step 10. ActivityManagerService.attachApplicationLocked

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

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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文件中：

[java] view plaincopy
  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函数中：

[java] view plaincopy
  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函数中：

[java] view plaincopy
  1. service.onCreate();

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

[java] view plaincopy
  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在形式来实现，使得这些耗时的计算能在一个独立的进程中进行，这样就能保持主进程流畅地响应界面事件，提 高用户体验。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

转载于:https://www.cnblogs.com/Free-Thinker/p/4142133.html

Android系统在新进程中启动自定义服务过程（startService）的原理分析相关推荐

  1. Android系统在新进程中启动自定义服务过程（startService）的原理分析 （下）

    Step 10. ActivityManagerService.attachApplicationLocked 这个函数定义在frameworks/base/services/java/com/and ...

  2. Android系统（117）---Activity启动过程

    Activity启动过程 ###一些基本的概念 ActivityManagerServices,简称AMS,服务端对象,负责系统中所有Activity的生命周期 ActivityThread,App的 ...

  3. 根据用户查进程_【磨叽教程】Android进阶教程之在Android系统下各进程之间的优先级关系...

    导读:本文大约2000字,预计阅读时间3分钟.本文纯属技术文,无推广. 正文     首先应用进程的生命周期并不由应用本身直接控制,而是由系统综合多种因素来确定的.Android系统有自己的一套标准, ...

  4. Android 9.0 在init.rc中启动一个服务

    现在有一个blink .bin文件,需要拷贝到/system/bin/目录下面去,然后再init.rc文件中启动该服务 一.init.rc文件中启动服务 1.在init.rc文件中启动服务 代码路径: ...

  5. Android系统刷机后第一次启动很慢的原因

    转自:Android系统刷机后第一次启动很慢的原因 - 走看看 在做Android内核开发的过程中,我们会发现,每次编译完系统源码,烧录到设备/手机中后,第一次启动都会很慢很慢,要好几分钟甚至十几分钟 ...

  6. android 自定义view xml ,Android实现在xml文件中引用自定义View的方法分析

    本文实例讲述了Android实现在xml文件中引用自定义View的方法.分享给大家供大家参考,具体如下: 在xml中引用自定义view 方法一: android:layout_width=" ...

  7. mat opencv 修改roi_OpenCV Android：在新Mat中定义并保存ROI(OpenCV Android: Define and save ROI in new Mat)...

    OpenCV Android:在新Mat中定义并保存ROI(OpenCV Android: Define and save ROI in new Mat) 我正在尝试将我的图像的一部分切割(裁剪)到另 ...

  8. android 系统（154）----OTA制作及升级过程

    OTA制作及升级过程 1.概述 1.1   文档概要 前段时间学习了AndroidRecovery模式及OTA升级过程,为加深理解和防止以后遗忘,所以写这篇文档进行一个总结和梳理,以便日后查阅回顾.文 ...

  9. 在linux中启动mysql,在linux中启动mysql服务的命令

    用reboot命令重启linux服务器之后会导致mysql服务终止,也就是mysql服务没有启动.必须要重启mysql服务,否则启动jboss时会 报有关数据库mysql方面的错误. 命令如下: 第一 ...

  10. linux命令mysql启动,在linux中启动mysql服务的命令

    用reboot命令重启linux服务器之后会导致mysql服务终止,也就是mysql服务没有启动.必须要重启mysql服务,否则启动jboss时会 报有关数据库mysql方面的错误. 命令如下: 第一 ...

最新文章

  1. AI时代的领航者，智能电话机器人对市场的影响
  2. Puppy Linux 8.0 发布，代号 BionicPup
  3. 只调用一次_JavaScript运行机制 - 调用栈
  4. linux mentohust dhcp,MentoHUST的使用教程详解
  5. 今晚解决了ActiveSync不能连接到手机的问题，电脑软件没有问题的情况
  6. 【MM模块】 Goods Receipt 收货 3
  7. 太骚了！Python模型完美切换SAS，还能这么玩。。
  8. 799元首发！小米手表Color：14天超长续航、专业运动健康管理
  9. MySQL不香吗，为啥京东放弃它拥抱Elasticsearch？
  10. 为制造业构建Teams Power App 1：Dataverse入门
  11. centos6.6安全设置
  12. UVaOJ 10328 Coin Toss
  13. CCNA中文版完整教程
  14. ISSCC 2017论文导读 Session 14: A 28nm SoC with a 1.2GHz Prediction Sparse Deep-Neural-Network Engine
  15. 目前计算机新技术应用领域,计算机的应用领域分为哪六个方面
  16. gcc/g++编译错误Assembler Error
  17. 气凝胶产业链都有？-供应银纳米粒子修饰碳球/石墨烯复合气凝胶/磷钨杂多酸修饰ZrO_2气凝胶/柠檬酸修饰纤维素气凝胶定制
  18. 推荐一款高效的处理延迟任务神器
  19. 非线性方程(组)：高维方程解法
  20. 小程序组件库ColorUI的使用，一键复制粘贴

热门文章

  1. Thinking in Java 10.8.1 闭包与回调
  2. JS常用函数（方法）
  3. jQuery CheckBoxList 全选 反选
  4. JSP之jsp内置标签
  5. 阴阳师哪些服务器可以跨系统转移,阴阳师跨系统转服方法介绍 怎么跨系统转服...
  6. checkbox未赋值时获取value是on_【漏洞分析】关于mysqlconnectorjava连接时的反序列化...
  7. javaweb——jsp(学习总结，javaweb必备技能)
  8. arraylist 线性不安全_Java面试系列(一)--集合类ArrayList
  9. ElementUI：tree鼠标浮动在某个节点背景色以及点击背景色修改
  10. Vue：数组的过滤排序显示客户端实现