Activity启动流程

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量61 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41940961/article/details/115757496
版权 
/*
Activity -> startActivity -> startActivityForResult
*/
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
    if (mParent == null) {
        ...
        Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options);
        ...
    } else {
        ...
    }
}
    
/*
看到里面调用了mInstrumentation.execStartActivity方法，其中一个参数mMainThread.getApplicationThread()，它的类型是ApplicationThread，ApplicationThread是ActivityThread的内部类，继承IApplicationThread.Stub，也是个Binder对象
而Instrumentation具有跟踪application及activity生命周期的功能，用于android 应用测试框架中代码检测。
接着看下mInstrumentation.execStartActivity方法：

Activity的启动交给了ActivityManager.getService()
*/
public ActivityResult execStartActivity(
    Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    ...
    try {
        ...
        int result = ActivityManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

public class ActivityManagerService extends IActivityManager.Stub2        
				implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback3

/*
ActivityManagerService继承IActivityManager.Stub，等于继承了Binder并且实现IActivityManager的Binder接口
ActivityManager.getService()获取的Binder对象是ActivityManagerService，通过单例获取

得到返回值result，调用 checkStartActivityResult(result, intent)：
*/

public static void checkStartActivityResult(int res, Object intent) {
    if (!ActivityManager.isStartResultFatalError(res)) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
                throw new ActivityNotFoundException(
                        "Unable to find explicit activity class "
                        + ((Intent)intent).getComponent().toShortString()
                        + "; have you declared this activity in your AndroidManifest.xml?");
            throw new ActivityNotFoundException(
                    "No Activity found to handle " + intent);
        case ActivityManager.START_PERMISSION_DENIED:
            throw new SecurityException("Not allowed to start activity "
                    + intent);
        case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
            throw new AndroidRuntimeException(
                    "FORWARD_RESULT_FLAG used while also requesting a result");
        case ActivityManager.START_NOT_ACTIVITY:
            throw new IllegalArgumentException(
                    "PendingIntent is not an activity");
        case ActivityManager.START_NOT_VOICE_COMPATIBLE:
            throw new SecurityException(
                    "Starting under voice control not allowed for: " + intent);
        case ActivityManager.START_VOICE_NOT_ACTIVE_SESSION:
            throw new IllegalStateException(
                    "Session calling startVoiceActivity does not match active session");
        case ActivityManager.START_VOICE_HIDDEN_SESSION:
            throw new IllegalStateException(
                    "Cannot start voice activity on a hidden session");
        case ActivityManager.START_ASSISTANT_NOT_ACTIVE_SESSION:
            throw new IllegalStateException(
                    "Session calling startAssistantActivity does not match active session");
        case ActivityManager.START_ASSISTANT_HIDDEN_SESSION:
            throw new IllegalStateException(
                    "Cannot start assistant activity on a hidden session");
        case ActivityManager.START_CANCELED:
            throw new AndroidRuntimeException("Activity could not be started for "
                    + intent);
        default:
            throw new AndroidRuntimeException("Unknown error code "
                    + res + " when starting " + intent);
    }
}

//ActivityManagerService.java
@Override
public int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return mActivityTaskManager.startActivity(caller, callingPackage, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions);
}

//ActivityTaskManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}
//ActivityTaskManagerService.java
@Override
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
            true /*validateIncomingUser*/);
}
//ActivityTaskManagerService.java
int startActivityAsUser(IApplicationThread caller, String callingPackage,
      Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
        boolean validateIncomingUser) {
    enforceNotIsolatedCaller("startActivityAsUser");

    userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

    // TODO: Switch to user app stacks here.
    return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setMayWait(userId)
            .execute();

}

/*
startActivityAsUser中，通过getActivityStartController().obtainStarter方法获取ActivityStarter实例 
然后调用一系列方法，最后的execute()方法是开始启动activity：
*/
//ActivityStartController.java
ActivityStarter obtainStarter(Intent intent, String reason) {
    return mFactory.obtain().setIntent(intent).setReason(reason);
}

//ActivityStarter.java
int execute() {
    try {
        // TODO(b/64750076): Look into passing request directly to these methods to allow
        // for transactional diffs and preprocessing.
        if (mRequest.mayWait) {
            return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                    mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
                    mRequest.intent, mRequest.resolvedType,
                    mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                    mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                    mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                    mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                    mRequest.inTask, mRequest.reason,
                    mRequest.allowPendingRemoteAnimationRegistryLookup,
                    mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
        } else {
            return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                    mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                    mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                    mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                    mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                    mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                    mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                    mRequest.outActivity, mRequest.inTask, mRequest.reason,
                    mRequest.allowPendingRemoteAnimationRegistryLookup,
                    mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
        }
    } finally {
        onExecutionComplete();
    }
}

//ActivityStarter.java
private int startActivityMayWait(){

}

//startActivityMayWait，startActivity最终都会走到startActivity方法

//ActivityStarter.java
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity, boolean restrictedBgActivity) {
    int result = START_CANCELED;
    final ActivityStack startedActivityStack;
    try {
        mService.mWindowManager.deferSurfaceLayout();
        result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
    } finally {
        ...
    }

    postStartActivityProcessing(r, result, startedActivityStack);

    return result;
}

/*
里面有调用了startActivityUnchecked方法，startActivityUnchecked内部调用了ActivityStack的startActivityLocked方法，startActivityLocked内部调用ensureActivitiesVisibleLocked方法，ensureActivitiesVisibleLocked又调用makeVisibleAndRestartIfNeeded方法，来看下：
*/

private int startActivityUnchecked(){
	mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
                mOptions);
}

void startActivityLocked(){
	ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}

final void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,boolean preserveWindows) {
    ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
            true /* notifyClients */);
}
final void ensureActivitiesVisibleLocked(){
	makeVisibleAndRestartIfNeeded(starting, configChanges, isTop, resumeNextActivity, r)
}

private boolean makeVisibleAndRestartIfNeeded(){
	mStackSupervisor.startSpecificActivityLocked(r, andResume && !r.mLaunchTaskBehind, true /* checkConfig */);
}

void startSpecificActivityLocked(){
	realStartActivityLocked(r, wpc, andResume, checkConfig);
}

/*
通过 ClientTransaction.obtain( proc.getThread(), r.appToken)获取了clientTransaction，其中参数proc.getThread()是IApplicationThread，就是前面提到的ApplicationThread在系统进程的代理。

ClientTransaction是包含一系列的message的容器，message用于 发送到客户端，包含回调方法和生命周期状态。

接着看，使用clientTransaction.addCallback添加了LaunchActivityItem实例：
*/

/*
Activity 启动经过 Instrumentation, 的 execStartActivity 方法

通过 ActivityManager.getService 在进行通信

service 其实是一个 IActivityManager.aidl，进行 Android 的 IPC

进行通信的就是 ActivityManagerService，查看 startActivity -> ActivityStart --> startActivityMayWait 方法

-> startActivityLocked ->startActivity -> doPendingActivityLaunchesLocked -> startActivity 
-> startActivityUnchecked -> ActivityStackSupervisor 的.resumeFocusedStackTopActivityLocked
-> resumeTopActivityUncheckedLocked -> resumeTopActivityInnerLocked -> ActivityStackSupervisor.startSpecificActivityLocked -> realStartActivityLocked (app存在情况)
-> ActivityManagerService.startProcessLocked

启动逻辑：
1、如果启动的是我们自己 app 进程的 Activity，那么直接去启动就好了
2、如果我们启动的 Activity 所在的进程不存在
例如：我们把微信 kill，然后跳转微信分享的 Activity，或者我们点击launch 的微信图标，那么，我么就会走创建新进程的逻辑

app.thread.

Activity启动流程（从Launcher开始）：

第一阶段：Launcher通知AMS要启动新的Activity（在Launcher所在的进程执行）
第二阶段：AMS先校验一下Activity的正确性，如果正确的话，会暂存一下Activity的信息。然后，AMS会通知Launcher程序pause Activity（在AMS所在进程执行）
第三阶段： pause Launcher的Activity，并通知AMS已经paused（在Launcher所在进程执行）
第四阶段：检查activity所在进程是否存在，如果存在，就直接通知这个进程，在该进程中启动Activity；不存在的话，会调用Process.start创建一个新进程（执行在AMS进程）
第五阶段： 创建ActivityThread实例，执行一些初始化操作，并绑定Application。如果Application不存在，会调用LoadedApk.makeApplication创建一个新的Application对象。之后进入Loop循环。（执行在新创建的app进程）
第六阶段：处理新的应用进程发出的创建进程完成的通信请求，并通知新应用程序进程启动目标Activity组件（执行在AMS进程）
第七阶段： 加载MainActivity类，调用onCreate声明周期方法（执行在新启动的app进程）

点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；
system_server进程接收到请求后，向zygote进程发送创建进程的请求；
Zygote进程fork出新的子进程，即App进程；
App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；
system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；
App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；
主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。
到此，App便正式启动，开始进入Activity生命周期，执行完onCreate/onStart/onResume方法，UI渲染结束后便可以看到App的主界面。

Zygote进程 –> SystemServer进程 –> 各种系统服务 –> 应用进程 
在Actvity启动过程中，其实是应用进程与SystemServer进程相互配合启动Activity的过程
其中应用进程主要用于执行具体的Activity的启动过程，回调生命周期方法等操作，
而SystemServer进程则主要是调用其中的各种服务，将Activity保存在栈中，协调各种系统资源等操作。
通过ActivityManagerNative –> ActivityManagerService 实现了应用进程与SystemServer进程的通讯 
通过AppicationThread <– IApplicationThread实现了SystemServer进程与应用进程的通讯

ActivityManagerService是ActivityManagerNative的具体实现，换句话说，就是AMS才是服务端的具体实现


*/
呓曲流觞
关注
Android Activity启动流程○
zenmela2011的专栏
05-11 4442
从点击屏幕上的应用icon，到该应用展示第一个可视界面，这个过程中，Android系统究竟做了什么操作？又涉及到哪些进程？ 1.根Activity启动过程 ①从Launcher到AMS 当点击屏幕上的应用icon时，Laucher发送启动应用的请求给AMS，因为Launcher是在Launcher进程，而AMS是在SystemServer进程。因此，实现这个请求，本质上是在实现一个跨进程通信的功能。在安卓领域实现跨进程通信的技术有多种，像是Broadcast、ContentProvinder等。在系.
Activity启动流程概述
听海时节的博客
09-12 1709
对于通过点击应用图标启动activity的场景说，AMS在这一步中没回调用startProcessLocked来创建一个新的进程，而对于通过在内部启动新的activity来说，这一步不需要执行，因为新的activity就在原来的activity所在的进程中启动。无论是通过Launcher启动，还是通过activity 内部来调用startActivity接口 来启动新的activity，都是通过Binder进程间通信进入到AMS进程中，并且调用AMS.startActivity 接口。
Activity启动流程详解
一个踩这七色彩虹的路人甲
07-20 1256
利用类加载器进行创建实例，同时利用Instrumentation回调activity的生命中周期。然后AMS进程一系列的工作，如判断该activity是否存在，启动模式是什么，有没有进行注册等。，利用本地进程在系统服务进程的IBinder接口直接访问本地ActivityThread。通过AMS在本地进程的IBinder接口，访问AMS，这里采用的跨进程技术是AIDL。的内部类，IApplicationThread是在远程服务端的Binder接口。ActivityThread通过。...
Android Activity启动流程一：从Intent到Activity创建
fumeidonga的博客
08-29 5392
Activity 是 android 四大组件之一，很有必要知道它的启动过程，我们在上一篇文章中介绍了 APP的启动流程，里面大概讲到了Activity的 启动流程，在本文中，我们系统的再总结一下，当成一个记录。
Android Activity启动过程详解
allen_xu_2012_new的博客
06-12 9208
ctivity启动的流程分为两部分：一是在activity中通过startActivity(Intent intent)方法启动一个Activity；二是我们在桌面通过点击应用图标启动一个App然后显示Activity；第二种方式相较于第一种方式更加全面和复杂，所以本文会以第二种流程来分析。应用的启动流程大致分为下面五个阶段：1，应用启动进程 Launcher 调用 ATMS 系统进程的过程2，ATMS 向 AMS 发送创建应用进程的过程。
图解Activity启动流程
Android小码家
09-09 3115
看一百遍不如做一遍，道理都懂，那么赶紧做出第一步吧！
Activity启动流程分析
java521666的博客
08-30 1680
简单点来说就是通过AMS代理类，封装创建Activity的信息，然后回调给ActivityThread，通过mInstrumentation创建Activity，调用onCreate方法启动Activity。隐式Intent是通过在AndroidManifest文件中设置action、data、category，让系统来筛选出合适的Activity。2、setComponent(componentName)方法。1、构造方法传入Component，最常用的方式。...
Android Activity启动过程分析
sd_zhuzhipeng的专栏
08-06 3057
当我们在一个Activity中（或通过Context对象），调用startActivity()方法来启动另一个Activity的工程中发发生了什么呢？这就是本文想跟大家分享的内容，我们一起通过源码的方式来看下Activity的启动过程（本文是基于Android Q源码）。  启动Activity的流程大体分为两步：找到要启动的Activity；然后启动它。（虽说有点像如何把大象装进冰箱，但也确实是那么回事，只不过每个步骤有更多细节） 找到Activity  要想启动一个Activity，系统先要找到这个.
Android面试题之activity启动流程
AntDream的程序世界
06-13 858
本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点。
activity启动流程
03-01
activity启动流程
Activity启动过程
06-20
Activity启动过程
android Activity启动流程
01-03
Activity的启动过程，我们可以从Context的startActivity说起，其实现是ContextImpl的startActivity，然后内部会通过Instrumentation来尝试启动Activity，这是一个跨进程过程，它会调用ams的startActivity方法，当AMS...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 322
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 389
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 689
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
Java分布式锁
juanmiao的专栏
10-12 697
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 527
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 908
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值