startActivity流程分析

分类：Android, Java 阅读 (986) Add comments

2月 212017

转载请注明原文地址：http://bcoder.com/java/analysis-of-startactivity

首先调用Activity.java中的startActivity

    public void startActivity(Intent intent) {
        this.startActivity(intent, null);
    }

public void startActivity(Intent intent) {

this.startActivity(intent, null);

}

调用了另外一startActivity函数，增加了options参数，为避免过于复杂，我们使用options为null

    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
    }

public void startActivity(Intent intent, @Nullable Bundle options) {

if (options != null) {

startActivityForResult(intent, -1, options);

} else {

// Note we want to go through this call for compatibility with

// applications that may have overridden the method.

startActivityForResult(intent, -1);

}

实际上又调用到了startActivityForResult函数

    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
    }

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {

startActivityForResult(intent, requestCode, null);

}

同样，带options参数的startActivityForResult

    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
            // TODO Consider clearing/flushing other event sources and events for child windows.
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,

@Nullable Bundle options) {

if (mParent == null) {

options = transferSpringboardActivityOptions(options);

Instrumentation.ActivityResult ar =

mInstrumentation.execStartActivity(

this, mMainThread.getApplicationThread(), mToken, this,

intent, requestCode, options);

if (ar != null) {

mMainThread.sendActivityResult(

mToken, mEmbeddedID, requestCode, ar.getResultCode(),

ar.getResultData());

}

if (requestCode >= 0) {

// If this start is requesting a result, we can avoid making

// the activity visible until the result is received. Setting

// this code during onCreate(Bundle savedInstanceState) or onResume() will keep the

// activity hidden during this time, to avoid flickering.

// This can only be done when a result is requested because

// that guarantees we will get information back when the

// activity is finished, no matter what happens to it.

mStartedActivity = true;

}

cancelInputsAndStartExitTransition(options);

// TODO Consider clearing/flushing other event sources and events for child windows.

} else {

if (options != null) {

mParent.startActivityFromChild(this, intent, requestCode, options);

} else {

// Note we want to go through this method for compatibility with

// existing applications that may have overridden it.

mParent.startActivityFromChild(this, intent, requestCode);

}

我们这里假设mParent为null

然后调用Instrumentation的executeStartActivity

    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess();
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
        }
        return null;
    }

public ActivityResult execStartActivity(

Context who, IBinder contextThread, IBinder token, Activity target,

Intent intent, int requestCode, Bundle options) {

IApplicationThread whoThread = (IApplicationThread) contextThread;

if (mActivityMonitors != null) {

synchronized (mSync) {

final int N = mActivityMonitors.size();

for (int i=0; i<N; i++) {

final ActivityMonitor am = mActivityMonitors.get(i);

if (am.match(who, null, intent)) {

am.mHits++;

if (am.isBlocking()) {

return requestCode >= 0 ? am.getResult() : null;

}

break;

}

try {

intent.migrateExtraStreamToClipData();

intent.prepareToLeaveProcess();

int result = ActivityManagerNative.getDefault()

.startActivity(whoThread, who.getBasePackageName(), intent,

intent.resolveTypeIfNeeded(who.getContentResolver()),

token, target != null ? target.mEmbeddedID : null,

requestCode, 0, null, null, options);

checkStartActivityResult(result, intent);

} catch (RemoteException e) {

}

return null;

}

然后调用ActivityManagerService里的startActivity和startActivityAsUser

    @Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags,
            String profileFile, ParcelFileDescriptor profileFd, Bundle options) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode,
                startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());
    }

    @Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags,
            String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
                false, true, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
                resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,
                null, null, options, userId);
    }

@Override

public final int startActivity(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo,

String resultWho, int requestCode, int startFlags,

String profileFile, ParcelFileDescriptor profileFd, Bundle options) {

return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,

resultWho, requestCode,

startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());

}

@Override

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo,

String resultWho, int requestCode, int startFlags,

String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {

enforceNotIsolatedCaller("startActivity");

userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,

false, true, "startActivity", null);

// TODO: Switch to user app stacks here.

return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,

resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,

null, null, options, userId);

}

mStackSupervisor.startActivityMayWait函数

    final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags, String profileFile,
            ParcelFileDescriptor profileFd, WaitResult outResult, Configuration config,
            Bundle options, int userId) {
        Slog.i(TAG, "startActivityMayWait, liuderu"); 
        // Refuse possible leaked file descriptors
        if (intent != null && intent.hasFileDescriptors()) {
            throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        boolean componentSpecified = intent.getComponent() != null;

        // Don't modify the client's object!
        intent = new Intent(intent);

        // Collect information about the target of the Intent.
        ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags,
                profileFile, profileFd, userId);

        synchronized (mService) {
            int callingPid;
            if (callingUid >= 0) {
                callingPid = -1;
            } else if (caller == null) {
                callingPid = Binder.getCallingPid();
                callingUid = Binder.getCallingUid();
            } else {
                callingPid = callingUid = -1;
            }

            final ActivityStack stack = getFocusedStack();
            stack.mConfigWillChange = config != null
                    && mService.mConfiguration.diff(config) != 0;
            if (DEBUG_CONFIGURATION) Slog.v(TAG,
                    "Starting activity when config will change = " + stack.mConfigWillChange);

            final long origId = Binder.clearCallingIdentity();

            if (aInfo != null &&
                    (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
                // This may be a heavy-weight process!  Check to see if we already
                // have another, different heavy-weight process running.
                if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
                    if (mService.mHeavyWeightProcess != null &&
                            (mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid ||
                            !mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) {
                        int realCallingUid = callingUid;
                        if (caller != null) {
                            ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
                            if (callerApp != null) {
                                realCallingUid = 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",
                                realCallingUid, userId, null, null, 0, new Intent[] { intent },
                                new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
                                | PendingIntent.FLAG_ONE_SHOT, null);

                        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));
                        if (mService.mHeavyWeightProcess.activities.size() > 0) {
                            ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,
                                    hist.packageName);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,
                                    hist.task.taskId);
                        }
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
                                aInfo.packageName);
                        newIntent.setFlags(intent.getFlags());
                        newIntent.setClassName("android",
                                HeavyWeightSwitcherActivity.class.getName());
                        intent = newIntent;
                        resolvedType = null;
                        caller = null;
                        callingUid = Binder.getCallingUid();
                        callingPid = Binder.getCallingPid();
                        componentSpecified = true;
                        try {
                            ResolveInfo rInfo =
                                AppGlobals.getPackageManager().resolveIntent(
                                        intent, null,
                                        PackageManager.MATCH_DEFAULT_ONLY
                                        | ActivityManagerService.STOCK_PM_FLAGS, userId);
                            aInfo = rInfo != null ? rInfo.activityInfo : null;
                            aInfo = mService.getActivityInfoForUser(aInfo, userId);
                        } catch (RemoteException e) {
                            aInfo = null;
                        }
                    }
                }
            }

            int res = startActivityLocked(caller, intent, resolvedType,
                    aInfo, resultTo, resultWho, requestCode, callingPid, callingUid,
                    callingPackage, startFlags, options, componentSpecified, null);

            if (stack.mConfigWillChange) {
                // If the caller also wants to switch to a new configuration,
                // do so now.  This allows a clean switch, as we are waiting
                // for the current activity to pause (so we will not destroy
                // it), and have not yet started the next activity.
                mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
                        "updateConfiguration()");
                stack.mConfigWillChange = false;
                if (DEBUG_CONFIGURATION) Slog.v(TAG,
                        "Updating to new configuration after starting activity.");
                mService.updateConfigurationLocked(config, null, false, false);
            }

            Binder.restoreCallingIdentity(origId);

            if (outResult != null) {
                outResult.result = res;
                if (res == ActivityManager.START_SUCCESS) {
                    mWaitingActivityLaunched.add(outResult);
                    do {
                        try {
                            mService.wait();
                        } catch (InterruptedException e) {
                        }
                    } while (!outResult.timeout && outResult.who == null);
                } else if (res == ActivityManager.START_TASK_TO_FRONT) {
                    ActivityRecord r = stack.topRunningActivityLocked(null);
                    if (r.nowVisible) {
                        outResult.timeout = false;
                        outResult.who = new ComponentName(r.info.packageName, r.info.name);
                        outResult.totalTime = 0;
                        outResult.thisTime = 0;
                    } else {
                        outResult.thisTime = SystemClock.uptimeMillis();
                        mWaitingActivityVisible.add(outResult);
                        do {
                            try {
                                mService.wait();
                            } catch (InterruptedException e) {
                            }
                        } while (!outResult.timeout && outResult.who == null);
                    }
                }
            }

            return res;
        }
    }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

final int startActivityMayWait(IApplicationThread caller, int callingUid,

String callingPackage, Intent intent, String resolvedType, IBinder resultTo,

String resultWho, int requestCode, int startFlags, String profileFile,

ParcelFileDescriptor profileFd, WaitResult outResult, Configuration config,

Bundle options, int userId) {

Slog.i(TAG, "startActivityMayWait, liuderu");

// Refuse possible leaked file descriptors

if (intent != null && intent.hasFileDescriptors()) {

throw new IllegalArgumentException("File descriptors passed in Intent");

}

boolean componentSpecified = intent.getComponent() != null;

// Don't modify the client's object!

intent = new Intent(intent);

// Collect information about the target of the Intent.

ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags,

profileFile, profileFd, userId);

synchronized (mService) {

int callingPid;

if (callingUid >= 0) {

callingPid = -1;

} else if (caller == null) {

callingPid = Binder.getCallingPid();

callingUid = Binder.getCallingUid();

} else {

callingPid = callingUid = -1;

}

final ActivityStack stack = getFocusedStack();

stack.mConfigWillChange = config != null

&& mService.mConfiguration.diff(config) != 0;

if (DEBUG_CONFIGURATION) Slog.v(TAG,

"Starting activity when config will change = " + stack.mConfigWillChange);

final long origId = Binder.clearCallingIdentity();

if (aInfo != null &&

(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {

// This may be a heavy-weight process! Check to see if we already

// have another, different heavy-weight process running.

if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {

if (mService.mHeavyWeightProcess != null &&

(mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid ||

!mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) {

int realCallingUid = callingUid;

if (caller != null) {

ProcessRecord callerApp = mService.getRecordForAppLocked(caller);

if (callerApp != null) {

realCallingUid = 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",

realCallingUid, userId, null, null, 0, new Intent[] { intent },

new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT

| PendingIntent.FLAG_ONE_SHOT, null);

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));

if (mService.mHeavyWeightProcess.activities.size() > 0) {

ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0);

newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,

hist.packageName);

newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,

hist.task.taskId);

}

newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,

aInfo.packageName);

newIntent.setFlags(intent.getFlags());

newIntent.setClassName("android",

HeavyWeightSwitcherActivity.class.getName());

intent = newIntent;

resolvedType = null;

caller = null;

callingUid = Binder.getCallingUid();

callingPid = Binder.getCallingPid();

componentSpecified = true;

try {

ResolveInfo rInfo =

AppGlobals.getPackageManager().resolveIntent(

intent, null,

PackageManager.MATCH_DEFAULT_ONLY

| ActivityManagerService.STOCK_PM_FLAGS, userId);

aInfo = rInfo != null ? rInfo.activityInfo : null;

aInfo = mService.getActivityInfoForUser(aInfo, userId);

} catch (RemoteException e) {

aInfo = null;

}

int res = startActivityLocked(caller, intent, resolvedType,

aInfo, resultTo, resultWho, requestCode, callingPid, callingUid,

callingPackage, startFlags, options, componentSpecified, null);

if (stack.mConfigWillChange) {

// If the caller also wants to switch to a new configuration,

// do so now. This allows a clean switch, as we are waiting

// for the current activity to pause (so we will not destroy

// it), and have not yet started the next activity.

mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,

"updateConfiguration()");

stack.mConfigWillChange = false;

if (DEBUG_CONFIGURATION) Slog.v(TAG,

"Updating to new configuration after starting activity.");

mService.updateConfigurationLocked(config, null, false, false);

}

Binder.restoreCallingIdentity(origId);

if (outResult != null) {

outResult.result = res;

if (res == ActivityManager.START_SUCCESS) {

mWaitingActivityLaunched.add(outResult);

do {

try {

mService.wait();

} catch (InterruptedException e) {

}

} while (!outResult.timeout && outResult.who == null);

} else if (res == ActivityManager.START_TASK_TO_FRONT) {

ActivityRecord r = stack.topRunningActivityLocked(null);

if (r.nowVisible) {

outResult.timeout = false;

outResult.who = new ComponentName(r.info.packageName, r.info.name);

outResult.totalTime = 0;

outResult.thisTime = 0;

} else {

outResult.thisTime = SystemClock.uptimeMillis();

mWaitingActivityVisible.add(outResult);

do {

try {

mService.wait();

} catch (InterruptedException e) {

}

} while (!outResult.timeout && outResult.who == null);

}

return res;

}

mStackSupervisor.startActivityLocked函数

    final int startActivityLocked(IApplicationThread caller,
            Intent intent, String resolvedType, ActivityInfo aInfo, IBinder resultTo,
            String resultWho, int requestCode,
            int callingPid, int callingUid, String callingPackage, int startFlags, Bundle options,
            boolean componentSpecified, ActivityRecord[] outActivity) {
        int err = ActivityManager.START_SUCCESS;

        ProcessRecord callerApp = null;
        if (caller != null) {
            callerApp = mService.getRecordForAppLocked(caller);
            if (callerApp != null) {
                callingPid = callerApp.pid;
                callingUid = callerApp.info.uid;
            } else {
                Slog.w(TAG, "Unable to find app for caller " + caller
                      + " (pid=" + callingPid + ") when starting: "
                      + intent.toString());
                err = ActivityManager.START_PERMISSION_DENIED;
            }
        }

        if (err == ActivityManager.START_SUCCESS) {
            final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
            Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
                    + "} from pid " + (callerApp != null ? callerApp.pid : callingPid));
        }

        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {
            sourceRecord = isInAnyStackLocked(resultTo);
            if (DEBUG_RESULTS) Slog.v(
                TAG, "Will send result to " + resultTo + " " + sourceRecord);
            if (sourceRecord != null) {
                if (requestCode >= 0 && !sourceRecord.finishing) {
                    resultRecord = sourceRecord;
                }
            }
        }
        ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;

        int launchFlags = intent.getFlags();

        if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0
                && sourceRecord != null) {
            // Transfer the result target from the source activity to the new
            // one being started, including any failures.
            if (requestCode >= 0) {
                ActivityOptions.abort(options);
                return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
            }
            resultRecord = sourceRecord.resultTo;
            resultWho = sourceRecord.resultWho;
            requestCode = sourceRecord.requestCode;
            sourceRecord.resultTo = null;
            if (resultRecord != null) {
                resultRecord.removeResultsLocked(
                    sourceRecord, resultWho, requestCode);
            }
            if (sourceRecord.launchedFromUid == callingUid) {
                // The new activity is being launched from the same uid as the previous
                // activity in the flow, and asking to forward its result back to the
                // previous.  In this case the activity is serving as a trampoline between
                // the two, so we also want to update its launchedFromPackage to be the
                // same as the previous activity.  Note that this is safe, since we know
                // these two packages come from the same uid; the caller could just as
                // well have supplied that same package name itself.  This specifially
                // deals with the case of an intent picker/chooser being launched in the app
                // flow to redirect to an activity picked by the user, where we want the final
                // activity to consider it to have been launched by the previous app activity.
                callingPackage = sourceRecord.launchedFromPackage;
            }
        }

        if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
            // We couldn't find a class that can handle the given Intent.
            // That's the end of that!
            err = ActivityManager.START_INTENT_NOT_RESOLVED;
        }

        if (err == ActivityManager.START_SUCCESS && aInfo == null) {
            // We couldn't find the specific class specified in the Intent.
            // Also the end of the line.
            err = ActivityManager.START_CLASS_NOT_FOUND;
        }

        if (err != ActivityManager.START_SUCCESS) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1,
                    resultRecord, resultWho, requestCode,
                    Activity.RESULT_CANCELED, null);
            }
            setDismissKeyguard(false);
            ActivityOptions.abort(options);
            return err;
        }

        final int startAnyPerm = mService.checkPermission(
                START_ANY_ACTIVITY, callingPid, callingUid);
        final int componentPerm = mService.checkComponentPermission(aInfo.permission, callingPid,
                callingUid, aInfo.applicationInfo.uid, aInfo.exported);
        if (startAnyPerm != PERMISSION_GRANTED && componentPerm != PERMISSION_GRANTED) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1,
                    resultRecord, resultWho, requestCode,
                    Activity.RESULT_CANCELED, null);
            }
            setDismissKeyguard(false);
            String msg;
            if (!aInfo.exported) {
                msg = "Permission Denial: starting " + intent.toString()
                        + " from " + callerApp + " (pid=" + callingPid
                        + ", uid=" + callingUid + ")"
                        + " not exported from uid " + aInfo.applicationInfo.uid;
            } else {
                msg = "Permission Denial: starting " + intent.toString()
                        + " from " + callerApp + " (pid=" + callingPid
                        + ", uid=" + callingUid + ")"
                        + " requires " + aInfo.permission;
            }
            Slog.w(TAG, msg);
            throw new SecurityException(msg);
        }

        boolean abort = !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
                callingPid, resolvedType, aInfo.applicationInfo);

        if (mService.mController != null) {
            try {
                // The Intent we give to the watcher has the extra data
                // stripped off, since it can contain private information.
                Intent watchIntent = intent.cloneFilter();
                abort |= !mService.mController.activityStarting(watchIntent,
                        aInfo.applicationInfo.packageName);
            } catch (RemoteException e) {
                mService.mController = null;
            }
        }

        if (abort) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
                        Activity.RESULT_CANCELED, null);
            }
            // We pretend to the caller that it was really started, but
            // they will just get a cancel result.
            setDismissKeyguard(false);
            ActivityOptions.abort(options);
            return ActivityManager.START_SUCCESS;
        }

        ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                intent, resolvedType, aInfo, mService.mConfiguration,
                resultRecord, resultWho, requestCode, componentSpecified, this);
        if (outActivity != null) {
            outActivity[0] = r;
        }

        final ActivityStack stack = getFocusedStack();
        if (stack.mResumedActivity == null
                || stack.mResumedActivity.info.applicationInfo.uid != callingUid) {
            if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid, "Activity start")) {
                PendingActivityLaunch pal =
                        new PendingActivityLaunch(r, sourceRecord, startFlags, stack);
                mService.mPendingActivityLaunches.add(pal);
                setDismissKeyguard(false);
                ActivityOptions.abort(options);
                return ActivityManager.START_SWITCHES_CANCELED;
            }
        }

        if (mService.mDidAppSwitch) {
            // This is the second allowed switch since we stopped switches,
            // so now just generally allow switches.  Use case: user presses
            // home (switches disabled, switch to home, mDidAppSwitch now true);
            // user taps a home icon (coming from home so allowed, we hit here
            // and now allow anyone to switch again).
            mService.mAppSwitchesAllowedTime = 0;
        } else {
            mService.mDidAppSwitch = true;
        }

        mService.doPendingActivityLaunchesLocked(false);

        err = startActivityUncheckedLocked(r, sourceRecord, startFlags, true, options);

        if (allPausedActivitiesComplete()) {
            // If someone asked to have the keyguard dismissed on the next
            // activity start, but we are not actually doing an activity
            // switch...  just dismiss the keyguard now, because we
            // probably want to see whatever is behind it.
            dismissKeyguard();
        }
        return err;
    }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

final int startActivityLocked(IApplicationThread caller,

Intent intent, String resolvedType, ActivityInfo aInfo, IBinder resultTo,

String resultWho, int requestCode,

int callingPid, int callingUid, String callingPackage, int startFlags, Bundle options,

boolean componentSpecified, ActivityRecord[] outActivity) {

int err = ActivityManager.START_SUCCESS;

ProcessRecord callerApp = null;

if (caller != null) {

callerApp = mService.getRecordForAppLocked(caller);

if (callerApp != null) {

callingPid = callerApp.pid;

callingUid = callerApp.info.uid;

} else {

Slog.w(TAG, "Unable to find app for caller " + caller

+ " (pid=" + callingPid + ") when starting: "

+ intent.toString());

err = ActivityManager.START_PERMISSION_DENIED;

}

if (err == ActivityManager.START_SUCCESS) {

final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;

Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)

+ "} from pid " + (callerApp != null ? callerApp.pid : callingPid));

}

ActivityRecord sourceRecord = null;

ActivityRecord resultRecord = null;

if (resultTo != null) {

sourceRecord = isInAnyStackLocked(resultTo);

if (DEBUG_RESULTS) Slog.v(

TAG, "Will send result to " + resultTo + " " + sourceRecord);

if (sourceRecord != null) {

if (requestCode >= 0 && !sourceRecord.finishing) {

resultRecord = sourceRecord;

}

ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;

int launchFlags = intent.getFlags();

if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0

&& sourceRecord != null) {

// Transfer the result target from the source activity to the new

// one being started, including any failures.

if (requestCode >= 0) {

ActivityOptions.abort(options);

return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;

}

resultRecord = sourceRecord.resultTo;

resultWho = sourceRecord.resultWho;

requestCode = sourceRecord.requestCode;

sourceRecord.resultTo = null;

if (resultRecord != null) {

resultRecord.removeResultsLocked(

sourceRecord, resultWho, requestCode);

}

if (sourceRecord.launchedFromUid == callingUid) {

// The new activity is being launched from the same uid as the previous

// activity in the flow, and asking to forward its result back to the

// previous. In this case the activity is serving as a trampoline between

// the two, so we also want to update its launchedFromPackage to be the

// same as the previous activity. Note that this is safe, since we know

// these two packages come from the same uid; the caller could just as

// well have supplied that same package name itself. This specifially

// deals with the case of an intent picker/chooser being launched in the app

// flow to redirect to an activity picked by the user, where we want the final

// activity to consider it to have been launched by the previous app activity.

callingPackage = sourceRecord.launchedFromPackage;

}

if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {

// We couldn't find a class that can handle the given Intent.

// That's the end of that!

err = ActivityManager.START_INTENT_NOT_RESOLVED;

}

if (err == ActivityManager.START_SUCCESS && aInfo == null) {

// We couldn't find the specific class specified in the Intent.

// Also the end of the line.

err = ActivityManager.START_CLASS_NOT_FOUND;

}

if (err != ActivityManager.START_SUCCESS) {

if (resultRecord != null) {

resultStack.sendActivityResultLocked(-1,

resultRecord, resultWho, requestCode,

Activity.RESULT_CANCELED, null);

}

setDismissKeyguard(false);

ActivityOptions.abort(options);

return err;

}

final int startAnyPerm = mService.checkPermission(

START_ANY_ACTIVITY, callingPid, callingUid);

final int componentPerm = mService.checkComponentPermission(aInfo.permission, callingPid,

callingUid, aInfo.applicationInfo.uid, aInfo.exported);

if (startAnyPerm != PERMISSION_GRANTED && componentPerm != PERMISSION_GRANTED) {

if (resultRecord != null) {

resultStack.sendActivityResultLocked(-1,

resultRecord, resultWho, requestCode,

Activity.RESULT_CANCELED, null);

}

setDismissKeyguard(false);

String msg;

if (!aInfo.exported) {

msg = "Permission Denial: starting " + intent.toString()

+ " from " + callerApp + " (pid=" + callingPid

+ ", uid=" + callingUid + ")"

+ " not exported from uid " + aInfo.applicationInfo.uid;

} else {

msg = "Permission Denial: starting " + intent.toString()

+ " from " + callerApp + " (pid=" + callingPid

+ ", uid=" + callingUid + ")"

+ " requires " + aInfo.permission;

}

Slog.w(TAG, msg);

throw new SecurityException(msg);

}

boolean abort = !mService.mIntentFirewall.checkStartActivity(intent, callingUid,

callingPid, resolvedType, aInfo.applicationInfo);

if (mService.mController != null) {

try {

// The Intent we give to the watcher has the extra data

// stripped off, since it can contain private information.

Intent watchIntent = intent.cloneFilter();

abort |= !mService.mController.activityStarting(watchIntent,

aInfo.applicationInfo.packageName);

} catch (RemoteException e) {

mService.mController = null;

}

if (abort) {

if (resultRecord != null) {

resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,

Activity.RESULT_CANCELED, null);

}

// We pretend to the caller that it was really started, but

// they will just get a cancel result.

setDismissKeyguard(false);

ActivityOptions.abort(options);

return ActivityManager.START_SUCCESS;

}

ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,

intent, resolvedType, aInfo, mService.mConfiguration,

resultRecord, resultWho, requestCode, componentSpecified, this);

if (outActivity != null) {

outActivity[0] = r;

}

final ActivityStack stack = getFocusedStack();

if (stack.mResumedActivity == null

|| stack.mResumedActivity.info.applicationInfo.uid != callingUid) {

if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid, "Activity start")) {

PendingActivityLaunch pal =

new PendingActivityLaunch(r, sourceRecord, startFlags, stack);

mService.mPendingActivityLaunches.add(pal);

setDismissKeyguard(false);

ActivityOptions.abort(options);

return ActivityManager.START_SWITCHES_CANCELED;

}

if (mService.mDidAppSwitch) {

// This is the second allowed switch since we stopped switches,

// so now just generally allow switches. Use case: user presses

// home (switches disabled, switch to home, mDidAppSwitch now true);

// user taps a home icon (coming from home so allowed, we hit here

// and now allow anyone to switch again).

mService.mAppSwitchesAllowedTime = 0;

} else {

mService.mDidAppSwitch = true;

}

mService.doPendingActivityLaunchesLocked(false);

err = startActivityUncheckedLocked(r, sourceRecord, startFlags, true, options);

if (allPausedActivitiesComplete()) {

// If someone asked to have the keyguard dismissed on the next

// activity start, but we are not actually doing an activity

// switch... just dismiss the keyguard now, because we

// probably want to see whatever is behind it.

dismissKeyguard();

}

return err;

}

调用函数mStackSupervisor.startActivityUncheckedLocked

调用函数ActiviyManagerService.checkGrantUriPermissionFromIntentLocked

调用函数ActivityStack.startActivityLocked

调用WindowManagerService.prepareAppTransition

调用函数ActivityStack.resumeTopActivityLocked

调用函数ActivityStack.startPausingLocked 开始pause当前Activity

调用函数ActivityManagerService.updateUsageStats 更新电池电量统计

调用函数mStackSupervisor.setFocusedStack

    void setFocusedStack(ActivityRecord r) {
        if (r == null) {
            return;
        }
        if (!r.isApplicationActivity() || (r.task != null && !r.task.isApplicationTask())) {
            if (mStackState != STACK_STATE_HOME_IN_FRONT) {
                if (DEBUG_STACK || DEBUG_FOCUS) Slog.d(TAG, "setFocusedStack: mStackState old=" +
                        stackStateToString(mStackState) + " new=" +
                        stackStateToString(STACK_STATE_HOME_TO_FRONT) +
                        " Callers=" + Debug.getCallers(3));
                mStackState = STACK_STATE_HOME_TO_FRONT;
            }
        } else {
            if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG,
                    "setFocusedStack: Setting focused stack to r=" + r + " task=" + r.task +
                    " Callers=" + Debug.getCallers(3));
            final ActivityStack taskStack = r.task.stack;
            mFocusedStack = taskStack.isHomeStack() ? null : taskStack;
            if (mStackState != STACK_STATE_HOME_IN_BACK) {
                if (DEBUG_STACK) Slog.d(TAG, "setFocusedStack: mStackState old=" +
                        stackStateToString(mStackState) + " new=" +
                        stackStateToString(STACK_STATE_HOME_TO_BACK) +
                        " Callers=" + Debug.getCallers(3));
                mStackState = STACK_STATE_HOME_TO_BACK;
            }
        }
    }

void setFocusedStack(ActivityRecord r) {

if (r == null) {

return;

}

if (!r.isApplicationActivity() || (r.task != null && !r.task.isApplicationTask())) {

if (mStackState != STACK_STATE_HOME_IN_FRONT) {

if (DEBUG_STACK || DEBUG_FOCUS) Slog.d(TAG, "setFocusedStack: mStackState old=" +

stackStateToString(mStackState) + " new=" +

stackStateToString(STACK_STATE_HOME_TO_FRONT) +

" Callers=" + Debug.getCallers(3));

mStackState = STACK_STATE_HOME_TO_FRONT;

}

} else {

if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG,

"setFocusedStack: Setting focused stack to r=" + r + " task=" + r.task +

" Callers=" + Debug.getCallers(3));

final ActivityStack taskStack = r.task.stack;

mFocusedStack = taskStack.isHomeStack() ? null : taskStack;

if (mStackState != STACK_STATE_HOME_IN_BACK) {

if (DEBUG_STACK) Slog.d(TAG, "setFocusedStack: mStackState old=" +

stackStateToString(mStackState) + " new=" +

stackStateToString(STACK_STATE_HOME_TO_BACK) +

" Callers=" + Debug.getCallers(3));

mStackState = STACK_STATE_HOME_TO_BACK;

}

调用WindowManagerService.findFocusedWindowLocked

调用函数WindowManagerService.updateFocusedWindowLocked

调用函数：mStackSupervisor.allPausedActivitiesComplete

打赏

Leave a Reply Cancel reply