AMS之Activity启动（AndroidV）

已于 2024-12-04 11:41:33 修改
阅读量1.4k 收藏 15
点赞数 31
CC 4.0 BY-SA版权
分类专栏： android android组件 文章标签： android
于 2024-12-04 11:01:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gary_qing/article/details/144186980

一：背景

    Activity作为Android四大组件之一，用途之广、作用之重要想必不需要多做赘述，下面将从Launcher点击Dialer图标这个流程来剖析Activity是如何启动的。

PS：点击事件在Launcher中的传递本篇文章不涉及，流程起始点是ContextImpl.startActivity

二：Activity启动流程

    2.1 准备工作

    2.1.1 ContextImpl.startActivity

      最终会通过ActivityTaskManagerService调用到ActivityStarter，在ActivityStarter中做真正Activity启动工作。

//frameworks/base/core/java/android/app/ContextImpl.java
    public void startActivity(Intent intent) {
        warnIfCallingFromSystemProcess();
        startActivity(intent, null);
    }

//frameworks/base/core/java/android/app/ContextImpl.java
    public void startActivity(Intent intent, Bundle options) {
        ...
        mMainThread.getInstrumentation().execStartActivity(
                getOuterContext(), mMainThread.getApplicationThread(), null,
                (Activity) null, intent, -1, options);
    }

//frameworks/base/core/java/android/app/Instrumentation.java
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        ...
        try {
            intent.migrateExtraStreamToClipData(who);
            intent.prepareToLeaveProcess(who);
            //启动Activity
            int result = ActivityTaskManager.getService().startActivity(whoThread,
                    who.getOpPackageName(), who.getAttributionTag(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                    target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
            notifyStartActivityResult(result, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
    public final int startActivity(IApplicationThread caller, String callingPackage,
            String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
            Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
                resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
    private int startActivityAsUser(IApplicationThread caller, String callingPackage,
            @Nullable String callingFeatureId, Intent intent, String resolvedType,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
        ...
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setCallingFeatureId(callingFeatureId)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(opts)
                .setUserId(userId)
                .execute();
    }

2.1.2 ActivityStarter.execute

  这里主要完成以下工作

  • 校验Activity启动合法性，判断是否需要拦截Activity启动
  • 创建ActivityRecord对象
  • 校准Activity启动的flag，并根据flag判断是否有可以复用的task，没有则创建新的任务栈
  • 计算Activity的参数，如窗口区域、窗口模式等
  • 开始播放Activity启动时startingWindow动画
//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
    int execute() {
        try {
            //执行开始即开始启动Activity
            onExecutionStarted();
            ...
            int res = START_CANCELED;
            synchronized (mService.mGlobalLock) {
                ...
                try {
                    ...
                    res = executeRequest(mRequest);
                } finally {
                    ...
                }
                ...
            }
            ...
        } finally {
            //执行结束即Activity启动结束
            onExecutionComplete();
        }
    ...
    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
    private int executeRequest(Request request) {
        ...
        //判断是否需要拦截Activity启动
        if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, inTaskFragment,
                callingPid, callingUid, checkedOptions, suggestedLaunchDisplayArea)) {
            ...
            intentGrants = null;
        }
        ...
        //创建ActivityRecord对象
        final ActivityRecord r = new ActivityRecord.Builder(mService)
                ...
                .build();
        ...
        //启动Activity
        mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, checkedOptions,
                inTask, inTaskFragment, balVerdict, intentGrants, realCallingUid);
        ...
    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, ActivityOptions options, Task inTask,
            TaskFragment inTaskFragment,
            BalVerdict balVerdict,
            NeededUriGrants intentGrants, int realCallingUid) {
        ...
        try {
            mService.deferWindowLayout();
            transitionController.collect(r);
            try {
                //开始"startActivityInner" trace的地方
                Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
                //启动Activity
                result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                        startFlags, options, inTask, inTaskFragment, balVerdict,
                        intentGrants, realCallingUid);
            } catch (Exception ex) {
                Slog.e(TAG, "Exception on startActivityInner", ex);
            } finally {
                //结束"startActivityInner" trace的地方
                Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
                startedActivityRootTask = handleStartResult(r, options, result, newTransition,
                        remoteTransition);
            }
        } finally {
            mService.continueWindowLayout();
        }
        postStartActivityProcessing(r, result, startedActivityRootTask);

        return result;
    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
    int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, ActivityOptions options, Task inTask,
            TaskFragment inTaskFragment, BalVerdict balVerdict,
            NeededUriGrants intentGrants, int realCallingUid) {
        //初始化状态
        setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
                voiceSession, voiceInteractor, balVerdict.getCode(), realCallingUid);
        //校准mLaunchFlags并更新到mIntent中
        computeLaunchingTaskFlags();
        mIntent.setFlags(mLaunchFlags);
        ...
        //根据includeLaunchedFromBubble判断是否有task可以复用，并返回可以复用的task
        final Task reusedTask = resolveReusableTask(includeLaunchedFromBubble);
        ...
        //判断是否有可以使用的现成的task（例如在应用中通过Activity1启动Activity2，启动方式是standard，那么Activity1所在的task就可以给Activity2使用而不需要重新创建一个task）
        final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
        final boolean newTask = targetTask == null;
        ...
        //计算启动Activity时的参数，例如窗口区域、窗口模式等
        computeLaunchParams(r, sourceRecord, targetTask);
        //检查启动是否被允许
        int startResult = isAllowedToStart(r, newTask, targetTask);

        ...

        final ActivityRecord targetTaskTop = newTask
                ? null : targetTask.getTopNonFinishingActivity();
        if (targetTaskTop != null) {
            //Activity的启动模式是SINGLE_INSTANCE，移除所有有该Activity的任务栈
            if (LAUNCH_SINGLE_INSTANCE == mLaunchMode && mSourceRecord != null
                    && targetTask == mSourceRecord.getTask()) {
                final ActivityRecord activity = mRootWindowContainer.findActivity(mIntent,
                        mStartActivity.info, false);
                if (activity != null && activity.getTask() != targetTask) {
                    activity.destroyIfPossible("Removes redundant singleInstance");
                }
            }
            ...
        }
        //如果当前任务栈的最上层Activity是将要启动的Activity，判断是否需要再次启动Activity（standard模式会再次启动，singletop模式则不会再次启动）
        final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
        if (topRootTask != null) {
            startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
            if (startResult != START_SUCCESS) {
                return startResult;
            }
        }
        ...
        //可用任务栈不存在，创建新的任务栈
        if (mTargetRootTask == null) {
            mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
                    mOptions);
        }
        ...
        //在event log中记录有新的task创建了
        if (newTask) {
            EventLogTags.writeWmCreateTask(mStartActivity.mUserId, startedTask.mTaskId,
                    startedTask.getRootTaskId(), startedTask.getDisplayId());
        }
        //在event log中记录create Activity
        mStartActivity.logStartActivity(EventLogTags.WM_CREATE_ACTIVITY, startedTask);
        ...
        //开始Activity启动过渡动画
        mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch,
                mOptions, sourceRecord);
        //mDoResume为true
        if (mDoResume) {
            final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
            if (!mTargetRootTask.isTopActivityFocusable()
                    || (topTaskActivity != null && topTaskActivity.isTaskOverlay()
                    && mStartActivity != topTaskActivity)) {
                ...
                mTargetRootTask.ensureActivitiesVisible(null /* starting */);
                mTargetRootTask.mDisplayContent.executeAppTransition();
            } else {
                ...
                mRootWindowContainer.resumeFocusedTasksTopActivities(
                        mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
            }
        }
        ...
        //更新最近任务栈
        mSupervisor.mRecentTasks.add(startedTask);
        ...
    }

//frameworks/base/services/core/java/com/android/server/wm/Task.java
    void startActivityLocked(ActivityRecord r, @Nullable Task topTask, boolean newTask,
            boolean isTaskSwitch, ActivityOptions options, @Nullable ActivityRecord sourceRecord) {
        ...
        final DisplayContent dc = mDisplayContent;
        if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {//不需要过渡动画
            ...
        } else {
            //准备过渡动画
            dc.prepareAppTransition(TRANSIT_OPEN);
            mTaskSupervisor.mNoAnimActivities.remove(r);
        }
        ...
        //后台启动
        if (r.mLaunchTaskBehind) {
            ...
        } else if (SHOW_APP_STARTING_PREVIEW && doShow) {//SHOW_APP_STARTING_PREVIEW为true
            ...
            //开始StartingWindow动画
            mWmService.mStartingSurfaceController.showStartingWindow(r, prev, newTask,
                    isTaskSwitch, sourceRecord);
        }
    }

//frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
    boolean resumeFocusedTasksTopActivities(
            Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
            boolean deferPause) {
        ...
        if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
                || getTopDisplayFocusedRootTask() == targetRootTask)) {
            result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                    deferPause);
        }
        ...
    }

//frameworks/base/services/core/java/com/android/server/wm/Task.java
    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
            boolean deferPause) {
        ...
        try {
            ...
            if (isLeafTask()) {
                if (isFocusableAndVisible()) {
                    someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
                }
            }
            ...
        }
        ...
    }

//frameworks/base/services/core/java/com/android/server/wm/Task.java
    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
            boolean deferPause) {
        ...
        final boolean[] resumed = new boolean[1];
        final TaskFragment topFragment = topActivity.getTaskFragment();
        resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
        forAllLeafTaskFragments(f -> {
            if (topFragment == f) {
                return;
            }
            if (!f.canBeResumed(null /* starting */)) {
                return;
            }
            resumed[0] |= f.resumeTopActivity(prev, options, deferPause);
        }, true);
        return resumed[0];
    }

//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
    final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
            boolean skipPause) {
        ...
        //暂停前一个Activity
        boolean pausing = !skipPause && taskDisplayArea.pauseBackTasks(next);
        ...
        if (pausing) {
            ...
            if (next.attachedToProcess()) {//Activity所属进程已存在
                ...
            } else if (!next.isProcessRunning()) {//Activity所属进程不存在
                ...
                //启动Activity所属进程
                mAtmService.startProcessAsync(next, false /* knownToBeDead */, isTop,
                        isTop ? HostingRecord.HOSTING_TYPE_NEXT_TOP_ACTIVITY
                                : HostingRecord.HOSTING_TYPE_NEXT_ACTIVITY);
            }
            ...
        }
        ...
        boolean anim = true;
        final DisplayContent dc = taskDisplayArea.mDisplayContent;
        if (prev != null) {
            if (prev.finishing) {
                ...
                if (mTaskSupervisor.mNoAnimActivities.contains(prev)) {
                    ...
                } else {
                    //过渡动画准备完成
                    dc.prepareAppTransition(TRANSIT_CLOSE);
                }
                prev.setVisibility(false);
            } else {
                ...
            }
        } else {
            ...
        }

        if (anim) {
            //播放过渡动画
            next.applyOptionsAnimation();
        } else {
            ...
        }
        ...
        if (next.attachedToProcess()) {
            ...
            //更新CPU统计信息
            mAtmService.updateCpuStats();
            //更新状态
            next.setState(RESUMED, "resumeTopActivity");
            ...
            try {
                ...
                //标记Activity resume
                next.notifyAppResumed();
            ...
    }

2.2 暂停前一个Activity

2.2.1 TaskFragment.startPausing

  获取需要暂停的ActivityRecord（即当前处于resume状态的Activity对应的ActivityRecord），更新需要暂停Activity的状态为PAUSING，调用TaskFragment的schedulePauseActivity做真正暂停Activity的工作

//frameworks/base/services/core/java/com/android/server/wm/TaskDisplayArea.java
    boolean pauseBackTasks(ActivityRecord resuming) {
        final int[] someActivityPaused = {0};
        forAllLeafTasks(leafTask -> {
            //调用Task的pauseActivityIfNeeded来暂定Activity，暂停原因是"pauseBackTasks"
            if (leafTask.pauseActivityIfNeeded(resuming, "pauseBackTasks")) {
                someActivityPaused[0]++;
            }
        }, true /* traverseTopToBottom */);
        return someActivityPaused[0] > 0;
    }

//frameworks/base/services/core/java/com/android/server/wm/Task.java
    boolean pauseActivityIfNeeded(@Nullable ActivityRecord resuming, @NonNull String reason) {
        ...
        forAllLeafTaskFragments((taskFrag) -> {
            final ActivityRecord resumedActivity = taskFrag.getResumedActivity();
            if (resumedActivity != null && !taskFrag.canBeResumed(resuming)) {
                //调用TaskFragment的startPausing继续暂停流程
                if (taskFrag.startPausing(false /* uiSleeping*/, resuming, reason)) {
                    someActivityPaused[0]++;
                }
            }
        }, true /* traverseTopToBottom */);
        ...
    }

//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
    boolean startPausing(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming,
            String reason) {
        ...
        //将要暂停的Activity对应的ActivityRecord赋值给prev
        ActivityRecord prev = mResumedActivity;
        ...
        mPausingActivity = prev;
        ...
        //更新状态为PAUSING
        prev.setState(PAUSING, "startPausingLocked");
        prev.getTask().touchActiveTime();
        ...
        if (prev.attachedToProcess()) {
            if (shouldAutoPip && ActivityTaskManagerService.isPip2ExperimentEnabled()) {//画中画模式，不暂停Activity
                ...
            } else if (shouldAutoPip) {//画中画模式，不暂停Activity
                ...
            } else {
                //真正暂停Activity的地方
                schedulePauseActivity(prev, userLeaving, pauseImmediately,
                        false /* autoEnteringPip */, reason);
            }
        }
        ...
        if (mPausingActivity != null) {
            ...
            if (pauseImmediately) {
                //暂停完成
                completePause(false, resuming);
                return false;

            } else {
                ...
            }

        }
        ...
    }

2.2.2 ActivityThread.performPauseActivity

  Activity的暂停是通过PauseActivityItem（Activity 的暂停transaction）来实现。PauseActivityItem会调用ActivityThread，更新Activity的状态为ON_PAUSE，最终通过Activity的performPause来调用到Launcher Activity的onPause函数

//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
    void schedulePauseActivity(ActivityRecord prev, boolean userLeaving,
            boolean pauseImmediately, boolean autoEnteringPip, String reason) {
        try {
            ...
            //暂停Activity
最低0.47元/天 解锁文章

200万优质内容无限畅学
Android AMS——应用启动Activity（八）
小旭的专栏
09-27 863
上一篇文章在创建 Application 后还调用了 ActivityTaskManagerInternal 的 attachApplication 方法去启动 Activity，启动 Activity 的流程我们从这里开始分析。
Android AMS——APP启动流程（九）
小旭的专栏
10-08 529
调用 Activity 的 startActivity 方法来启动目标 Activity。接着就会调用到 Instrunmentation 的 execStartActivity 方法，通过获取 ATMS 的 binder 代理对象，然后调用到 ATMS 的 startActivity 中去。
【Android AMS】startActivity流程分析
Shujie
04-16 920
AMS是个用于管理Activity和其它组件运行状态的系统进程。
Android6.0 AMS启动Activity（二） 启动进程然后启动Activity
kc58236582的博客
09-08 4451
在上篇博客中说到有两种方式启动进程，其中一种就是点击Launcher界面，在点击Launcher最后也会调用Activity的startActivity方法，但是在Launcher中会调用如下代码： intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 这句代码代表启动这个Activity的时候要新建一个Task，主要在AMS中所有的Activity都
Android AMS分析之Activity启动过程
temp7695的博客
08-08 1177
在Android framework的systemService中有多个以线程形式存在的Service， 如ActivityManagerService、WindowMangerService等等， 其中ActivityManagerService（AMS）是个很重要的Service， 管理着四大组件的生命周期，本文先从Activity的启动过程入手， 了解从App端请求一个Activity， 到AMS进行一系列处理并与之交互的大概流程， 从而对Acitivity的启动过程有一个感性的认识。...
AMS-Activity启动流程
NIIIICO的博客
01-08 2066
本文基于Android_9.0、kernel_3.18源码 由PMS-PackageManagerService我们知道，PMS会在开机/安装app时解析APK的AndroidManifest.xml文件，并将解析的结果缓存在PMS中。 接下来分析启动Activity的流程。 Launcher启动流程 frameworks/base/services/java/com/android/server/SystemServer.java frameworks/base/services/core/java/c
Android Activity Manager Service (AMS) 深入详解及源码分析
weixin_44780781的博客
11-18 2898
AMS 是 Android 的核心服务，负责管理应用生命周期、进程调度、任务栈、Activity 启动与切换等功能。为了全面剖析 AMS 的工作机制，本文从启动过程、核心组件、源码分析、常见问题及优化等角度展开。步骤方法源码路径1、 SystemServer 启动2、 启动 AMS 服务3、创建 AMS 实例4、AMS 构造函数初始化5、启动核心逻辑6、完成 Binder 服务注册AMS 是 Android 系统的中枢，其源码复杂但逻辑清晰，理解其工作机制可以帮助开发者优化应用性能。
Android 11 （R）AMS Activity内部机制
abcdefg1289的博客
09-03 1300
由SystemServiceManager启动具体的服务，从代码可以看出这里启动的是ActivityTaskManagerService.Lifecycle，并没有直接启动ActivityTaskManagerService。AMS在将binder传递给ProcessRecord之前，还会调用bindApplication，实际上是调用的ActivityThread.java的bindApplication函数。最后在ZygoteInit.java中会调用caller.run();
AMS-Activity启动流程，源码分析
l447268674的博客
03-29 352
// 调用startActivity后， // 通过servicemanager获取到atms服务， // 通过socket服务通知zygote来fork出app进程， // zygote的socket服务端fork完APP进程后会反射执行activitythread的main方法 // app会把进程的binder服务交给atms管理， // atms最后通过handler来启动app和反射展示对应的activity界面
android 7.1 ams启动,android AMS—— Activity的启动一
weixin_33708562的博客
05-28 337
Activity的启动由APP端发起，通过Binder通讯进入系统端的AMS。Acitivity的启动.png一、APP端发起从APP端点击应用打开窗口调用StartActivity开始流程经过Instrumentation. execStartActivity中ActivityManager.getService()获得AMS IBinder客户端，并与AMS进行交互，进入到AMS中的start...
【Android】AMS（三）APP启动流程
每天不是在写bug就是在写bug的路上
06-07 1083
App和Activity启动流程
Activity启动流程-AMS
07-14 687
Activity的启动的基本介绍 因为关于AMS内部类的关系，例如stack、task，已有了相关的文档做介绍，本文不再赘述细说，基于相关文档以及代码的学习，本文主要集中篇幅集中于第三章，描述在Activity进程的启动流程中，启动应用进程以及应用进程中启动Activity的流程，也就是Activity启动的后半段流程。第二章关于Activity启动的前期准备主要涉及AMS的重点地方也会做详细描述...
Android源码剖析之Framework层实战版（Ams管理Activity启动）
劝学
08-24 5543
本文来自http://blog.csdn.net/liuxian13183/，引用必须注明出处！ 讲到实战，就不得不拿两个例子来说明，本篇想拿的是应用最广泛的两个：Ams和Wms，一个管理activity，一个管理窗口，而前面我们已经讲了不少，本篇不再赘述。 关于Ams对activity的管理，无非这几个方面：启动哪个activity、物理按键对activi...
Android ActivityManagerService总结(一)AMS启动
u012514113的专栏
04-02 1389
ActivityManagerService是Android系统中一个特别重要的系统服务，也是我们上层APP打交道最多的系统服务之一。ActivityManagerService（以下简称AMS） 主要负责四大组件的启动、切换、调度以及应用进程的管理和调度工作 本文主要介绍一下启动过程
【安卓AMS启动流程】
m0_46857231的博客
05-11 581
Android 9.0 及以前版本，Acitivity 管理由AMS 和WMS 协作完成，导致在AMS 和WMS 中都有相似功能的实体，除了大量的代码冗余之外，二者之间的协作也非常困难，从Android 11 的代码变更看，google 最终的目的是把activity 和window融合，其实activity和window的融合早在Android 10就开始了，但目前只是简单的把代码整理到一起了。
Android10 AMS详情分析二(Activity 启动流程，进程存在的情况下)
qq_18420641的博客
09-07 1090
AMS的梳理
Android系统服务 AMS 启动流程
bugyinyin的博客
08-25 1802
AMS为 system 创建环境：创建 AMS 对象，注册一系列的服务，如：管理四大组件、内存、CPU使用监控等为 system 进程创建，加入到AMS的进程管理中启动，拉起launch进程。
ams功能分析之activity启动过程
superpupil的博客
11-28 661
以点击桌面图标启动为例； 前提知识： 桌面也是activity，即Launcher继承ActivityAPP进程Launcher源码摘取分析：public void onClick(View v) { ... Object tag = v.getTag(); if (tag instanceof ShortcutInfo) { //点击的
【安卓开机启动】AMS启动流程
qq_23542165的博客
11-25 686
安卓系统框架学习_AMS启动流程 本文参考https://blog.csdn.net/renshuguo123723/article/details/85332146 AMS的启动流程 1:SystemServer#main -> 2:SystemServer#run -> 3:SystemServiceManager#startBootstrapServices 1:首先System...
Android 启动方法
最新发布
01-28
### Android 应用程序启动流程详解 #### 启动请求发起 当用户点击应用图标或其他方式触发应用启动时，`startActivity()` 方法被调用。此方法负责构建意图(Intent)，并通过Intent传递给系统服务层，向 `ActivityManagerService (AMS)` 发送启动新 Activity 的请求[^3]。 #### 请求处理与准备阶段 AMS 收到启动请求后，解析 Intent 中携带的信息，确定要启动的目标组件及其属性，如启动模式等。接着 AMS 进行一系列准备工作，包括但不限于： - 如果当前有其他 Activity 正处于前台展示，则先让其执行 `onPause()` 操作； - 判断目标 Activity 所属的应用进程是否已存在；如果不存在则创建新的进程实例，并等待该进程中 Application 对象初始化完毕。 #### 创建并显示Activity 一旦上述条件满足，AMS 将指示相应进程内的客户端（通常是应用程序的主线程）通过 `realStartActivity()` 函数继续后续工作。具体来说，在客户端内部会发生如下事件序列： 1. 调用 `scheduleLaunchActivity()` 方法将 LAUNCH_ACTIVITY 消息放入消息队列中。 2. 当轮询到这条消息时，由 `handleLaunchActivity()` 处理它。 3. 接着调用了 `performLaunchActivity()` 来真正地创建一个新的 Activity 实例，并依次回调它的 `onCreate()`, `onStart()` 生命周期函数。 4. 最终再经由 `handleResumeActivity()` 去触发展示前最后一个重要的生命周期钩子——`onResume()`，此时 Activity 已完全就绪可与用户互动[^2]。 ```java // 示例代码片段展示了部分关键逻辑 protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 设置UI布局文件 // 初始化操作... } @Override protected void onStart(){ super.onStart(); // 让Activity变得可见... } @Override public void onResume(){ super.onResume(); // 开始接收用户的输入... } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值