/* * Copyright (C) 2017 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License */ package com.android.server.wm; import static android.app.ActivityManager.START_SUCCESS; import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME; import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; import static android.os.FactoryTest.FACTORY_TEST_LOW_LEVEL; import static com.android.server.wm.ActivityStackSupervisor.ON_TOP; import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM; import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME; import android.annotation.Nullable; import android.app.ActivityOptions; import android.app.IApplicationThread; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Intent; import android.content.pm.ActivityInfo; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.os.Binder; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.UserHandle; import android.provider.Settings; import android.util.Slog; import android.util.SparseArray; import android.util.proto.ProtoOutputStream; import android.view.RemoteAnimationAdapter; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.ArrayUtils; import com.android.server.am.ActivityManagerService; import com.android.server.am.PendingIntentRecord; import com.android.server.uri.NeededUriGrants; import com.android.server.wm.ActivityStackSupervisor.PendingActivityLaunch; import com.android.server.wm.ActivityStarter.DefaultFactory; import com.android.server.wm.ActivityStarter.Factory; import java.io.PrintWriter; import java.util.ArrayList; import java.util.List; /** * Controller for delegating activity launches. * * This class' main objective is to take external activity start requests and prepare them into * a series of discrete activity launches that can be handled by an {@link ActivityStarter}. It is * also responsible for handling logic that happens around an activity launch, but doesn't * necessarily influence the activity start. Examples include power hint management, processing * through the pending activity list, and recording home activity launches. */ public class ActivityStartController { private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStartController" : TAG_ATM; private static final int DO_PENDING_ACTIVITY_LAUNCHES_MSG = 1; private final ActivityTaskManagerService mService; private final ActivityStackSupervisor mSupervisor; /** Last home activity record we attempted to start. */ private ActivityRecord mLastHomeActivityStartRecord; /** Temporary array to capture start activity results */ private ActivityRecord[] tmpOutRecord = new ActivityRecord[1]; /** The result of the last home activity we attempted to start. */ private int mLastHomeActivityStartResult; /** A list of activities that are waiting to launch. */ private final ArrayList mPendingActivityLaunches = new ArrayList<>(); private final Factory mFactory; private final Handler mHandler; private final PendingRemoteAnimationRegistry mPendingRemoteAnimationRegistry; boolean mCheckedForSetup = false; private final class StartHandler extends Handler { public StartHandler(Looper looper) { super(looper, null, true); } @Override public void handleMessage(Message msg) { switch(msg.what) { case DO_PENDING_ACTIVITY_LAUNCHES_MSG: synchronized (mService.mGlobalLock) { doPendingActivityLaunches(true); } break; } } } /** * TODO(b/64750076): Capture information necessary for dump and * {@link #postStartActivityProcessingForLastStarter} rather than keeping the entire object * around */ private ActivityStarter mLastStarter; ActivityStartController(ActivityTaskManagerService service) { this(service, service.mStackSupervisor, new DefaultFactory(service, service.mStackSupervisor, new ActivityStartInterceptor(service, service.mStackSupervisor))); } @VisibleForTesting ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor, Factory factory) { mService = service; mSupervisor = supervisor; mHandler = new StartHandler(mService.mH.getLooper()); mFactory = factory; mFactory.setController(this); mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service.mGlobalLock, service.mH); } /** * @return A starter to configure and execute starting an activity. It is valid until after * {@link ActivityStarter#execute} is invoked. At that point, the starter should be * considered invalid and no longer modified or used. */ ActivityStarter obtainStarter(Intent intent, String reason) { return mFactory.obtain().setIntent(intent).setReason(reason); } void onExecutionComplete(ActivityStarter starter) { if (mLastStarter == null) { mLastStarter = mFactory.obtain(); } mLastStarter.set(starter); mFactory.recycle(starter); } /** * TODO(b/64750076): usage of this doesn't seem right. We're making decisions based off the * last starter for an arbitrary task record. Re-evaluate whether we can remove. */ void postStartActivityProcessingForLastStarter(ActivityRecord r, int result, ActivityStack targetStack) { if (mLastStarter == null) { return; } mLastStarter.postStartActivityProcessing(r, result, targetStack); } void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason, TaskDisplayArea taskDisplayArea) { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN); if (!ActivityRecord.isResolverActivity(aInfo.name)) { // The resolver activity shouldn't be put in home stack because when the foreground is // standard type activity, the resolver activity should be put on the top of current // foreground instead of bring home stack to front. options.setLaunchActivityType(ACTIVITY_TYPE_HOME); } final int displayId = taskDisplayArea.getDisplayId(); options.setLaunchDisplayId(displayId); options.setLaunchTaskDisplayArea(taskDisplayArea.mRemoteToken .toWindowContainerToken()); // The home activity will be started later, defer resuming to avoid unneccerary operations // (e.g. start home recursively) when creating home stack. mSupervisor.beginDeferResume(); final ActivityStack homeStack; try { // Make sure home stack exists on display area. homeStack = taskDisplayArea.getOrCreateRootHomeTask(ON_TOP); } finally { mSupervisor.endDeferResume(); } mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason) .setOutActivity(tmpOutRecord) .setCallingUid(0) .setActivityInfo(aInfo) .setActivityOptions(options.toBundle()) .execute(); mLastHomeActivityStartRecord = tmpOutRecord[0]; if (homeStack.mInResumeTopActivity) { // If we are in resume section already, home activity will be initialized, but not // resumed (to avoid recursive resume) and will stay that way until something pokes it // again. We need to schedule another resume. mSupervisor.scheduleResumeTopActivities(); } } /** * Starts the "new version setup screen" if appropriate. */ void startSetupActivity() { // Only do this once per boot. if (mCheckedForSetup) { return; } // We will show this screen if the current one is a different // version than the last one shown, and we are not running in // low-level factory test mode. final ContentResolver resolver = mService.mContext.getContentResolver(); if (mService.mFactoryTest != FACTORY_TEST_LOW_LEVEL && Settings.Global.getInt(resolver, Settings.Global.DEVICE_PROVISIONED, 0) != 0) { mCheckedForSetup = true; // See if we should be showing the platform update setup UI. final Intent intent = new Intent(Intent.ACTION_UPGRADE_SETUP); final List ris = mService.mContext.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_SYSTEM_ONLY | PackageManager.GET_META_DATA | ActivityManagerService.STOCK_PM_FLAGS); if (!ris.isEmpty()) { final ResolveInfo ri = ris.get(0); String vers = ri.activityInfo.metaData != null ? ri.activityInfo.metaData.getString(Intent.METADATA_SETUP_VERSION) : null; if (vers == null && ri.activityInfo.applicationInfo.metaData != null) { vers = ri.activityInfo.applicationInfo.metaData.getString( Intent.METADATA_SETUP_VERSION); } String lastVers = Settings.Secure.getString( resolver, Settings.Secure.LAST_SETUP_SHOWN); if (vers != null && !vers.equals(lastVers)) { intent.setFlags(FLAG_ACTIVITY_NEW_TASK); intent.setComponent(new ComponentName( ri.activityInfo.packageName, ri.activityInfo.name)); obtainStarter(intent, "startSetupActivity") .setCallingUid(0) .setActivityInfo(ri.activityInfo) .execute(); } } } } /** * If {@code validateIncomingUser} is true, check {@code targetUserId} against the real calling * user ID inferred from {@code realCallingUid}, then return the resolved user-id, taking into * account "current user", etc. * * If {@code validateIncomingUser} is false, it skips the above check, but instead * ensures {@code targetUserId} is a real user ID and not a special user ID such as * {@link android.os.UserHandle#USER_ALL}, etc. */ int checkTargetUser(int targetUserId, boolean validateIncomingUser, int realCallingPid, int realCallingUid, String reason) { if (validateIncomingUser) { return mService.handleIncomingUser( realCallingPid, realCallingUid, targetUserId, reason); } else { mService.mAmInternal.ensureNotSpecialUser(targetUserId); return targetUserId; } } final int startActivityInPackage(int uid, int realCallingPid, int realCallingUid, String callingPackage, @Nullable String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, SafeActivityOptions options, int userId, Task inTask, String reason, boolean validateIncomingUser, PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) { userId = checkTargetUser(userId, validateIncomingUser, realCallingPid, realCallingUid, reason); // TODO: Switch to user app stacks here. return obtainStarter(intent, reason) .setCallingUid(uid) .setRealCallingPid(realCallingPid) .setRealCallingUid(realCallingUid) .setCallingPackage(callingPackage) .setCallingFeatureId(callingFeatureId) .setResolvedType(resolvedType) .setResultTo(resultTo) .setResultWho(resultWho) .setRequestCode(requestCode) .setStartFlags(startFlags) .setActivityOptions(options) .setUserId(userId) .setInTask(inTask) .setOriginatingPendingIntent(originatingPendingIntent) .setAllowBackgroundActivityStart(allowBackgroundActivityStart) .execute(); } /** * Start intents as a package. * * @param uid Make a call as if this UID did. * @param callingPackage Make a call as if this package did. * @param callingFeatureId Make a call as if this feature in the package did. * @param intents Intents to start. * @param userId Start the intents on this user. * @param validateIncomingUser Set true to skip checking {@code userId} with the calling UID. * @param originatingPendingIntent PendingIntentRecord that originated this activity start or * null if not originated by PendingIntent */ final int startActivitiesInPackage(int uid, String callingPackage, @Nullable String callingFeatureId, Intent[] intents, String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options, int userId, boolean validateIncomingUser, PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) { return startActivitiesInPackage(uid, 0 /* realCallingPid */, -1 /* realCallingUid */, callingPackage, callingFeatureId, intents, resolvedTypes, resultTo, options, userId, validateIncomingUser, originatingPendingIntent, allowBackgroundActivityStart); } /** * Start intents as a package. * * @param uid Make a call as if this UID did. * @param realCallingPid PID of the real caller. * @param realCallingUid UID of the real caller. * @param callingPackage Make a call as if this package did. * @param intents Intents to start. * @param userId Start the intents on this user. * @param validateIncomingUser Set true to skip checking {@code userId} with the calling UID. * @param originatingPendingIntent PendingIntentRecord that originated this activity start or * null if not originated by PendingIntent */ final int startActivitiesInPackage(int uid, int realCallingPid, int realCallingUid, String callingPackage, @Nullable String callingFeatureId, Intent[] intents, String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options, int userId, boolean validateIncomingUser, PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) { final String reason = "startActivityInPackage"; userId = checkTargetUser(userId, validateIncomingUser, Binder.getCallingPid(), Binder.getCallingUid(), reason); // TODO: Switch to user app stacks here. return startActivities(null, uid, realCallingPid, realCallingUid, callingPackage, callingFeatureId, intents, resolvedTypes, resultTo, options, userId, reason, originatingPendingIntent, allowBackgroundActivityStart); } int startActivities(IApplicationThread caller, int callingUid, int incomingRealCallingPid, int incomingRealCallingUid, String callingPackage, @Nullable String callingFeatureId, Intent[] intents, String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options, int userId, String reason, PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) { if (intents == null) { throw new NullPointerException("intents is null"); } if (resolvedTypes == null) { throw new NullPointerException("resolvedTypes is null"); } if (intents.length != resolvedTypes.length) { throw new IllegalArgumentException("intents are length different than resolvedTypes"); } final int realCallingPid = incomingRealCallingPid != 0 ? incomingRealCallingPid : Binder.getCallingPid(); final int realCallingUid = incomingRealCallingUid != -1 ? incomingRealCallingUid : Binder.getCallingUid(); int callingPid; if (callingUid >= 0) { callingPid = -1; } else if (caller == null) { callingPid = realCallingPid; callingUid = realCallingUid; } else { callingPid = callingUid = -1; } final int filterCallingUid = ActivityStarter.computeResolveFilterUid( callingUid, realCallingUid, UserHandle.USER_NULL); final SparseArray startingUidPkgs = new SparseArray<>(); final long origId = Binder.clearCallingIdentity(); try { intents = ArrayUtils.filterNotNull(intents, Intent[]::new); final ActivityStarter[] starters = new ActivityStarter[intents.length]; // Do not hold WM global lock on this loop because when resolving intent, it may // potentially acquire activity manager lock that leads to deadlock. for (int i = 0; i < intents.length; i++) { Intent intent = intents[i]; NeededUriGrants intentGrants = null; // Refuse possible leaked file descriptors. if (intent.hasFileDescriptors()) { throw new IllegalArgumentException("File descriptors passed in Intent"); } // Get the flag earlier because the intent may be modified in resolveActivity below. final 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 = mSupervisor.resolveActivity(intent, resolvedTypes[i], 0 /* startFlags */, null /* profilerInfo */, userId, filterCallingUid); aInfo = mService.mAmInternal.getActivityInfoForUser(aInfo, userId); // Carefully collect grants without holding lock if (aInfo != null) { intentGrants = mSupervisor.mService.mUgmInternal .checkGrantUriPermissionFromIntent(intent, filterCallingUid, aInfo.applicationInfo.packageName, UserHandle.getUserId(aInfo.applicationInfo.uid)); } if (aInfo != null) { if ((aInfo.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) { throw new IllegalArgumentException( "FLAG_CANT_SAVE_STATE not supported here"); } startingUidPkgs.put(aInfo.applicationInfo.uid, aInfo.applicationInfo.packageName); } final boolean top = i == intents.length - 1; final SafeActivityOptions checkedOptions = top ? options : null; starters[i] = obtainStarter(intent, reason) .setIntentGrants(intentGrants) .setCaller(caller) .setResolvedType(resolvedTypes[i]) .setActivityInfo(aInfo) .setRequestCode(-1) .setCallingPid(callingPid) .setCallingUid(callingUid) .setCallingPackage(callingPackage) .setCallingFeatureId(callingFeatureId) .setRealCallingPid(realCallingPid) .setRealCallingUid(realCallingUid) .setActivityOptions(checkedOptions) .setComponentSpecified(componentSpecified) // Top activity decides on animation being run, so we allow only for the // top one as otherwise an activity below might consume it. .setAllowPendingRemoteAnimationRegistryLookup(top /* allowLookup*/) .setOriginatingPendingIntent(originatingPendingIntent) .setAllowBackgroundActivityStart(allowBackgroundActivityStart); } // Log if the activities to be started have different uids. if (startingUidPkgs.size() > 1) { final StringBuilder sb = new StringBuilder("startActivities: different apps ["); final int size = startingUidPkgs.size(); for (int i = 0; i < size; i++) { sb.append(startingUidPkgs.valueAt(i)).append(i == size - 1 ? "]" : ", "); } sb.append(" from ").append(callingPackage); Slog.wtf(TAG, sb.toString()); } final IBinder sourceResultTo = resultTo; final ActivityRecord[] outActivity = new ActivityRecord[1]; // Lock the loop to ensure the activities launched in a sequence. synchronized (mService.mGlobalLock) { mService.deferWindowLayout(); try { for (int i = 0; i < starters.length; i++) { final int startResult = starters[i].setResultTo(resultTo) .setOutActivity(outActivity).execute(); if (startResult < START_SUCCESS) { // Abort by error result and recycle unused starters. for (int j = i + 1; j < starters.length; j++) { mFactory.recycle(starters[j]); } return startResult; } final ActivityRecord started = outActivity[0]; if (started != null && started.getUid() == filterCallingUid) { // Only the started activity which has the same uid as the source caller // can be the caller of next activity. resultTo = started.appToken; } else { resultTo = sourceResultTo; // Different apps not adjacent to the caller are forced to be new task. if (i < starters.length - 1) { starters[i + 1].getIntent().addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); } } } } finally { mService.continueWindowLayout(); } } } finally { Binder.restoreCallingIdentity(origId); } return START_SUCCESS; } void schedulePendingActivityLaunches(long delayMs) { mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG); Message msg = mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG); mHandler.sendMessageDelayed(msg, delayMs); } void doPendingActivityLaunches(boolean doResume) { while (!mPendingActivityLaunches.isEmpty()) { final PendingActivityLaunch pal = mPendingActivityLaunches.remove(0); final boolean resume = doResume && mPendingActivityLaunches.isEmpty(); final ActivityStarter starter = obtainStarter(null /* intent */, "pendingActivityLaunch"); try { starter.startResolvedActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags, resume, pal.r.pendingOptions, null, pal.intentGrants); } catch (Exception e) { Slog.e(TAG, "Exception during pending activity launch pal=" + pal, e); pal.sendErrorResult(e.getMessage()); } } } void addPendingActivityLaunch(PendingActivityLaunch launch) { mPendingActivityLaunches.add(launch); } boolean clearPendingActivityLaunches(String packageName) { final int pendingLaunches = mPendingActivityLaunches.size(); for (int palNdx = pendingLaunches - 1; palNdx >= 0; --palNdx) { final PendingActivityLaunch pal = mPendingActivityLaunches.get(palNdx); final ActivityRecord r = pal.r; if (r != null && r.packageName.equals(packageName)) { mPendingActivityLaunches.remove(palNdx); } } return mPendingActivityLaunches.size() < pendingLaunches; } void registerRemoteAnimationForNextActivityStart(String packageName, RemoteAnimationAdapter adapter) { mPendingRemoteAnimationRegistry.addPendingAnimation(packageName, adapter); } PendingRemoteAnimationRegistry getPendingRemoteAnimationRegistry() { return mPendingRemoteAnimationRegistry; } void dumpLastHomeActivityStartResult(PrintWriter pw, String prefix) { pw.print(prefix); pw.print("mLastHomeActivityStartResult="); pw.println(mLastHomeActivityStartResult); } void dump(PrintWriter pw, String prefix, String dumpPackage) { boolean dumped = false; final boolean dumpPackagePresent = dumpPackage != null; if (mLastHomeActivityStartRecord != null && (!dumpPackagePresent || dumpPackage.equals(mLastHomeActivityStartRecord.packageName))) { if (!dumped) { dumped = true; dumpLastHomeActivityStartResult(pw, prefix); } pw.print(prefix); pw.println("mLastHomeActivityStartRecord:"); mLastHomeActivityStartRecord.dump(pw, prefix + " ", true /* dumpAll */); } if (mLastStarter != null) { final boolean dump = !dumpPackagePresent || mLastStarter.relatedToPackage(dumpPackage) || (mLastHomeActivityStartRecord != null && dumpPackage.equals(mLastHomeActivityStartRecord.packageName)); if (dump) { if (!dumped) { dumped = true; dumpLastHomeActivityStartResult(pw, prefix); } pw.print(prefix); mLastStarter.dump(pw, prefix + " "); if (dumpPackagePresent) { return; } } } if (!dumped) { pw.print(prefix); pw.println("(nothing)"); } } public void dumpDebug(ProtoOutputStream proto, long fieldId) { for (PendingActivityLaunch activity: mPendingActivityLaunches) { activity.r.writeIdentifierToProto(proto, fieldId); } } }