devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android-33源码分析: 系统启动流程

作者：很楠不爱3 | 2024-05-05 04:57:12

赞

踩

android-33
1、按下电源键进行系统启动：触发引导芯片，加载预定义代码，启动引导程序BootLoader
2、启动BootLoader引导程序：它是一个Android系统启动前运行的一个小程序，用来拉起OS并运行
3、启动linux内核：设置缓存、被保护存储器、计划列表、加载驱动、完成系统设置，设置完后会找到系统文件init.rc启动init进程

init_parse_config_file("/init.rc");
4、启动init进程：初始化并启动属性服务，启动zygote进程
Zygote进程的初始化在App_main.cpp文件中开启

  1.   // 使用运行时环境启动Zygote的初始化类.
  2.   runtime.start("com.android.internal.os.ZygoteInit", startSystemServer);
5、启动zygote进程孵化器：创建JVM，注册JNI，创建服务端的socket，启动systemServer进程
6、启动systemServer进程：启动binder线程池和systemServerManager，启动各种系统服务，如AMS、WMS等
现在从c或c++代码进入到java代码中, ZygoteInit.java初始化类

  1. public static void main(String[] argv) {
  2. ....
  3. // 孵化器fork出SystemServer类
  4. Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer)
  5. ....
  6. }
  1.     static int forkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
  2.             int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
  3.         ZygoteHooks.preFork();
  4.       
  5.         int pid = nativeForkSystemServer(
  6.                 uid, gid, gids, runtimeFlags, rlimits,
  7.                 permittedCapabilities, effectiveCapabilities);
  8.  
  9.         // Set the Java Language thread priority to the default value for new apps.
  10.         Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
  11.  
  12.         ZygoteHooks.postForkCommon();
  13.         return pid;
  14.     }
  1.     //  com.android.server.SystemServer 
  2.  
  3.     // 执行main方法
  4.     public static void main(String[] args) {
  5.         new SystemServer().run();
  6.     }
  7.  
  8.  
  9.   private void run() {
  10.         TimingsTraceAndSlog t = new TimingsTraceAndSlog();
  11.         /**
  12.          * 该进程中也会维护一个主Looper循环 并开启消息循环Looper.loop()
  13.          */
  14.         // Start services.
  15.         try {
  16.             t.traceBegin("StartServices");
  17.             // 启动引导服务
  18.             startBootstrapServices(t);
  19.             // 启动核心服务
  20.             startCoreServices(t);
  21.             // 启动其他服务-会执行mActivityManagerService.systemReady()
  22.             startOtherServices(t);
  23.  
  24.             startApexServices(t);
  25.         } catch (Throwable ex) {
  26.             Slog.e("System", "******************************************");
  27.             Slog.e("System", "************ Failure starting system services", ex);
  28.             throw ex;
  29.         } finally {
  30.             t.traceEnd(); // StartServices
  31.         }
  32.  
  33.         // Loop forever.
  34.         Looper.loop();
  35.         throw new RuntimeException("Main thread loop unexpectedly exited");
  36.     }
// 启动引导服务
DeviceIdentifiersPolicyService
UriGrantsManagerService
PowerStatsService
ActivityTaskManagerService   
ActivityManagerService
DataLoaderManagerService
PowerManagerService
ThermalManagerService
HintManagerService
RecoverySystemService
DisplayManagerService
UserManagerService
OverlayManagerService
ResourcesManagerService
....
// 启动核心服务
SystemConfigService
BatteryService
UsageStatsService
WebViewUpdateService
CachedDeviceStateService
BinderCallsStatsService
GpuService
...
// 启动其他服务
BinaryTransparencyService
DropBoxManagerService
VibratorManagerService
WindowManagerService
NetworkManagementService
NetworkWatchlistService
FontManagerService
PinnerService
LogcatManagerService
....

  1.     /**
  2.      * Ready. Set. Go!
  3.      * ActivityTaskManagerInternal是ActivityManagerService的抽象类
  4.      * 实现是ActivityTaskManagerService的LocalService，
  5.      * 所以mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady")
  6.      * 最终调用的是ActivityTaskManagerService的startHomeOnAllDisplays()方法
  7.      */
  8.     public void systemReady(final Runnable goingCallback, @NonNull TimingsTraceAndSlog t) {
  9.     ...省略
  10.  
  11.      if (bootingSystemUser) {
  12.                 t.traceBegin("startHomeOnAllDisplays");
  13.                 mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
  14.                 t.traceEnd();
  15.             }
  16.  
  17.      ...省略
  18.  
  19.     }
  20.  
ActivityTaskManagerService 中方法调用

  1.         @Override
  2.         public boolean startHomeOnAllDisplays(int userId, String reason) {
  3.             synchronized (mGlobalLock) {
  4.                 return mRootWindowContainer.startHomeOnAllDisplays(userId, reason);
  5.             }
  6.         }
RootWindowContainer 中方法调用


  1.     boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting,
  2.             boolean fromHomeKey) {
  3.         // Fallback to top focused display or default display if the displayId is invalid.
  4.         if (displayId == INVALID_DISPLAY) {
  5.             final Task rootTask = getTopDisplayFocusedRootTask();
  6.             displayId = rootTask != null ? rootTask.getDisplayId() : DEFAULT_DISPLAY;
  7.         }
  8.  
  9.         final DisplayContent display = getDisplayContent(displayId);
  10.         return display.reduceOnAllTaskDisplayAreas((taskDisplayArea, result) ->
  11.                         result | startHomeOnTaskDisplayArea(userId, reason, taskDisplayArea,
  12.                                 allowInstrumenting, fromHomeKey),
  13.                 false /* initValue */);
  14.     }
  15.  
  1.   boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
  2.             boolean allowInstrumenting, boolean fromHomeKey) {
  3.         // Fallback to top focused display area if the provided one is invalid.
  4.         if (taskDisplayArea == null) {
  5.             final Task rootTask = getTopDisplayFocusedRootTask();
  6.             taskDisplayArea = rootTask != null ? rootTask.getDisplayArea()
  7.                     : getDefaultTaskDisplayArea();
  8.         }
  9.  
  10.         Intent homeIntent = null;
  11.         ActivityInfo aInfo = null;
  12.         if (taskDisplayArea == getDefaultTaskDisplayArea()) {
  13.             // 配置意图同时设置CATEGORY_HOME
  14.             homeIntent = mService.getHomeIntent();
  15.             aInfo = resolveHomeActivity(userId, homeIntent);
  16.         } else if (shouldPlaceSecondaryHomeOnDisplayArea(taskDisplayArea)) {
  17.             Pair<ActivityInfo, Intent> info = resolveSecondaryHomeActivity(userId, taskDisplayArea);
  18.             aInfo = info.first;
  19.             homeIntent = info.second;
  20.         }
  21.         if (aInfo == null || homeIntent == null) {
  22.             return false;
  23.         }
  24.         // 检查能否正常显示
  25.         if (!canStartHomeOnDisplayArea(aInfo, taskDisplayArea, allowInstrumenting)) {
  26.             return false;
  27.         }
  28.  
  29.         // Updates the home component of the intent.
  30.         homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
  31.         homeIntent.setFlags(homeIntent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
  32.         // Updates the extra information of the intent.
  33.         if (fromHomeKey) {
  34.             homeIntent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, true);
  35.             if (mWindowManager.getRecentsAnimationController() != null) {
  36.                 mWindowManager.getRecentsAnimationController().cancelAnimationForHomeStart();
  37.             }
  38.         }
  39.         homeIntent.putExtra(WindowManagerPolicy.EXTRA_START_REASON, reason);
  40.  
  41.         // Update the reason for ANR debugging to verify if the user activity is the one that
  42.         // actually launched.
  43.         final String myReason = reason + ":" + userId + ":" + UserHandle.getUserId(
  44.                 aInfo.applicationInfo.uid) + ":" + taskDisplayArea.getDisplayId();
  45.         mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
  46.                 taskDisplayArea);
  47.         return true;
  48.     }
ActivityStartController 中方法调用
  1.     void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason,
  2.             TaskDisplayArea taskDisplayArea) {
  3.         // ...省略
  4.         // 执行ActivityStarter中的execute
  5.         mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
  6.                 .setOutActivity(tmpOutRecord)
  7.                 .setCallingUid(0)
  8.                 .setActivityInfo(aInfo)
  9.                 .setActivityOptions(options.toBundle())
  10.                 .execute();
  11.         mLastHomeActivityStartRecord = tmpOutRecord[0];
  12.         if (rootHomeTask.mInResumeTopActivity) {
  13.             // If we are in resume section already, home activity will be initialized, but not
  14.             // resumed (to avoid recursive resume) and will stay that way until something pokes it
  15.             // again. We need to schedule another resume.
  16.             mSupervisor.scheduleResumeTopActivities();
  17.         }
  18.     }
  1. ActivityStarter // 负责界面启动检查
  2. .execute()
  3. .executeRequest(mRequest)
  4. .startActivityUnchecked(final ActivityRecord r....)
  5. .startActivityInner(final ActivityRecord r....)
  6. mRootWindowContainer.resumeFocusedTasksTopActivities(mTargetRootTask....)
  7.  
  8. RootWindowContainer
  9. .resumeFocusedTasksTopActivities(mTargetRootTask, mStartActivity, mOptions, mTransientLaunch)
  10. targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions, deferPause)
  11.  
  12. Task
  13. .resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause)
  14. .resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause)
  15. topFragment.resumeTopActivity(prev, options, deferPause)
  16.  
  17. TaskFragment
  18. .resumeTopActivity(ActivityRecord prev, ActivityOptions options, boolean deferPause)
  19. mTaskSupervisor.startSpecificActivity(next, true, true)
  20.  
  21. ActivityTaskSupervisor // 负责所有Activity栈的管理
  22. .startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig)
  23. .realStartActivityLocked(r, wpc, andResume, checkConfig)
  24. clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent)....) // 解释LaunchActivityItem由来
  25. mService.getLifecycleManager().scheduleTransaction(clientTransaction)
  26.  
  27. ClientLifecycleManager // 生命周期的管理调用
  28. .scheduleTransaction(ClientTransaction transaction)
  29. transaction.schedule();
  30.  
  31. ClientTransaction  // 客服端事务调度
  32. .schedule()
  33. IApplicationThread=mClient.scheduleTransaction(this)
  34.  
  35. ActivityThread 内部类 ApplicationThread // ApplicationThread 实现IApplicationThread
  36. .scheduleTransaction(ClientTransaction transaction)
  37. ActivityThread.this.scheduleTransaction(transaction)
  38.  
  39. ClientTransactionHandler // ActivityThread的父类 主要管理消息发送与执行
  40. .scheduleTransaction(ClientTransaction transaction)
  41. transaction.preExecute(this);
  42. sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
  43.  
  44. ActivityThread.mH // mH是ActivityThread内部Handler
  45. TransactionExecutor=mTransactionExecutor.execute(transaction)
  46.  
  47. TransactionExecutor // 主要作用是执行ClientTransaction
  48. .execute(ClientTransaction transaction)
  49. .executeLifecycleState(ClientTransaction transaction)
  50. lifecycleItem.execute(mTransactionHandler, token, mPendingActions)
  51.  
  52. LaunchActivityItem // 继承自ClientTransactionItem，而ClientTransactionItem实现BaseClientRequest  // ResumeActivityItem
  53. .execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions)
  54. ClientTransactionHandler=client.handleLaunchActivity(r, pendingActions, null /* customIntent */)
  55.  
  56. ActivityThread ex ClientTransactionHandler // 管理应用程序进程中主线程的执行
  57. .handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent)
  58. .performLaunchActivity(r, customIntent)
  59. Instrumentation=mInstrumentation.callActivityOnCreate(activity....)
  60.  
  61. Instrumentation
  62. .callActivityOnCreate(activity....)
  63. activity.performCreate(icicle)
  64.  
  65. Activity
  66. .performCreate(Bundle icicle)
  67. .performCreate(Bundle icicle, PersistableBundle persistentState)
  68. .onCreate(icicle....）
  1. 应用进程的创建：
  2. ActivityTaskSupervisor
  3. mService.startProcessAsync(r, knownToBeDead...)
  4.  
  5. ActivityTaskManagerService
  6. .startProcessAsync(r, knownToBeDead...)
  7. Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess...)
  8. ActivityManagerInternal抽象类实现ActivityManagerService.LocalService
  9.  
  10. ActivityManagerService
  11. .startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,boolean isTop, String hostingType, ComponentName hostingName)
  12. .tartProcessLocked(processName, info.....)
  13. .tartProcessLocked(processName, info.....) // 重载
  14. mProcessList.startProcessLocked(processName, info, knownToBeDead...)
  15.  
  16. ProcessList
  17. .startProcessLocked(processName, info, knownToBeDead...)
  18. .startProcessLocked(processName, info, knownToBeDead...) // 重载
  19. final Process.ProcessStartResult startResult = startProcess(hostingRecord,entryPoint, app,....)
  20. startResult = appZygote.getProcess().start(entryPoint,app.processName, uid, uid, gids.....)
  21. AppZygote.getProcess返回ChildZygoteProcess继承ZygoteProcess
  22.  
  23. ZygoteProcess
  24. .start(final String processClass,final String niceName,int uid, int gid, @Nullable int[] gids....)
  25. .startViaZygote(final String processClass,final String niceName,int uid, int gid, @Nullable int[] gids....)
  26. .zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),  zygotePolicyFlags, argsForZygote)
  27. .attemptZygoteSendArgsAndGetResult(zygoteState, msgStr)
  28. zygoteWriter.write(msgStr);  // 把应用进程参数写入zygote进程 比如 processClass ="android.app.ActivityThread"
  29. zygoteWriter.flush(); // 进入Zygote进程，处于阻塞状态
  30. // fork采用copy-on-write机制 
  31.  
  32. ZygoteInit
  33. .main(String[] argv)
  34. zygoteServer.runSelectLoop(abiList)->caller.run()
  35.  
  36. ZygoteServer
  37. .runSelectLoop(abiList)
  38. final Runnable command = connection.processCommand(this, multipleForksOK)
  39.  
  40. ZygoteConnection
  41. .processCommand(ZygoteServer zygoteServer, boolean multipleOK)
  42. handleChildProc(parsedArgs, childPipeFd,parsedArgs.mStartChildZygote)
  43. ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,parsedArgs.mDisabledCompatChanges,parsedArgs.mRemainingArgs, null /* classLoader */)
  44.  
  45. ZygoteInit
  46. .zygoteInit(parsedArgs.mTargetSdkVersion,parsedArgs.mDisabledCompatChanges,parsedArgs.mRemainingArgs, null /* classLoader */)
  47. RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,classLoader)
  48.  
  49. RuntimeInit
  50. .applicationInit(int targetSdkVersion, long[] disabledCompatChanges,String[] argv, ClassLoader classLoader)
  51. .indStaticMain(String className, String[] argv,ClassLoader classLoader)
  52. new MethodAndArgsCaller(m, argv).run({mMethod.invoke(null, new Object[] { mArgs })})
  53.  
  54. ActivityThread.main() 执行完成
 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/537305
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号