Activity启动2-startActivityMayWait方法

最新推荐文章于 2024-08-02 16:51:07 发布
最新推荐文章于 2024-08-02 16:51:07 发布
阅读量3k 收藏 3
点赞数 2
分类专栏： Android系统 Android基础 java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwei708846696/article/details/83243837
版权

我们从上一节分析参数开始最终达到：

result = mInterface.startActivityAndWait(null, null, intent, mimeType,
                                         null, null, 0, mStartFlags, profilerInfo,
                                         options != null ? options.toBundle() : null, mUserId);

此时我们先承上启下的分析参数：

参数含义
IApplicationThread caller调用者进程控制器null
String callingPackage调用者所在包名null
Intent intent调用者的意图intent
String resolvedTypeprovider中getType返回的值，有些页面可以处理这种urimimeType
IBinder resultTo接受结果的activitytRecord(binder对象)null
String resultWho用户自定义的字符串，调用完毕会传回去null
int requestCode用户自定义的code，调用完毕会传回去0
int startFlags启动标志mStartFlags
ProfilerInfo profilerInfo统计数据profilerInfo
Bundle bOptions其他启动参数　可能是从父activity继承的options.toBundle()
int userIduserIdmUserId

ActvitiyManagerService.java

@Override
public final WaitResult startActivityAndWait(IApplicationThread caller, 
                                             String callingPackage,
                                             Intent intent, String resolvedType,
                                             IBinder resultTo, String resultWho, 
                                             int requestCode,
                                             int startFlags, ProfilerInfo profilerInfo, 
                                             Bundle bOptions, int userId) {
    enforceNotIsolatedCaller("startActivityAndWait");
    userId = mUserController.handleIncomingUser(Binder.getCallingPid(), 
                                                Binder.getCallingUid(),
                                                userId, false, ALLOW_FULL_ONLY, 
                                                "startActivityAndWait", null);
    WaitResult res = new WaitResult();
    // TODO: Switch to user app stacks here.
    mActivityStarter.startActivityMayWait(caller, -1, callingPackage, 
                                          intent, resolvedType,
                                          null, null, resultTo, 
                                          resultWho, requestCode, startFlags, 
                                          profilerInfo, res, null,
                                          bOptions, false, userId, null, 
                                          "startActivityAndWait");
    return res;
}

final int startActivityMayWait(IApplicationThread caller, int callingUid,
                               String callingPackage, Intent intent, 
                               String resolvedType,
                               IVoiceInteractionSession voiceSession, 
                               IVoiceInteractor voiceInteractor,
                               IBinder resultTo, String resultWho, 
                               int requestCode, int startFlags,
                               ProfilerInfo profilerInfo, WaitResult outResult,
                               Configuration globalConfig, Bundle bOptions, 
                               boolean ignoreTargetSecurity, int userId,
                               TaskRecord inTask, String reason) {
    	//intent不能传递文件句柄
        if (intent != null && intent.hasFileDescriptors()) {
            throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        mSupervisor.mActivityMetricsLogger.notifyActivityLaunching();
    	//指定-n或者通过查找PKMS中的注册表
        boolean componentSpecified = intent.getComponent() != null;
    	//拷贝两个intent，一个是临时，一个是防止修改之后无法还原
        final Intent ephemeralIntent = new Intent(intent);
    	intent = new Intent(intent);
    	//当有对应组件并且传递的数据不为null，并且action也就是指定了-a参数是android.intent.action.VIEW
    	//并且是安装程序对应的Activity
    	//反正走不到这里
        if (componentSpecified
                && intent.getData() != null
                && Intent.ACTION_VIEW.equals(intent.getAction())
                && mService.getPackageManagerInternalLocked()
                        .isInstantAppInstallerComponent(intent.getComponent())) {、
            intent.setComponent(null /*component*/);
            componentSpecified = false;
        }
	    //利用PKMS解析满足Intent等参数要求的信息，内部包含了四大组件等从清单文件中声明的信息
        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
    	//当没有得到ResolveInfo时
        if (rInfo == null) {
            UserInfo userInfo = mSupervisor.getUserInfo(userId);
            //通过isManagedProfile()方法来判断这份UserInfo是否只是一个profile(Android中允许一个用户还拥有另一份profile)
            if (userInfo != null && userInfo.isManagedProfile()) {
                UserManager userManager = UserManager.get(mService.mContext);
                boolean profileLockedAndParentUnlockingOrUnlocked = false;
                long token = Binder.clearCallingIdentity();
                try {
                    UserInfo parent = userManager.getProfileParent(userId);
                    profileLockedAndParentUnlockingOrUnlocked = (parent != null)
                            && userManager.isUserUnlockingOrUnlocked(parent.id)
                            && !userManager.isUserUnlockingOrUnlocked(userId);
                } finally {
                    Binder.restoreCallingIdentity(token);
                }
                if (profileLockedAndParentUnlockingOrUnlocked) {
                    rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
                            PackageManager.MATCH_DIRECT_BOOT_AWARE
                                    | PackageManager.MATCH_DIRECT_BOOT_UNAWARE);
                }
            }
        }
   	    //上面是有关多用户的一段逻辑
        // 通过ResolveInfo得到目标Activity的信息.
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
    	//得到ActivityOptions，有关这个就是通过--task，--stack，--display等设置的一些额外参数
        ActivityOptions options = ActivityOptions.fromBundle(bOptions);
    	//来了一把AMS的锁
        synchronized (mService) {
            //得到调用的Pid和Uid
            final int realCallingPid = Binder.getCallingPid();
            final int realCallingUid = Binder.getCallingUid();
            int callingPid;
            if (callingUid >= 0) {
                callingPid = -1;
            } else if (caller == null) {
                callingPid = realCallingPid;
                callingUid = realCallingUid;
            } else {
                callingPid = callingUid = -1;
            }
            //得到当前的栈
            final ActivityStack stack = mSupervisor.mFocusedStack;
            //false
            stack.mConfigWillChange = globalConfig != null
                    && mService.getGlobalConfiguration().diff(globalConfig) != 0;
            if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
                    "Starting activity when config will change = " + stack.mConfigWillChange);
            //清除Pid和Uid，用于安全检查
            final long origId = Binder.clearCallingIdentity();
            //如果ActivityRecord不为null，ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE标记，意味着调用者App是属于heavy-weight process
            if (aInfo != null &&
                    (aInfo.applicationInfo.privateFlags
                            & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
                //进程名等于Application中的包名
                if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
                    //得到重量级进程的记录，当前运行的
                    final ProcessRecord heavy = mService.mHeavyWeightProcess;
                    //当前运行的重量级进程与要启动的不符合
                    if (heavy != null && (heavy.info.uid != aInfo.applicationInfo.uid
                            || !heavy.processName.equals(aInfo.processName))) {
                        int appCallingUid = callingUid;
                        if (caller != null) {
                           	//得到调用着的进程记录
                            ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
                            if (callerApp != null) {
                                appCallingUid = callerApp.info.uid;
                            } else {
                                Slog.w(TAG, "Unable to find app for caller " + caller
                                        + " (pid=" + callingPid + ") when starting: "
                                        + intent.toString());
                                ActivityOptions.abort(options);
                                return ActivityManager.START_PERMISSION_DENIED;
                            }
                        }

                        IIntentSender target = mService.getIntentSenderLocked(
                                ActivityManager.INTENT_SENDER_ACTIVITY, "android",
                                appCallingUid, userId, null, null, 0, new Intent[] { intent },
                                new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
                                        | PendingIntent.FLAG_ONE_SHOT, null);
					  //新的Intent
                        Intent newIntent = new Intent();
                        if (requestCode >= 0) {
                            // Caller is requesting a result.
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
                        }
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
                                new IntentSender(target));
                        //当前重量级进程的ActivityRecord数量大于0
                        if (heavy.activities.size() > 0) {
                            //得到第一个Activity，将名字和栈set进新的Intent中
                            ActivityRecord hist = heavy.activities.get(0);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,
                                    hist.packageName);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,
                                    hist.getTask().taskId);
                        }
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
                                aInfo.packageName);
                        newIntent.setFlags(intent.getFlags());
                        //新intent的名称
                        newIntent.setClassName("android",
                                HeavyWeightSwitcherActivity.class.getName());
                        intent = newIntent;
                        resolvedType = null;
                        caller = null;
                        callingUid = Binder.getCallingUid();
                        callingPid = Binder.getCallingPid();
                        componentSpecified = true;
                        rInfo = mSupervisor.resolveIntent(intent, null /*resolvedType*/, userId);
                        aInfo = rInfo != null ? rInfo.activityInfo : null;
                        if (aInfo != null) {
                            aInfo = mService.getActivityInfoForUser(aInfo, userId);
                        }
                    }
                }
            }
            //创建新的ActivityRecord
            final ActivityRecord[] outRecord = new ActivityRecord[1];
            //执行startActivityLocked
            int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, inTask,
                    reason);
            //设置pid，uid，权限校验相关
            Binder.restoreCallingIdentity(origId);
            //false
            if (stack.mConfigWillChange) { mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
                        "updateConfiguration()");
                stack.mConfigWillChange = false;
                if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
                        "Updating to new configuration after starting activity.");
                mService.updateConfigurationLocked(globalConfig, null, false);
            }
            //当结果不为null
            if (outResult != null) {
                outResult.result = res;
                //并且成功启动
                //目标Activity要运行在一个新的应用进程中，因此需要等待应用进程正常启动并处理相关请求
                if (res == ActivityManager.START_SUCCESS) {
                    mSupervisor.mWaitingActivityLaunched.add(outResult);
                    do {
                        try {
                            //一直等待，直到outResult显示Activity对应的Task成为front task
                            mService.wait();
                        } catch (InterruptedException e) {
                        }
                        //如果请求结果不是START_TASK_TO_FRONT，并且没有超时，并且调用方不是null则等待
                    } while (outResult.result != START_TASK_TO_FRONT
                            && !outResult.timeout && outResult.who == null);
                    if (outResult.result == START_TASK_TO_FRONT) {
                        res = START_TASK_TO_FRONT;
                    }
                }
                if (res == START_TASK_TO_FRONT) {
                    final ActivityRecord r = outRecord[0];
                    if (r.nowVisible && r.state == RESUMED) {
                        outResult.timeout = false;
                        outResult.who = r.realActivity;
                        outResult.totalTime = 0;
                        outResult.thisTime = 0;
                    } else {
                        outResult.thisTime = SystemClock.uptimeMillis();
                        //Activity对应的task拉到前台后，一直要等到该界面被加载
                        mSupervisor.waitActivityVisible(r.realActivity, outResult);
                        do {
                            try {
                                mService.wait();
                            } catch (InterruptedException e) {
                            }
                        } while (!outResult.timeout && outResult.who == null);
                    }
                }
            }
        }
}

小结这个方法；

  • 解析出与Intent相匹配的ActivityInfo。
  • 得到启动该Activity的Task，前台Task。
  • 通过startActivityLocked启动Activity
  • 对返回值进行处理，因为使用-W的参数，所以等待Activity被启动
我叫菜鸡
关注
专栏目录
Activity 启动流程分析
程序员Android
11-16 757
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、Android Acitvity启动流程概览二、启动流程中AMS内的各个角色三、AMS跨进程通信创建Activity，第一步四、ActivityStarter 正式开始启动Activity五、startActivityMayWait六、startActivity处理ActivityInfo转化为Acti...
【笔记】ActivityManagerService 启动activity
pirionFordring的博客
11-17 334
https://blog.csdn.net/csdn_of_coder/article/details/78024696     1.Activity向AMS 发起请求启动App  1.1 AMS 启动Activity 流程 AMS 调用startActivity() 来启动APP： public final int startActivity(IApplicationT...
应用冷启动流程分析 - AndroidU
最新发布
gary_qing的博客
08-02 889
应用启动
Android API For StartActivityAndWait
03-16
不同系统版本下IActivityManager.startActivityAndWait()函数的详情
ActivityManagerService之startActivity · 二
一个有梦想的码农的博客
01-21 923
这篇文章通过追踪AMS源码（api28），走一遍调用startActivity的代码执行流程，先来一张流程图： 从源码开始追踪（省略无关的代码）： 1.Activity#startActivity 2.Activity#startActivityForResult public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle
android6.0源码分析之Activity启动过程
yangzhihuiguming的专栏
06-20 4834
Activity最为android开发者最熟悉的组件，本文将分析Activity的启动过程，以及AMS对Activity的调度
Activity的启动流程
程序员Android
08-13 1008
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、Android Acitvity启动流程概览二、启动流程中AMS内的各个角色三、AMS跨进程...
二.Activity启动流程-ATMS到ApplicationThread的调用过程
你只是看起很努力
07-14 1396
Activity的启动一般分为普通Activity的启动,根Activity的启动.而根Activity是指应用启动的第一个Activity过程,所以也可以理解为应用的启动过程. 相关内容链接：android系统启动流程
Activity启动流程2
shbj的博客
05-05 293
在应用程序内启动同进程内的Activity 1、onClick @Override public void onClick(View v) { switch (v.getId()){ case R.id.btn_sub: Intent intent = new Intent(); intent.setAction("com.shbj.action.action.sub1");
详解VirtualApk启动插件Activity
08-27
1. 调用startActivity方法，首先调用Instrumentation.execStartActivity方法，该方法会调用AMS.startActivity启动对应的Activity，然后通过checkStartActivityResult来对启动结果进行检查。 2. AMS.startActivity...
Android Activity——启动过程探索（三）
ITRenj的博客
03-02 960
在《Android Activity——启动过程探索（一） 和 《Android Activity——启动过程探索（二） 中我们知道了Activity启动的生命周期回调，并且分析了其中当前Activity的 onPause() 和新打开的Activity的 onCreate() 、 onStart()和onResume()回调执行过程，也就是新的Activity已经完成了 “创建->用户可见->用户可操作” 的过程。那么当前的Activity就变为不可见了，需要执行 onstop() 回调，如
源码阅读体验 - Activity启动
马也程序猴的专栏
06-21 156
这是第一次真正意义上的阅读源码，文章的目的是记录一下阅读源码的体验和心路历程，探索一下自己后续应该怎样阅读源码和使用源码；文章中可能会存在错误和理解偏差，这些不是文章的重点，各位大佬留情。 这篇不是技术文章，请勿参考 这篇不是技术文章，请勿参考 这篇不是技术文章，请勿参考 Activity的启动流程最初由Zygote发起，通过AMS来启动Activity，其中的过程可以总结为Launcher => AMS，AMS => ApplicationThread，ApplicationThread =
startActivity流程
chenlian的博客
03-01 563
1. startActivity流程图 调用方Activity1通过调用startActivity()跳转到Activity2的流程图如下所示，后面将对其中重要步骤进行详细分析 2. startActivityMayWait() startActivityMayWait()函数代码很长，其核心工作主要分为5个步骤： 3. startActivityLocked(1)
Android6.0 AMS启动Activity（二） 启动进程然后启动Activity
kc58236582的博客
09-08 4344
在上篇博客中说到有两种方式启动进程，其中一种就是点击Launcher界面，在点击Launcher最后也会调用Activity的startActivity方法，但是在Launcher中会调用如下代码： intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 这句代码代表启动这个Activity的时候要新建一个Task，主要在AMS中所有的Activity都
Android笔记（十六）Activity启动
u014529755的专栏
04-15 642
Activity启动分为两种情况 Activity所在进程不存在，冷启动 Activity所在进程存在于后台 针对于这两种情况，我们都可以对此用一套流程来描述，针对冷启动情况，其中会添加一部分创建ActivityThread的流程 还是先上图,图片出处GitYuan 假设在图片流程之前，我们做的是点击桌面按钮操作，那么会去执行activity的startActivity操作，该方法里...
Activity的启动过程(2)
rockstore的博客
03-29 392
在Activity启动流程（1）中，Activity的启动经过binder通信就会进入ActivityManagerService所在的进程中继续执行startActivity方法，由于后续的方法涉及的逻辑比较多，在后面的分析中我可能会把某一个函数单独拿出来分析，最后我会做一个启动流程的总结。 ok，接下来看下startActivity的实现： ActivityManangerServ...
startActivity启动过程
GitViolet的博客
06-02 323
代码来自Android 7.1.1版本，简单分析startActivity的启动过程 【1.1】 启动Activity，最终都会调到startActivityForResult，requestCode默认-1，options默认null //Activity.java public void startActivityForResult(@RequiresPermis...
AMS—启动一个Activity（基于深入理解Android）
淡淡的宁静的博客
07-16 982
am启动一个activity 在前面先作一个精简的总结 从上图说起，上图分析到为Activity所在进程zygote一个进程，其实zygote一个进程，就是为其分配私有空间，分配一个process_id,ProcessRecord(应该相当于进程描述符吧）。随意此图没有涉及到Activity的内容。那么接下来，简要的分析流程中的每个方法的作用： ActivityManager
Android 进阶之了解源码——Activity启动
编程之路的专栏
03-04 603
我们通常说Android有四大组件，也有说法是五大组件，将Intent也算一种，不管是五大还是四大，它们都是Android app开发中最经常打交道的东西，刚开始的时候也都会碰到一些坑，很多时候我们都是搜索资料，看其他人写的博客来学习和避坑，其实很多博客资料也就是对官方文档的翻译，加上一些自己避坑心得的记录，有些时候即使通过一些资料解决了某个问题，但其实自己也说不出个所以然来，也是云里雾里，...
Android进阶：深度解析Activity服务启动
2. **Activity启动阶段** 当新进程启动后，或者服务已经在当前进程中运行，就会开始启动Activity。这涉及到解析Intent，创建Activity实例，调用生命周期方法如`onCreate`、`onStart`和`onResume`。对于服务来说，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值