android高级程序开发-app启动流程

最新推荐文章于 2023-05-23 14:58:19 发布

我是小小舒

最新推荐文章于 2023-05-23 14:58:19 发布

阅读量343

点赞数

本文链接：https://blog.csdn.net/qq_15437701/article/details/79396632

版权

Android系统启动流程分析：

之所以分析它，是为了更好的理解整个系统，也有助于我们后面的学习，更深入理解我们Android App的启动流程

一、开机流程：

开机后会加载引导程序BootLoader，它是Android系统运行的第一个程序，在操作系统运行之前运行。

BootLoader主要功能：1.检查RAM，初始化硬件参数等功能；2.拉起操作系统

二、初始化内核Kernel：

完成了内核的大部分初始化工作，启动用户空间的init进程

init进程：所有的进程都是由init进程直接或者间接fork出来的

三、init进程初始化：

加载ServiceManager服务进程：这个是一个守护进程，用于管理各种服务Server,主要用于ipc跨进程通信，提供Clinet访问Server服务的接口

fork一个Zygote进程：该进程是Android系统开启新的进程的方式，是通过fork zygote进程实现的，之所以这么做是为了实现资源共用和更快的启动速度。

四、Zygote进程初始化：

1.创建Android运行时环境AppRuntime：调用app_main.cpp的main函数中的AppRuntime的start来启动zygote进程

app_main.cpp：main()

AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
 }

2.创建Android运行时环境AppRuntime，AppRuntime继承了系统的AndroidRuntime类，start方法实际上调用的是AndroidRuntime的start方法

AndroidRuntime：start()
startVm(&mJavaVM, &env, zygote)
startReg(env)
//找到ZygoteInit的main函数
jmethodID startMeth = env->GetStaticMethodID(startClass, "main", "([Ljava/lang/String;)V");
//通过JNI调用ZygoteInit的main函数
env->CallStaticVoidMethod(startClass, startMeth, strArray);

2.1、创建虚拟机：调用startVm

2.2、初始化虚拟机：调用startReg函数用来为JavaVm注册JNI

2.3、找到ZygoteInit的main

2.4、通过JNI调用ZygoteInit的main函数(main函数是java编写的)

3.执行ZygoteInit的main函数：开始进入java层，主要是启动SystemServer进程

ZygoteInit：main()
//注册Zygote用的Socket
registerZygoteSocket(socketName);
//预加载类和资源
preload();
//启动SystemServer进程
if (startSystemServer) {
	startSystemServer(abiList, socketName);
            }
//等待客户端请求
runSelectLoop(abiList);

3.1、通过registerZygoteSocket函数来创建一个Server端的Socket，这个Socket用来等待ActivityManagerService来请求Zygote来创建新的应用程序进程

3.2、预加载类和资源

3.3、启动SystemServer进程，这样系统的关键服务也会由SystemServer进程启动起来，fork出SystemServer进程：系统里面的重要的服务都是在这个进程里面开启的，比如：ActivityManagerService、PackageManagerService、WindowManagerService等等

3.4、等待客户端AMS Socket通讯请求

五、SystemServer进程初始化：

至此，Android Framework里面两大非常重要的进程：Zygote和SystemServer进程就已经开启了

public static void main(String[] args) {
    new SystemServer().run();
}
private void run() {
    // 准备SystemServer运行环境:设置线程优先级，创建主线层Looper，ActivityThread和SystemContext
    android.os.Process.setThreadPriority();
    Looper.prepareMainLooper();
    
    // 创建systemserver上进程的ActivityThread和SystemContext
    createSystemContext();
    
    // 增加SystemServiceManager：统一管理system services的创建，启动和生命周期，多用户切换
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    
    // Start services.
    
    // 1.创建AMS
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
      
    // Start the Power Manager service
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    // Start the package manager service
    mPackageManagerService = PackageManagerService.main();
            
    
    // 2.将SystemServer进程添加到AMS中调度管理
    mActivityManagerService.setSystemProcess();
    
    // 3.将相关provider运行在systemserver进程中：SettingsProvider
    mActivityManagerService.installSystemProviders();
    
    // 
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.init(context, mActivityManagerService);
    
    // Start Window Manager 
    wm = WindowManagerService.main();
    
    // 4.直接保存wms对象，与WMS交互
    mActivityManagerService.setWindowManager(wm);
    
    // 5.通过WMS 弹出“正在启动应用”框
    // R.string.android_upgrading_starting_apps
    ActivityManagerNative.getDefault().showBootMessage();
    
    // 6. AMS作为Framework核心，做好准备就绪后就开始启动应用层，和对AMS有依赖的服务
    mActivityManagerService.systemReady(new Runnable(){
        //启动SystemUI
        startSystemUi(context);
        
        //启动WatchDog监控核心服务状态
        Watchdog.getInstance().start();
        
        //
        mmsServiceF.systemRunning();
    });


    // Loop forever.
    Looper.loop();
}

系统里面的重要的服务都是在这个进程里面开启的，比如：ActivityManagerService、PackageManagerService、WindowManagerService等等

完成后，系统服务都已经启动好了，那么下面就可以通过系统服务，启动一些应用层程序了，比如Launcher程序就是在ActivityManagerService(简称AMS)的systemReady方法里启动的，那么我们下面就来看看AMS。

六、ActivityManagerService：

简称AMS，服务端对象，负责四大组件的初始化，负责系统中所有Activity的生命周期。
通知zygote进程来fork一个新进程，来开启我们的目标App

所有的Activity的开启、暂停、关闭都需要AMS来控制，所以我们说，AMS负责系统中所有Activity的生命周期

public static final class Lifecycle extends SystemService {
        private final ActivityManagerService mService;
        public Lifecycle(Context context) {
            super(context);
            mService = new ActivityManagerService(context);
        }

        @Override
        public void onStart() {
            mService.start();
        }

        public ActivityManagerService getService() {
            return mService;
        }
    }

public ActivityManagerService(Context systemContext) {
        
　　     // 1.系统Context 和 ActivityThread （将systemserver进程作为应用进程管理）
        mContext = systemContext;
        mFactoryTest = FactoryTest.getMode();
        mSystemThread = ActivityThread.currentActivityThread();
        
        // 2.AMS工作的线程和Handler，处理显示相关的UiHandler  ---》知识点HandlerThread和Handler
        mHandlerThread = new ServiceThread(TAG,
            android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        mUiHandler = new UiHandler();
        
        // 3. 广播队列BroadcastQueue初始化：前台广播队列和后台广播队列
        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;
        
        // 4. Service 和 Provider 管理
        mServices = new ActiveServices(this);
        mProviderMap = new ProviderMap(this);
        
        // 5.系统数据存放目录：/data/system/
        File dataDir = Environment.getDataDirectory();
        File systemDir = new File(dataDir, "system");
        systemDir.mkdirs();
       
        // 电池状态信息，进程状态 和 应用权限管理
        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);    
        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
        mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
        
        // 6.多用户管理
        mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
        mUserLru.add(UserHandle.USER_OWNER);
        updateStartedUserArrayLocked();

        // 7.最近任务，Activity，Task管理
        mRecentTasks = new RecentTasks(this);
        mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
        mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);
        
        // 创建一个新线程，用于监控和定时更新系统CPU信息，30分钟更新一次CPU和电池信息
        mProcessCpuTracker.init();
        mProcessCpuThread = new Thread("CpuTracker") {}
        
        // 加入Watchdog监控起来
        Watchdog.getInstance().addMonitor(this);
        Watchdog.getInstance().addThread(mHandler);
    }

public void setSystemProcess() {
        // 将服务加入到ServiceManager中
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);//ActivityManagerService是以activity名称存放到ServiceManager守护进程中的。
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        ServiceManager.addService("meminfo", new MemBinder(this));
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        ServiceManager.addService("dbinfo", new DbBinder(this));
        
        // 设置application info LoadedApkinfo 有关 framework-res.apk
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
        
        //给SystemServer进程创建ProcessRecord，adj值，就是将SystemServer进程加入到AMS进程管理机制中，跟应用进程一致
        synchronized (this) {
            ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            synchronized (mPidsSelfLocked) {
                mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
    }

启动Home应用程序：Launcher进程

public void systemReady(final Runnable goingCallback) {
        ...
        // Start up initial activity.
        mBooting = true;
        startHomeActivityLocked(mCurrentUserId, "systemReady");
        ...
    }

本节主要介绍了Android系统从开机到启动Launcher应用程序的流程分析，对于应用程序开发人员来说，只需要了解下整个流程的主要方法，特别是上面一些重要的系统进程和服务，因为它可以让我们加深对Android系统的理解。大家可以重点关注下：ServiceManager服务进程以及SystemServer进程，还有就是AMS。

总结：

1、开机后加载引导程序bootloader：将操作系统拉起来

2、初始化内核，在系统文件中寻找init.rc文件，启动init进程：加载ServiceManager服务进程；fork出一个Zygote进程

3、Zygote进程初始化：创建Android运行时环境AppRuntime(创建虚拟机，初始化虚拟机:注册JNI，通过JNI调用Zygote的main函数)；执行Main函数，开始进入Java层(注册Zygote用的Socket:用于监听SystemServer进程中的AMS的Socket连接，以便fork出新的进程；启动SystemServer进程；通过runSelectLoop函数等待ActivityanagerService的请求)

4、SystemServer进程初始化：用于启动各种系统服务

5、Launcher启动：被SystemServer启动的AMS会执行systemReady方法，从来启动Home程序

接下来我们将重点介绍应用程序的启动流程，当然由于启动应用程序涉及到IPC进程间通信，所以我们需要先了解下Binder跨进程通信机制，然后再分析应用程序的启动流程。欢迎订阅！

我是小小舒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
android高级程序开发-app启动流程

Android系统启动流程分析：之所以分析它，是为了更好的理解整个系统，也有助于我们后面的学习，更深入理解我们Android App的启动流程一、开机流程：开机后会加载引导程序BootLoader，它是Android系统运行的第一个程序，在操作系统运行之前运行。BootLoader主要功能：1.检查RAM，初始化硬件参数等功能；2.拉起操作系统二、初始化内核Kernel：完成了内核的大部分初始化工...
复制链接

扫一扫