精华内容
下载资源
问答
  • Android系统启动流程

    2017-05-15 14:21:46
    Android系统启动流程

    1.     启动电源及其系统启动:当电源按下时引导芯片代码开始从预定义的地方(固化在ROM)开始执行,加载引导程序Bootloader到RAM,然后执行

    2.     引导程序Bootloader

    引导程序Bootloader在android操作系统开始执行钱的一个小程序,他的主要作用是把系统OS拉起来并运行

    3.     Linux内核启动

    内核启动时、设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置,它首先在系统文件中寻找init.rc文件,并启动init进程。

    4.     init进程

    初始化和启动属性服务。

    5.     zygote进程启动创建JavaMV并为JavaMV注册JNI。创建服务端Socket,启动systemserver进程

    6.     Systemserver进程启动

    启动Binder线程池和SystemServiceManager,并启动各种系统服务。

    7.     Launcher启动

    被Systemserver进程启动的ActivityManagerService会启动Launcher,Launcher启动后会将安装应用的快捷图标显示在界面上。

     

    结合以上的流程,给出android系统启动流程图:

     

    展开全文
  • Android 系统启动流程

    2020-02-27 07:30:38
    Android系统启动总体流程 启动电源,加载引导程序BootLoader到RAM中 BootLoader把系统OS拉起来并运行 Linux内核启动,首先在系统文件中寻找init.rc文件,并启动init进程 init进程启动,主要用来初始化、启动属性...

    Android系统启动总体流程

    1. 启动电源,加载引导程序BootLoader到RAM中
    2. BootLoader把系统OS拉起来并运行
    3. Linux内核启动,首先在系统文件中寻找init.rc文件,并启动init进程
    4. init进程启动,主要用来初始化、启动属性服务和Zygote进程
    5. Zygote进程启动,创建Java虚拟机并为Java虚拟机注册JNI方法,创建服务端Socket,启动SystemServer进程
    6. SystemServer进程启动,启动Binder线程池和SystemServerManager,并且启动各种系统服务
    7. 被SystemServer进程启动的AMS会启动Launcher,Launcher将已安装应用的快捷方式显示到界面上

    Android系统启动流程图

    在这里插入图片描述

    详细分析

    详见
    Android init进程启动过程
    Android Zygote进程启动过程
    Android SystemServer进程启动过程
    Android Launcher启动流程

    展开全文
  • android系统启动流程

    千次阅读 2015-09-23 01:52:09
    Android系统启动流程 一、init进程启动 1.按下Power键,引导芯片代码从预定义的地方(固化在ROM(read only memory)的预定义位置) 开始加载引导程序 BootLoader到RAM(random access memory),然后执行引导程序...

    Android系统的启动流程

    https://ansen-1252623423.cos.ap-guangzhou.myqcloud.com/22_system_boot.png

    • BootLoader

    按下Power键,引导芯片代码从预定义的地方(固化在ROM(read only memory)的预定义位置) 开始加载引导程序 BootLoader到RAM(random access memory),然后执行引导程序(bootloader)

    引导程序BootLoader是Android系统运行前的第一个程序,它的主要作用是把系统OS拉起来并运行.
    BootLoader是针对特定的主板与芯片的,设备制造商可以使用常见的引导程序如redboot、uboot、qi bootloader
    或者开发自己的引导程序,它不是Android操作系统的一部分.
    
    • Linux kernel

    Linux kernel启动. kernel(内核)启动时会设置缓存、被保护存储器、计划列表、加载驱动.然后在系统文件中寻找init文件,并启动init进程

    • init进程

    init 进程是Linux用户空间中第一个进程,进程号为1,是所有进程的父进程.

    init进程启动. init进程主要来创建和挂载启动所需的文件目录,启动属性服务(类似于windows的注册表),启动Zygote进程

    init进程代码(system/core/init目录) init.cpp
    system/core/init/inti.cpp   代码如下:
        int main(int argc, char** argv) {
            ...
            // 创建并挂载目录,如/sys、/dev、/proc
            ...
            if (bootscript.empty()) {
                parser.ParseConfig("/init.rc");         // 解析init.rc配置文件
                parser.set_is_system_etc_init_loaded(
                        parser.ParseConfig("/system/etc/init"));
                parser.set_is_vendor_etc_init_loaded(
                        parser.ParseConfig("/vendor/etc/init"));
                parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
            }   // .rc文件是Android使用的初始化脚本文件
            ...
        }
    inti.cpp 的main函数首先初始化属性,创建文件和挂载文件,分析和运行所有的init.rc文件,创建并启动zygote孵化进程.
    
    • Zygote进程启动

    Zygote(孵化器)进程的建立是真正的Android运行空间,Zygote孵化进程首先会创建虚拟机,之后通过JNI加载 Android Framework 中的 class、res到内存,创建服务端socket,并轮询监听socket,等待AMS的请求来创建APP进程,它通过fock(复制进程)的形式来创建DVM/ART,systemservice,app进程.

    Zygote通过调用forkSystemServer(),启动SystemServer进程.

    //android P: frameworks/base/core/java/com/android/internal/os/ZygoteInit.java 
    private static Runnable forkSystemServer(String abiList, String socketName,
                ZygoteServer zygoteServer) {
            // ... ...
            // 创建args数组,保存启动SystemServer的启动参数
            /* Hardcoded command line to start the system server */
            String args[] = {
                "--setuid=1000",
                "--setgid=1000",
                "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1024,1032,1065,3001,3002,3003,3006,3007,3009,3010",
                "--capabilities=" + capabilities + "," + capabilities,
                "--nice-name=system_server",
                "--runtime-args",
                "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
                "com.android.server.SystemServer",
            };
            ZygoteConnection.Arguments parsedArgs = null;
    
            int pid;
    
            try {
                parsedArgs = new ZygoteConnection.Arguments(args);
                ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
                ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
    
                boolean profileSystemServer = SystemProperties.getBoolean(
                        "dalvik.vm.profilesystemserver", false);
                if (profileSystemServer) {
                    parsedArgs.runtimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;
                }
                //创建SystemServer进程,
                /* Request to fork the system server process */
                pid = Zygote.forkSystemServer(
                        parsedArgs.uid, parsedArgs.gid,
                        parsedArgs.gids,
                        parsedArgs.runtimeFlags,
                        null,
                        parsedArgs.permittedCapabilities,
                        parsedArgs.effectiveCapabilities);
            } catch (IllegalArgumentException ex) {
                throw new RuntimeException(ex);
            }
            /* For child process */
            if (pid == 0) {     //当前运行在SystemServer进程中
                if (hasSecondZygote(abiList)) {
                    waitForSecondaryZygote(socketName);
                }
                zygoteServer.closeServerSocket();   //关闭Zygote进程创建的socket
                return handleSystemServerProcess(parsedArgs);
            }
            return null;
        }
    
    • SystemServer进程

    SystemService会启动Binder线程池 创建SystemServiceManage对系统服务的创建启动和生命周期进程管理,并启动各种java层系统服务,接着会调用WMS,AMS等服务的systemReady()完成启动.

        private void run() {
            try {
                // ... ...
                // Prepare the main looper thread (this thread).
                android.os.Process.setThreadPriority(
                    android.os.Process.THREAD_PRIORITY_FOREGROUND);
                android.os.Process.setCanSelfBackground(false);
                Looper.prepareMainLooper();
                Looper.getMainLooper().setSlowLogThresholdMs(
                        SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
    
                // Initialize native services.
                System.loadLibrary("android_servers");
    
                // Check whether we failed to shut down last time we tried.
                // This call may not return.
                performPendingShutdown();
    
                // Initialize the system context.
                createSystemContext();
                // 创建SystemServiceManager 对系统服务进行创建启动和生命周期管理.
                // Create the system service manager.
                mSystemServiceManager = new SystemServiceManager(mSystemContext);
                mSystemServiceManager.setStartInfo(mRuntimeRestart,
                        mRuntimeStartElapsedTime, mRuntimeStartUptime);
                LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
                // Prepare the thread pool for init tasks that can be parallelized
                SystemServerInitThreadPool.get();
            } finally {
                traceEnd();  // InitBeforeStartServices
            }
    
            // Start services.
            try {
                traceBeginAndSlog("StartServices");
                // 启动引导服务
                startBootstrapServices();
                // 启动核心服务 (DropBoxManagerService,BatteryService,UsageService,WebViewUpdateService)
                startCoreServices();
                // 启动其他服务,在该方法中还会回调WMS,AMS,PMS的systemReady方法通知系统服务完成启动
                startOtherServices();
                SystemServerInitThreadPool.shutdown();
            } catch (Throwable ex) {
                Slog.e("System", "******************************************");
                Slog.e("System", "************ Failure starting system services", ex);
                throw ex;
            } finally {
                traceEnd();
            }
            // ... ...
        }
    
    • Launcher启动

    在ActivityManagerService的systemReady方法中调用startHomeActivityLocked来启动Action为Intent.ACTION_MAIN Category为Intent.CATEGORY_HOME的应用,也就是Launcher所配置的标签,启动Launcher 将已安装应用的快捷图标显示到界面上

    Android P: frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java 
    public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
            traceLog.traceBegin("PhaseActivityManagerReady");
            // ... ...
            synchronized (this) {
                // Only start up encryption-aware persistent apps; once user is
                // unlocked we'll come back around and start unaware apps
                startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
    
                // Start up initial activity.
                mBooting = true;
                // Enable home activity for system user, so that the system can always boot. We don't
                // do this when the system user is not setup since the setup wizard should be the one
                // to handle home activity in this case.
                if (UserManager.isSplitSystemUser() &&
                        Settings.Secure.getInt(mContext.getContentResolver(),
                             Settings.Secure.USER_SETUP_COMPLETE, 0) != 0) {
                    ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
                    try {
                        AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
                                PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,
                                UserHandle.USER_SYSTEM);
                    } catch (RemoteException e) {
                        throw e.rethrowAsRuntimeException();
                    }
                }
                // 启动桌面Activity
                startHomeActivityLocked(currentUserId, "systemReady");
                // ... ...
            }
        }
        boolean startHomeActivityLocked(int userId, String reason) {
            if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
                    && mTopAction == null) {
                // We are running in factory test mode, but unable to find
                // the factory test app, so just sit around displaying the
                // error message and don't try to start anything.
                return false;
            }
            Intent intent = getHomeIntent();
            ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
            if (aInfo != null) {
                intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
                // Don't do this if the home app is currently being
                // instrumented.
                aInfo = new ActivityInfo(aInfo);
                aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
                ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                        aInfo.applicationInfo.uid, true);
                if (app == null || app.instr == null) {
                    intent.setFlags(intent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
                    final int resolvedUserId = UserHandle.getUserId(aInfo.applicationInfo.uid);
                    // For ANR debugging to verify if the user activity is the one that actually
                    // launched.
                    final String myReason = reason + ":" + userId + ":" + resolvedUserId;
                    mActivityStartController.startHomeActivity(intent, aInfo, myReason);
                }
            } else {
                Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
            }
            return true;
        }
        Intent getHomeIntent() {
            Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
            intent.setComponent(mTopComponent);
            intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
            if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
                intent.addCategory(Intent.CATEGORY_HOME);
            }
            return intent;
        }
        
    
    展开全文
  • 此前的文章我们学习了init进程、Zygote进程和SyetemServer进程的启动过程,这一篇文章我们就来学习Android系统启动流程的最后一步:Launcher的启动流程,并结合本系列的前三篇文章的内容来讲解Android系统启动流程。...

    相关文章
    Android系统架构与系统源码目录
    Android系统启动流程(一)解析init进程启动过程
    Android系统启动流程(二)解析Zygote进程启动过程
    Android系统启动流程(三)解析SyetemServer进程启动过程

    前言

    此前的文章我们学习了init进程、Zygote进程和SyetemServer进程的启动过程,这一篇文章我们就来学习Android系统启动流程的最后一步:Launcher的启动流程,并结合本系列的前三篇文章的内容来讲解Android系统启动流程。建议读这篇文章前要通读本系列的前三篇文章,否则你可能不会理解我在讲什么。

    1.Launcher概述

    Android系统启动的最后一步是启动一个Home应用程序,这个应用程序用来显示系统中已经安装的应用程序,这个Home应用程序就叫做Launcher。应用程序Launcher在启动过程中会请求PackageManagerService返回系统中已经安装的应用程序的信息,并将这些信息封装成一个快捷图标列表显示在系统屏幕上,这样用户可以通过点击这些快捷图标来启动相应的应用程序。

    2.Launcher启动流程

    SyetemServer进程在启动的过程中会启动PackageManagerService,PackageManagerService启动后会将系统中的应用程序安装完成。在此前已经启动的ActivityManagerService会将Launcher启动起来。
    启动Launcher的入口为ActivityManagerService的systemReady函数,如下所示。
    frameworks/base/services/java/com/android/server/SystemServer.java

     private void startOtherServices() {
     ...
      mActivityManagerService.systemReady(new Runnable() {
                @Override
                public void run() {
                    Slog.i(TAG, "Making services ready");
                    mSystemServiceManager.startBootPhase(
                            SystemService.PHASE_ACTIVITY_MANAGER_READY);
    
    ...
    }
    ...
    }

    在startOtherServices函数中,会调用ActivityManagerService的systemReady函数:
    frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

    public void systemReady(final Runnable goingCallback) {
    ...
    synchronized (this) {
               ...
                mStackSupervisor.resumeFocusedStackTopActivityLocked();
                mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);
            }
        }

    systemReady函数中调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked函数:
    frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

    boolean resumeFocusedStackTopActivityLocked(
                ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
            if (targetStack != null && isFocusedStack(targetStack)) {
                return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//1
            }
            final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
            if (r == null || r.state != RESUMED) {
                mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
            }
            return false;
        }

    在注释1处会调用ActivityStack的resumeTopActivityUncheckedLocked函数,ActivityStack对象是用来描述Activity堆栈的,resumeTopActivityUncheckedLocked函数如下所示。
    frameworks/base/services/core/java/com/android/server/am/ActivityStack.java

     boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
            if (mStackSupervisor.inResumeTopActivity) {
                // Don't even start recursing.
                return false;
            }
            boolean result = false;
            try {
                // Protect against recursion.
                mStackSupervisor.inResumeTopActivity = true;
                if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
                    mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
                    mService.updateSleepIfNeededLocked();
                }
                result = resumeTopActivityInnerLocked(prev, options);//1
            } finally {
                mStackSupervisor.inResumeTopActivity = false;
            }
           return result;
        }

    注释1调用了resumeTopActivityInnerLocked函数:

     private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
       ...
       return isOnHomeDisplay() &&
                            mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "prevFinished");
       ...                 
    }

    resumeTopActivityInnerLocked函数的代码很长,我们截取我们要分析的关键的一句:调用ActivityStackSupervisor的resumeHomeStackTask函数,代码如下所示。
    frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

    boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev, String reason) {
        ...
        if (r != null && !r.finishing) {
            mService.setFocusedActivityLocked(r, myReason);
            return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null);
        }
        return mService.startHomeActivityLocked(mCurrentUser, myReason);//1
    }

    在注释1处调用了ActivityManagerService的startHomeActivityLocked函数,如下所示。
    frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

       boolean startHomeActivityLocked(int userId, String reason) {
            if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
                    && mTopAction == null) {//1
                return false;
            }
            Intent intent = getHomeIntent();//2
            ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
            if (aInfo != null) {
                intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
                aInfo = new ActivityInfo(aInfo);
                aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
                ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                        aInfo.applicationInfo.uid, true);
                if (app == null || app.instrumentationClass == null) {//3
                    intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
                    mActivityStarter.startHomeActivityLocked(intent, aInfo, reason);//4
                }
            } else {
                Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
            }
    
            return true;
        }

    注释1处的mFactoryTest代表系统的运行模式,系统的运行模式分为三种,分别是非工厂模式、低级工厂模式和高级工厂模式,mTopAction则用来描述第一个被启动Activity组件的Action,它的值为Intent.ACTION_MAIN。因此注释1的代码意思就是mFactoryTest为FactoryTest.FACTORY_TEST_LOW_LEVEL(低级工厂模式)并且mTopAction=null时,直接返回false。注释2处的getHomeIntent函数如下所示。

    Intent getHomeIntent() {
        Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
        intent.setComponent(mTopComponent);
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
            intent.addCategory(Intent.CATEGORY_HOME);
        }
        return intent;
    }

    getHomeIntent函数中创建了Intent,并将mTopAction和mTopData传入。mTopAction的值为Intent.ACTION_MAIN,并且如果系统运行模式不是低级工厂模式则将intent的Category设置为Intent.CATEGORY_HOME。我们再回到ActivityManagerService的startHomeActivityLocked函数,假设系统的运行模式不是低级工厂模式,在注释3处判断符合Action为Intent.ACTION_MAIN,Category为Intent.CATEGORY_HOME的应用程序是否已经启动,如果没启动则调用注释4的方法启动该应用程序。
    这个被启动的应用程序就是Launcher,因为Launcher的Manifest文件中的intent-filter标签匹配了Action为Intent.ACTION_MAIN,Category为Intent.CATEGORY_HOME。Launcher的Manifest文件如下所示。
    packages/apps/Launcher3/AndroidManifest.xml

    <manifest
        xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.android.launcher3">
        <uses-sdk android:targetSdkVersion="23" android:minSdkVersion="16"/>
     ...
     <application
            ...
            <activity
                android:name="com.android.launcher3.Launcher"
                android:launchMode="singleTask"
                android:clearTaskOnLaunch="true"
                android:stateNotNeeded="true"
                android:theme="@style/Theme"
                android:windowSoftInputMode="adjustPan"
                android:screenOrientation="nosensor"
                android:configChanges="keyboard|keyboardHidden|navigation"
                android:resumeWhilePausing="true"
                android:taskAffinity=""
                android:enabled="true">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
                    <category android:name="android.intent.category.HOME" />
                    <category android:name="android.intent.category.DEFAULT" />
                    <category android:name="android.intent.category.MONKEY"/>
                </intent-filter>
            </activity>
    ...
      </application> 
    </manifest>         

    这样,应用程序Launcher就会被启动起来,并执行它的onCreate函数。

    3.Launcher中应用图标显示流程

    Launcher的onCreate函数如下所示。
    packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

          @Override
        protected void onCreate(Bundle savedInstanceState) {
           ...
            LauncherAppState app = LauncherAppState.getInstance();//1
            mDeviceProfile = getResources().getConfiguration().orientation
                    == Configuration.ORIENTATION_LANDSCAPE ?
                    app.getInvariantDeviceProfile().landscapeProfile
                    : app.getInvariantDeviceProfile().portraitProfile;
    
            mSharedPrefs = Utilities.getPrefs(this);
            mIsSafeModeEnabled = getPackageManager().isSafeMode();
            mModel = app.setLauncher(this);//2
            ....
            if (!mRestoring) {
                if (DISABLE_SYNCHRONOUS_BINDING_CURRENT_PAGE) {
                    mModel.startLoader(PagedView.INVALID_RESTORE_PAGE);//2
                } else {
                    mModel.startLoader(mWorkspace.getRestorePage());
                }
            }
    ...
        }

    注释1处获取LauncherAppState的实例并在注释2处调用它的setLauncher函数并将Launcher对象传入,LauncherAppState的setLauncher函数如下所示。
    packages/apps/Launcher3/src/com/android/launcher3/LauncherAppState.java

       LauncherModel setLauncher(Launcher launcher) {
            getLauncherProvider().setLauncherProviderChangeListener(launcher);
            mModel.initialize(launcher);//1
            mAccessibilityDelegate = ((launcher != null) && Utilities.ATLEAST_LOLLIPOP) ?
                new LauncherAccessibilityDelegate(launcher) : null;
            return mModel;
        }

    注释1处会调用LauncherModel的initialize函数:

    public void initialize(Callbacks callbacks) {
        synchronized (mLock) {
            unbindItemInfosAndClearQueuedBindRunnables();
            mCallbacks = new WeakReference<Callbacks>(callbacks);
        }
    }

    在initialize函数中会将Callbacks,也就是传入的Launcher 封装成一个弱引用对象。因此我们得知mCallbacks变量指的就是封装成弱引用对象的Launcher,这个mCallbacks后文会用到它。
    再回到Launcher的onCreate函数,在注释2处调用了LauncherModel的startLoader函数:
    packages/apps/Launcher3/src/com/android/launcher3/LauncherModel.java

    ...
     @Thunk static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");//1
        static {
            sWorkerThread.start();
        }
        @Thunk static final Handler sWorker = new Handler(sWorkerThread.getLooper());//2
    ...
       public void startLoader(int synchronousBindPage, int loadFlags) {s
            InstallShortcutReceiver.enableInstallQueue();
            synchronized (mLock) {
                synchronized (mDeferredBindRunnables) {
                    mDeferredBindRunnables.clear();
                }
                if (mCallbacks != null && mCallbacks.get() != null) {
                    stopLoaderLocked();
                    mLoaderTask = new LoaderTask(mApp.getContext(), loadFlags);//3
                    if (synchronousBindPage != PagedView.INVALID_RESTORE_PAGE
                            && mAllAppsLoaded && mWorkspaceLoaded && !mIsLoaderTaskRunning) {
                        mLoaderTask.runBindSynchronousPage(synchronousBindPage);
                    } else {
                        sWorkerThread.setPriority(Thread.NORM_PRIORITY);
                        sWorker.post(mLoaderTask);//4
                    }
                }
            }
        }

    注释1处创建了具有消息循环的线程HandlerThread对象。注释2处创建了Handler,并且传入HandlerThread的Looper。Hander的作用就是向HandlerThread发送消息。在注释3处创建LoaderTask,在注释4处将LoaderTask作为消息发送给HandlerThread 。
    LoaderTask类实现了Runnable接口,当LoaderTask所描述的消息被处理时则会调用它的run函数,代码如下所示

     private class LoaderTask implements Runnable {
     ...
            public void run() {
                synchronized (mLock) {
                    if (mStopped) {
                        return;
                    }
                    mIsLoaderTaskRunning = true;
                }
                keep_running: {
                    if (DEBUG_LOADERS) Log.d(TAG, "step 1: loading workspace");
                    loadAndBindWorkspace();//1
                    if (mStopped) {
                        break keep_running;
                    }
                    waitForIdle();
                    if (DEBUG_LOADERS) Log.d(TAG, "step 2: loading all apps");
                    loadAndBindAllApps();//2
                }
                mContext = null;
                synchronized (mLock) {
                    if (mLoaderTask == this) {
                        mLoaderTask = null;
                    }
                    mIsLoaderTaskRunning = false;
                    mHasLoaderCompletedOnce = true;
                }
            }
       ...     
      }      

    Launcher是用工作区的形式来显示系统安装的应用程序的快捷图标,每一个工作区都是来描述一个抽象桌面的,它由n个屏幕组成,每个屏幕又分n个单元格,每个单元格用来显示一个应用程序的快捷图标。注释1处调用loadAndBindWorkspace函数用来加载工作区信息,注释2处的loadAndBindAllApps函数是用来加载系统已经安装的应用程序信息,loadAndBindAllApps函数代码如下所示。

    private void loadAndBindAllApps() {
        if (DEBUG_LOADERS) {
            Log.d(TAG, "loadAndBindAllApps mAllAppsLoaded=" + mAllAppsLoaded);
        }
        if (!mAllAppsLoaded) {
            loadAllApps();//1
            synchronized (LoaderTask.this) {
                if (mStopped) {
                    return;
                }
            }
            updateIconCache();
            synchronized (LoaderTask.this) {
                if (mStopped) {
                    return;
                }
                mAllAppsLoaded = true;
            }
        } else {
            onlyBindAllApps();
        }
    }

    如果系统没有加载已经安装的应用程序信息,则会调用注释1处的loadAllApps函数:

      private void loadAllApps() {
    ...
            mHandler.post(new Runnable() {
                public void run() {
                    final long bindTime = SystemClock.uptimeMillis();
                    final Callbacks callbacks = tryGetCallbacks(oldCallbacks);
                    if (callbacks != null) {
                        callbacks.bindAllApplications(added);//1
                        if (DEBUG_LOADERS) {
                            Log.d(TAG, "bound " + added.size() + " apps in "
                                    + (SystemClock.uptimeMillis() - bindTime) + "ms");
                        }
                    } else {
                        Log.i(TAG, "not binding apps: no Launcher activity");
                    }
                }
            });
           ...
        }

    在注释1处会调用callbacks的bindAllApplications函数,在前面我们得知这个callbacks实际是指向Launcher的,因此我们来查看Launcher的bindAllApplications函数,代码如下所示。
    packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

    public void bindAllApplications(final ArrayList<AppInfo> apps) {
        if (waitUntilResume(mBindAllApplicationsRunnable, true)) {
            mTmpAppsList = apps;
            return;
        }
        if (mAppsView != null) {
            mAppsView.setApps(apps);//1
        }
        if (mLauncherCallbacks != null) {
            mLauncherCallbacks.bindAllApplications(apps);
        }
    }

    在注释1处会调用AllAppsContainerView的setApps函数,并将包含应用信息的列表apps传进去,AllAppsContainerView的setApps函数如下所示。
    packages/apps/Launcher3/src/com/android/launcher3/allapps/AllAppsContainerView.java

      public void setApps(List<AppInfo> apps) {
            mApps.setApps(apps);
        }

    包含应用信息的列表apps已经传给了AllAppsContainerView,查看AllAppsContainerView的onFinishInflate函数:

     @Override
        protected void onFinishInflate() {
            super.onFinishInflate();
    ...
            // Load the all apps recycler view
            mAppsRecyclerView = (AllAppsRecyclerView) findViewById(R.id.apps_list_view);//1
            mAppsRecyclerView.setApps(mApps);//2
            mAppsRecyclerView.setLayoutManager(mLayoutManager);
            mAppsRecyclerView.setAdapter(mAdapter);//3
            mAppsRecyclerView.setHasFixedSize(true);
            mAppsRecyclerView.addOnScrollListener(mElevationController);
            mAppsRecyclerView.setElevationController(mElevationController);
    ...
        }

    onFinishInflate函数在加载完xml文件时就会调用,在注释1处得到AllAppsRecyclerView用来显示App列表,并在注释2处将apps的信息列表传进去,并在注释3处为AllAppsRecyclerView设置Adapter。这样应用程序快捷图标的列表就会显示在屏幕上。
    到这里Launcher启动流程就讲到这,接下来讲Android系统启动流程。

    4.Android系统启动流程

    那么结合本篇以及本系列的前三篇文章,我们就可以得出Android系统启动流程,如下所示。
    1.启动电源以及系统启动
    当电源按下时引导芯片代码开始从预定义的地方(固化在ROM)开始执行。加载引导程序Bootloader到RAM,然后执行。
    2.引导程序BootLoader
    引导程序BootLoader是在Android操作系统开始运行前的一个小程序,它的主要作用是把系统OS拉起来并运行。
    3.Linux内核启动
    内核启动时,设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置,它首先在系统文件中寻找init.rc文件,并启动init进程。
    4.init进程启动
    初始化和启动属性服务,并且启动Zygote进程。
    5.Zygote进程启动
    创建JavaVM并为JavaVM注册JNI,创建服务端Socket,启动SystemServer进程。
    6.SystemServer进程启动
    启动Binder线程池和SystemServiceManager,并且启动各种系统服务。
    7.Launcher启动
    被SystemServer进程启动的ActivityManagerService会启动Launcher,Launcher启动后会将已安装应用的快捷图标显示到界面上。

    结合上面的流程,给出Android系统启动流程图:
    这里写图片描述


    欢迎关注我的微信公众号,第一时间获得博客更新提醒,以及更多成体系的Android相关原创技术干货。
    扫一扫下方二维码或者长按识别二维码,即可关注。

    展开全文
  • Android系统启动流程的思维导图,包含了Android系统的关键进程以及关键服务。。
  • Android系统启动流程(1) ——解析init进程启动过程 Android系统启动流程(2) ——解析Zygote进程启动过程 Android系统启动流程(3) ——解析SystemServer进程启动过程 Launcher启动过程 此前已经学习了 Android ...
  • Android系统启动流程 总结 整体流程大致如下: Android系统的启动,主要是指Android手机关机后,长按电源键后,Android手机开机的过程。从系统角度看,Android的启动程序可分为: 1、bootloader引导 2、...
  • Android系统启动流程(1) ——解析init进程启动过程 Android系统启动流程(2) ——解析Zygote进程启动过程 SystemServer 启动过程 SystemServer 进程主要用于创建系统服务,我们熟知的 AMS、WMS和PMS 都是由它来...
  • Android系统启动流程之Launcher进程启动
  • Android系统启动流程分析之启动应用

    千次阅读 2016-06-24 17:37:27
    继上一篇Android系统启动流程分析之安装应用文章接着分析系统启动应用的过程. Android系统的启动流程简要分析里已经介绍了SystemServer在main方法里创建了一个线程ServerThread,并调用initAndLoop方法加载各种服务,...
  • Android系统启动流程概述: 当按下Android设备电源键时究竟发生了什么?Android的启动过程是怎么样的?什么是Linux内核?桌面系统linux内核与Android系统linux内核有什么区别?什么是引导装载程序?什么是Zygote...
  • Android系统启动流程分析 打开adb shell 然后执行ps命令,可以看到首先执行的是init方法!找到init.c这个文件. 然后走init里面的main方法,在这main方法里面执行mkdir进行创建很多的文件夹,和挂载一些目录 然后回去...
  • Android 底层系统启动流程(Bootloader Kernel init) 二. Android 上层系统启动流程 1. Android 上层系统启动简介 启动流程 : init 进程启动 -> 启动 Android 系统本地服务(Native Serv...
  • Android 系统启动流程简介

    千次阅读 2018-07-03 11:25:39
    Init 进程启动流程Android启动流程 init进程 –&gt; Zygote进程 –&gt; SystemServer进程 –&gt;各种应用进程Init 进程init是第一个进程,我们可以说它是root进程或者说有进程的父进程。init进程有...
  • 对于纯Android应用层开发来讲,了解一些Android的启动流程的知识并不会直接提高自己的代码质量。但是作为整个Android系统的开端,这部分的流程时刻影响着应用层的方方面面。这些知识也是作为Android开发进阶必须要...
  • 前言 本系列文章简要介绍 Android 系统启动的流程,不会拘泥于源码细节,旨在让读者了解大概的流程。另外,需要提醒大家注意的... init进程是Android系统中用户空间的第一个进程,进程号为1,是Android系统启动...
  • Android系统启动流程(一)解析init进程启动过程

    万次阅读 多人点赞 2017-02-07 11:29:48
    作为“Android框架层”这个大系列中的第一个系列,我们首先要了解的是Android系统启动流程,在这个流程中会涉及到很多重要的知识点,这个系列我们就来一一讲解它们,这一篇我们就来学习init进程。
  • Android系统启动流程(一)解析init进程启动过程  Android系统启动流程(二)解析Zygote进程启动过程 前言 上一篇我们学习了Zygote进程,并且知道Zygote进程启动了SyetemServer进程,那么这一篇我们就来学习...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,451
精华内容 29,780
关键字:

android系统启动流程