services/core/java/com/android/server/am/ActivityRecord.java

   1 /*
   2  * Copyright (C) 2006 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.am;
  18
  19 import static android.app.ActivityManager.StackId;
  20 import static android.app.ActivityManager.StackId.FREEFORM_WORKSPACE_STACK_ID;
  21 import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
  22 import static android.content.pm.ActivityInfo.RESIZE_MODE_CROP_WINDOWS;
  23 import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;
  24 import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;
  25 import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE_AND_PIPABLE;
  26 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_CONFIGURATION;
  27 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SWITCH;
  28 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_THUMBNAILS;
  29 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_STATES;
  30 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SWITCH;
  31 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_THUMBNAILS;
  32 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
  33 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
  34 import static com.android.server.am.TaskRecord.INVALID_TASK_ID;
  35
  36 import android.app.ActivityManager.TaskDescription;
  37 import android.app.ActivityOptions;
  38 import android.app.PendingIntent;
  39 import android.app.ResultInfo;
  40 import android.content.ComponentName;
  41 import android.content.Intent;
  42 import android.content.pm.ActivityInfo;
  43 import android.content.pm.ApplicationInfo;
  44 import android.content.res.CompatibilityInfo;
  45 import android.content.res.Configuration;
  46 import android.graphics.Bitmap;
  47 import android.graphics.Rect;
  48 import android.os.Build;
  49 import android.os.Bundle;
  50 import android.os.IBinder;
  51 import android.os.Message;
  52 import android.os.PersistableBundle;
  53 import android.os.Process;
  54 import android.os.RemoteException;
  55 import android.os.SystemClock;
  56 import android.os.Trace;
  57 import android.os.UserHandle;
  58 import android.service.voice.IVoiceInteractionSession;
  59 import android.util.EventLog;
  60 import android.util.Log;
  61 import android.util.Slog;
  62 import android.util.TimeUtils;
  63 import android.view.AppTransitionAnimationSpec;
  64 import android.view.IApplicationToken;
  65 import android.view.WindowManager;
  66
  67 import com.android.internal.app.ResolverActivity;
  68 import com.android.internal.content.ReferrerIntent;
  69 import com.android.internal.util.XmlUtils;
  70 import com.android.server.AttributeCache;
  71 import com.android.server.am.ActivityStack.ActivityState;
  72 import com.android.server.am.ActivityStackSupervisor.ActivityContainer;
  73
  74 import java.io.File;
  75 import java.io.IOException;
  76 import java.io.PrintWriter;
  77 import java.lang.ref.WeakReference;
  78 import java.util.ArrayList;
  79 import java.util.Arrays;
  80 import java.util.HashSet;
  81 import java.util.Objects;
  82
  83 import org.xmlpull.v1.XmlPullParser;
  84 import org.xmlpull.v1.XmlPullParserException;
  85 import org.xmlpull.v1.XmlSerializer;
  86
  87 /**
  88  * An entry in the history stack, representing an activity.
  89  */
  90 final class ActivityRecord {
  91     private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityRecord" : TAG_AM;
  92     private static final String TAG_STATES = TAG + POSTFIX_STATES;
  93     private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
  94     private static final String TAG_THUMBNAILS = TAG + POSTFIX_THUMBNAILS;
  95
  96     private static final boolean SHOW_ACTIVITY_START_TIME = true;
  97     final public static String RECENTS_PACKAGE_NAME = "com.android.systemui.recents";
  98
  99     private static final String ATTR_ID = "id";
 100     private static final String TAG_INTENT = "intent";
 101     private static final String ATTR_USERID = "user_id";
 102     private static final String TAG_PERSISTABLEBUNDLE = "persistable_bundle";
 103     private static final String ATTR_LAUNCHEDFROMUID = "launched_from_uid";
 104     private static final String ATTR_LAUNCHEDFROMPACKAGE = "launched_from_package";
 105     private static final String ATTR_RESOLVEDTYPE = "resolved_type";
 106     private static final String ATTR_COMPONENTSPECIFIED = "component_specified";
 107     static final String ACTIVITY_ICON_SUFFIX = "_activity_icon_";
 108
 109     final ActivityManagerService service; // owner
 110     final IApplicationToken.Stub appToken; // window manager token
 111     final ActivityInfo info; // all about me
 112     final ApplicationInfo appInfo; // information about activity's app
 113     final int launchedFromUid; // always the uid who started the activity.
 114     final String launchedFromPackage; // always the package who started the activity.
 115     final int userId;          // Which user is this running for?
 116     final Intent intent;    // the original intent that generated us
 117     final ComponentName realActivity;  // the intent component, or target of an alias.
 118     final String shortComponentName; // the short component name of the intent
 119     final String resolvedType; // as per original caller;
 120     final String packageName; // the package implementing intent's component
 121     final String processName; // process where this component wants to run
 122     final String taskAffinity; // as per ActivityInfo.taskAffinity
 123     final boolean stateNotNeeded; // As per ActivityInfo.flags
 124     boolean fullscreen; // covers the full screen?
 125     final boolean noDisplay;  // activity is not displayed?
 126     final boolean componentSpecified;  // did caller specify an explicit component?
 127     final boolean rootVoiceInteraction;  // was this the root activity of a voice interaction?
 128
 129     static final int APPLICATION_ACTIVITY_TYPE = 0;
 130     static final int HOME_ACTIVITY_TYPE = 1;
 131     static final int RECENTS_ACTIVITY_TYPE = 2;
 132     int mActivityType;
 133
 134     CharSequence nonLocalizedLabel;  // the label information from the package mgr.
 135     int labelRes;           // the label information from the package mgr.
 136     int icon;               // resource identifier of activity's icon.
 137     int logo;               // resource identifier of activity's logo.
 138     int theme;              // resource identifier of activity's theme.
 139     int realTheme;          // actual theme resource we will use, never 0.
 140     int windowFlags;        // custom window flags for preview window.
 141     TaskRecord task;        // the task this is in.
 142     long createTime = System.currentTimeMillis();
 143     long displayStartTime;  // when we started launching this activity
 144     long fullyDrawnStartTime; // when we started launching this activity
 145     long startTime;         // last time this activity was started
 146     long lastVisibleTime;   // last time this activity became visible
 147     long cpuTimeAtResume;   // the cpu time of host process at the time of resuming activity
 148     long pauseTime;         // last time we started pausing the activity
 149     long launchTickTime;    // base time for launch tick messages
 150     Configuration configuration; // configuration activity was last running in
 151     // Overridden configuration by the activity task
 152     // WARNING: Reference points to {@link TaskRecord#mOverrideConfig}, so its internal state
 153     // should never be altered directly.
 154     Configuration taskConfigOverride;
 155     CompatibilityInfo compat;// last used compatibility mode
 156     ActivityRecord resultTo; // who started this entry, so will get our reply
 157     final String resultWho; // additional identifier for use by resultTo.
 158     final int requestCode;  // code given by requester (resultTo)
 159     ArrayList<ResultInfo> results; // pending ActivityResult objs we have received
 160     HashSet<WeakReference<PendingIntentRecord>> pendingResults; // all pending intents for this act
 161     ArrayList<ReferrerIntent> newIntents; // any pending new intents for single-top mode
 162     ActivityOptions pendingOptions; // most recently given options
 163     ActivityOptions returningOptions; // options that are coming back via convertToTranslucent
 164     AppTimeTracker appTimeTracker; // set if we are tracking the time in this app/task/activity
 165     HashSet<ConnectionRecord> connections; // All ConnectionRecord we hold
 166     UriPermissionOwner uriPermissions; // current special URI access perms.
 167     ProcessRecord app;      // if non-null, hosting application
 168     ActivityState state;    // current state we are in
 169     Bundle  icicle;         // last saved activity state
 170     PersistableBundle persistentState; // last persistently saved activity state
 171     boolean frontOfTask;    // is this the root activity of its task?
 172     boolean launchFailed;   // set if a launched failed, to abort on 2nd try
 173     boolean haveState;      // have we gotten the last activity state?
 174     boolean stopped;        // is activity pause finished?
 175     boolean delayedResume;  // not yet resumed because of stopped app switches?
 176     boolean finishing;      // activity in pending finish list?
 177     boolean deferRelaunchUntilPaused;   // relaunch of activity is being deferred until pause is
 178                                         // completed
 179     boolean preserveWindowOnDeferredRelaunch; // activity windows are preserved on deferred relaunch
 180     int configChangeFlags;  // which config values have changed
 181     boolean keysPaused;     // has key dispatching been paused for it?
 182     int launchMode;         // the launch mode activity attribute.
 183     boolean visible;        // does this activity's window need to be shown?
 184     boolean sleeping;       // have we told the activity to sleep?
 185     boolean nowVisible;     // is this activity's window visible?
 186     boolean idle;           // has the activity gone idle?
 187     boolean hasBeenLaunched;// has this activity ever been launched?
 188     boolean frozenBeforeDestroy;// has been frozen but not yet destroyed.
 189     boolean immersive;      // immersive mode (don't interrupt if possible)
 190     boolean forceNewConfig; // force re-create with new config next time
 191     int launchCount;        // count of launches since last state
 192     long lastLaunchTime;    // time of last launch of this activity
 193     ComponentName requestedVrComponent; // the requested component for handling VR mode.
 194     ArrayList<ActivityContainer> mChildContainers = new ArrayList<>();
 195
 196     String stringName;      // for caching of toString().
 197
 198     private boolean inHistory;  // are we in the history stack?
 199     final ActivityStackSupervisor mStackSupervisor;
 200
 201     static final int STARTING_WINDOW_NOT_SHOWN = 0;
 202     static final int STARTING_WINDOW_SHOWN = 1;
 203     static final int STARTING_WINDOW_REMOVED = 2;
 204     int mStartingWindowState = STARTING_WINDOW_NOT_SHOWN;
 205     boolean mTaskOverlay = false; // Task is always on-top of other activities in the task.
 206
 207     boolean mUpdateTaskThumbnailWhenHidden;
 208     ActivityContainer mInitialActivityContainer;
 209
 210     TaskDescription taskDescription; // the recents information for this activity
 211     boolean mLaunchTaskBehind; // this activity is actively being launched with
 212         // ActivityOptions.setLaunchTaskBehind, will be cleared once launch is completed.
 213
 214     // These configurations are collected from application's resources based on size-sensitive
 215     // qualifiers. For example, layout-w800dp will be added to mHorizontalSizeConfigurations as 800
 216     // and drawable-sw400dp will be added to both as 400.
 217     private int[] mVerticalSizeConfigurations;
 218     private int[] mHorizontalSizeConfigurations;
 219     private int[] mSmallestSizeConfigurations;
 220
 221     boolean pendingVoiceInteractionStart;   // Waiting for activity-invoked voice session
 222     IVoiceInteractionSession voiceSession;  // Voice interaction session for this activity
 223
 224     // A hint to override the window specified rotation animation, or -1
 225     // to use the window specified value. We use this so that
 226     // we can select the right animation in the cases of starting
 227     // windows, where the app hasn't had time to set a value
 228     // on the window.
 229     int mRotationAnimationHint = -1;
 230
 231     private static String startingWindowStateToString(int state) {
 232         switch (state) {
 233             case STARTING_WINDOW_NOT_SHOWN:
 234                 return "STARTING_WINDOW_NOT_SHOWN";
 235             case STARTING_WINDOW_SHOWN:
 236                 return "STARTING_WINDOW_SHOWN";
 237             case STARTING_WINDOW_REMOVED:
 238                 return "STARTING_WINDOW_REMOVED";
 239             default:
 240                 return "unknown state=" + state;
 241         }
 242     }
 243
 244     void dump(PrintWriter pw, String prefix) {
 245         final long now = SystemClock.uptimeMillis();
 246         pw.print(prefix); pw.print("packageName="); pw.print(packageName);
 247                 pw.print(" processName="); pw.println(processName);
 248         pw.print(prefix); pw.print("launchedFromUid="); pw.print(launchedFromUid);
 249                 pw.print(" launchedFromPackage="); pw.print(launchedFromPackage);
 250                 pw.print(" userId="); pw.println(userId);
 251         pw.print(prefix); pw.print("app="); pw.println(app);
 252         pw.print(prefix); pw.println(intent.toInsecureStringWithClip());
 253         pw.print(prefix); pw.print("frontOfTask="); pw.print(frontOfTask);
 254                 pw.print(" task="); pw.println(task);
 255         pw.print(prefix); pw.print("taskAffinity="); pw.println(taskAffinity);
 256         pw.print(prefix); pw.print("realActivity=");
 257                 pw.println(realActivity.flattenToShortString());
 258         if (appInfo != null) {
 259             pw.print(prefix); pw.print("baseDir="); pw.println(appInfo.sourceDir);
 260             if (!Objects.equals(appInfo.sourceDir, appInfo.publicSourceDir)) {
 261                 pw.print(prefix); pw.print("resDir="); pw.println(appInfo.publicSourceDir);
 262             }
 263             pw.print(prefix); pw.print("dataDir="); pw.println(appInfo.dataDir);
 264             if (appInfo.splitSourceDirs != null) {
 265                 pw.print(prefix); pw.print("splitDir=");
 266                         pw.println(Arrays.toString(appInfo.splitSourceDirs));
 267             }
 268         }
 269         pw.print(prefix); pw.print("stateNotNeeded="); pw.print(stateNotNeeded);
 270                 pw.print(" componentSpecified="); pw.print(componentSpecified);
 271                 pw.print(" mActivityType="); pw.println(mActivityType);
 272         if (rootVoiceInteraction) {
 273             pw.print(prefix); pw.print("rootVoiceInteraction="); pw.println(rootVoiceInteraction);
 274         }
 275         pw.print(prefix); pw.print("compat="); pw.print(compat);
 276                 pw.print(" labelRes=0x"); pw.print(Integer.toHexString(labelRes));
 277                 pw.print(" icon=0x"); pw.print(Integer.toHexString(icon));
 278                 pw.print(" theme=0x"); pw.println(Integer.toHexString(theme));
 279         pw.print(prefix); pw.print("config="); pw.println(configuration);
 280         pw.print(prefix); pw.print("taskConfigOverride="); pw.println(taskConfigOverride);
 281         if (resultTo != null || resultWho != null) {
 282             pw.print(prefix); pw.print("resultTo="); pw.print(resultTo);
 283                     pw.print(" resultWho="); pw.print(resultWho);
 284                     pw.print(" resultCode="); pw.println(requestCode);
 285         }
 286         if (taskDescription != null) {
 287             final String iconFilename = taskDescription.getIconFilename();
 288             if (iconFilename != null || taskDescription.getLabel() != null ||
 289                     taskDescription.getPrimaryColor() != 0) {
 290                 pw.print(prefix); pw.print("taskDescription:");
 291                         pw.print(" iconFilename="); pw.print(taskDescription.getIconFilename());
 292                         pw.print(" label=\""); pw.print(taskDescription.getLabel());
 293                                 pw.print("\"");
 294                         pw.print(" color=");
 295                         pw.println(Integer.toHexString(taskDescription.getPrimaryColor()));
 296             }
 297             if (iconFilename == null && taskDescription.getIcon() != null) {
 298                 pw.print(prefix); pw.println("taskDescription contains Bitmap");
 299             }
 300         }
 301         if (results != null) {
 302             pw.print(prefix); pw.print("results="); pw.println(results);
 303         }
 304         if (pendingResults != null && pendingResults.size() > 0) {
 305             pw.print(prefix); pw.println("Pending Results:");
 306             for (WeakReference<PendingIntentRecord> wpir : pendingResults) {
 307                 PendingIntentRecord pir = wpir != null ? wpir.get() : null;
 308                 pw.print(prefix); pw.print("  - ");
 309                 if (pir == null) {
 310                     pw.println("null");
 311                 } else {
 312                     pw.println(pir);
 313                     pir.dump(pw, prefix + "    ");
 314                 }
 315             }
 316         }
 317         if (newIntents != null && newIntents.size() > 0) {
 318             pw.print(prefix); pw.println("Pending New Intents:");
 319             for (int i=0; i<newIntents.size(); i++) {
 320                 Intent intent = newIntents.get(i);
 321                 pw.print(prefix); pw.print("  - ");
 322                 if (intent == null) {
 323                     pw.println("null");
 324                 } else {
 325                     pw.println(intent.toShortString(false, true, false, true));
 326                 }
 327             }
 328         }
 329         if (pendingOptions != null) {
 330             pw.print(prefix); pw.print("pendingOptions="); pw.println(pendingOptions);
 331         }
 332         if (appTimeTracker != null) {
 333             appTimeTracker.dumpWithHeader(pw, prefix, false);
 334         }
 335         if (uriPermissions != null) {
 336             uriPermissions.dump(pw, prefix);
 337         }
 338         pw.print(prefix); pw.print("launchFailed="); pw.print(launchFailed);
 339                 pw.print(" launchCount="); pw.print(launchCount);
 340                 pw.print(" lastLaunchTime=");
 341                 if (lastLaunchTime == 0) pw.print("0");
 342                 else TimeUtils.formatDuration(lastLaunchTime, now, pw);
 343                 pw.println();
 344         pw.print(prefix); pw.print("haveState="); pw.print(haveState);
 345                 pw.print(" icicle="); pw.println(icicle);
 346         pw.print(prefix); pw.print("state="); pw.print(state);
 347                 pw.print(" stopped="); pw.print(stopped);
 348                 pw.print(" delayedResume="); pw.print(delayedResume);
 349                 pw.print(" finishing="); pw.println(finishing);
 350         pw.print(prefix); pw.print("keysPaused="); pw.print(keysPaused);
 351                 pw.print(" inHistory="); pw.print(inHistory);
 352                 pw.print(" visible="); pw.print(visible);
 353                 pw.print(" sleeping="); pw.print(sleeping);
 354                 pw.print(" idle="); pw.print(idle);
 355                 pw.print(" mStartingWindowState=");
 356                 pw.println(startingWindowStateToString(mStartingWindowState));
 357         pw.print(prefix); pw.print("fullscreen="); pw.print(fullscreen);
 358                 pw.print(" noDisplay="); pw.print(noDisplay);
 359                 pw.print(" immersive="); pw.print(immersive);
 360                 pw.print(" launchMode="); pw.println(launchMode);
 361         pw.print(prefix); pw.print("frozenBeforeDestroy="); pw.print(frozenBeforeDestroy);
 362                 pw.print(" forceNewConfig="); pw.println(forceNewConfig);
 363         pw.print(prefix); pw.print("mActivityType=");
 364                 pw.println(activityTypeToString(mActivityType));
 365         if (requestedVrComponent != null) {
 366             pw.print(prefix);
 367             pw.print("requestedVrComponent=");
 368             pw.println(requestedVrComponent);
 369         }
 370         if (displayStartTime != 0 || startTime != 0) {
 371             pw.print(prefix); pw.print("displayStartTime=");
 372                     if (displayStartTime == 0) pw.print("0");
 373                     else TimeUtils.formatDuration(displayStartTime, now, pw);
 374                     pw.print(" startTime=");
 375                     if (startTime == 0) pw.print("0");
 376                     else TimeUtils.formatDuration(startTime, now, pw);
 377                     pw.println();
 378         }
 379         final boolean waitingVisible = mStackSupervisor.mWaitingVisibleActivities.contains(this);
 380         if (lastVisibleTime != 0 || waitingVisible || nowVisible) {
 381             pw.print(prefix); pw.print("waitingVisible="); pw.print(waitingVisible);
 382                     pw.print(" nowVisible="); pw.print(nowVisible);
 383                     pw.print(" lastVisibleTime=");
 384                     if (lastVisibleTime == 0) pw.print("0");
 385                     else TimeUtils.formatDuration(lastVisibleTime, now, pw);
 386                     pw.println();
 387         }
 388         if (deferRelaunchUntilPaused || configChangeFlags != 0) {
 389             pw.print(prefix); pw.print("deferRelaunchUntilPaused="); pw.print(deferRelaunchUntilPaused);
 390                     pw.print(" configChangeFlags=");
 391                     pw.println(Integer.toHexString(configChangeFlags));
 392         }
 393         if (connections != null) {
 394             pw.print(prefix); pw.print("connections="); pw.println(connections);
 395         }
 396         if (info != null) {
 397             pw.println(prefix + "resizeMode=" + ActivityInfo.resizeModeToString(info.resizeMode));
 398         }
 399     }
 400
 401     public boolean crossesHorizontalSizeThreshold(int firstDp, int secondDp) {
 402         return crossesSizeThreshold(mHorizontalSizeConfigurations, firstDp, secondDp);
 403     }
 404
 405     public boolean crossesVerticalSizeThreshold(int firstDp, int secondDp) {
 406         return crossesSizeThreshold(mVerticalSizeConfigurations, firstDp, secondDp);
 407     }
 408
 409     public boolean crossesSmallestSizeThreshold(int firstDp, int secondDp) {
 410         return crossesSizeThreshold(mSmallestSizeConfigurations, firstDp, secondDp);
 411     }
 412
 413     /**
 414      * The purpose of this method is to decide whether the activity needs to be relaunched upon
 415      * changing its size. In most cases the activities don't need to be relaunched, if the resize
 416      * is small, all the activity content has to do is relayout itself within new bounds. There are
 417      * cases however, where the activity's content would be completely changed in the new size and
 418      * the full relaunch is required.
 419      *
 420      * The activity will report to us vertical and horizontal thresholds after which a relaunch is
 421      * required. These thresholds are collected from the application resource qualifiers. For
 422      * example, if application has layout-w600dp resource directory, then it needs a relaunch when
 423      * we resize from width of 650dp to 550dp, as it crosses the 600dp threshold. However, if
 424      * it resizes width from 620dp to 700dp, it won't be relaunched as it stays on the same side
 425      * of the threshold.
 426      */
 427     private static boolean crossesSizeThreshold(int[] thresholds, int firstDp,
 428             int secondDp) {
 429         if (thresholds == null) {
 430             return false;
 431         }
 432         for (int i = thresholds.length - 1; i >= 0; i--) {
 433             final int threshold = thresholds[i];
 434             if ((firstDp < threshold && secondDp >= threshold)
 435                     || (firstDp >= threshold && secondDp < threshold)) {
 436                 return true;
 437             }
 438         }
 439         return false;
 440     }
 441
 442     public void setSizeConfigurations(int[] horizontalSizeConfiguration,
 443             int[] verticalSizeConfigurations, int[] smallestSizeConfigurations) {
 444         mHorizontalSizeConfigurations = horizontalSizeConfiguration;
 445         mVerticalSizeConfigurations = verticalSizeConfigurations;
 446         mSmallestSizeConfigurations = smallestSizeConfigurations;
 447     }
 448
 449     void scheduleConfigurationChanged(Configuration config, boolean reportToActivity) {
 450         if (app == null || app.thread == null) {
 451             return;
 452         }
 453         try {
 454             // Make sure fontScale is always equal to global. For fullscreen apps, config is
 455             // the shared EMPTY config, which has default fontScale of 1.0. We don't want it
 456             // to be applied as an override config.
 457             Configuration overrideConfig = new Configuration(config);
 458             overrideConfig.fontScale = service.mConfiguration.fontScale;
 459
 460             if (DEBUG_CONFIGURATION) Slog.v(TAG, "Sending new config to " + this + " " +
 461                     "reportToActivity=" + reportToActivity + " and config: " + overrideConfig);
 462
 463             app.thread.scheduleActivityConfigurationChanged(
 464                     appToken, overrideConfig, reportToActivity);
 465         } catch (RemoteException e) {
 466             // If process died, whatever.
 467         }
 468     }
 469
 470     void scheduleMultiWindowModeChanged() {
 471         if (task == null || task.stack == null || app == null || app.thread == null) {
 472             return;
 473         }
 474         try {
 475             // An activity is considered to be in multi-window mode if its task isn't fullscreen.
 476             app.thread.scheduleMultiWindowModeChanged(appToken, !task.mFullscreen);
 477         } catch (Exception e) {
 478             // If process died, I don't care.
 479         }
 480     }
 481
 482     void schedulePictureInPictureModeChanged() {
 483         if (task == null || task.stack == null || app == null || app.thread == null) {
 484             return;
 485         }
 486         try {
 487             app.thread.schedulePictureInPictureModeChanged(
 488                     appToken, task.stack.mStackId == PINNED_STACK_ID);
 489         } catch (Exception e) {
 490             // If process died, no one cares.
 491         }
 492     }
 493
 494     boolean isFreeform() {
 495         return task != null && task.stack != null
 496                 && task.stack.mStackId == FREEFORM_WORKSPACE_STACK_ID;
 497     }
 498
 499     static class Token extends IApplicationToken.Stub {
 500         private final WeakReference<ActivityRecord> weakActivity;
 501         private final ActivityManagerService mService;
 502
 503         Token(ActivityRecord activity, ActivityManagerService service) {
 504             weakActivity = new WeakReference<>(activity);
 505             mService = service;
 506         }
 507
 508         @Override
 509         public void windowsDrawn() {
 510             synchronized (mService) {
 511                 ActivityRecord r = tokenToActivityRecordLocked(this);
 512                 if (r != null) {
 513                     r.windowsDrawnLocked();
 514                 }
 515             }
 516         }
 517
 518         @Override
 519         public void windowsVisible() {
 520             synchronized (mService) {
 521                 ActivityRecord r = tokenToActivityRecordLocked(this);
 522                 if (r != null) {
 523                     r.windowsVisibleLocked();
 524                 }
 525             }
 526         }
 527
 528         @Override
 529         public void windowsGone() {
 530             synchronized (mService) {
 531                 ActivityRecord r = tokenToActivityRecordLocked(this);
 532                 if (r != null) {
 533                     if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "windowsGone(): " + r);
 534                     r.nowVisible = false;
 535                     return;
 536                 }
 537             }
 538         }
 539
 540         @Override
 541         public boolean keyDispatchingTimedOut(String reason) {
 542             ActivityRecord r;
 543             ActivityRecord anrActivity;
 544             ProcessRecord anrApp;
 545             synchronized (mService) {
 546                 r = tokenToActivityRecordLocked(this);
 547                 if (r == null) {
 548                     return false;
 549                 }
 550                 anrActivity = r.getWaitingHistoryRecordLocked();
 551                 anrApp = r != null ? r.app : null;
 552             }
 553             return mService.inputDispatchingTimedOut(anrApp, anrActivity, r, false, reason);
 554         }
 555
 556         @Override
 557         public long getKeyDispatchingTimeout() {
 558             synchronized (mService) {
 559                 ActivityRecord r = tokenToActivityRecordLocked(this);
 560                 if (r == null) {
 561                     return 0;
 562                 }
 563                 r = r.getWaitingHistoryRecordLocked();
 564                 return ActivityManagerService.getInputDispatchingTimeoutLocked(r);
 565             }
 566         }
 567
 568         private static final ActivityRecord tokenToActivityRecordLocked(Token token) {
 569             if (token == null) {
 570                 return null;
 571             }
 572             ActivityRecord r = token.weakActivity.get();
 573             if (r == null || r.task == null || r.task.stack == null) {
 574                 return null;
 575             }
 576             return r;
 577         }
 578
 579         @Override
 580         public String toString() {
 581             StringBuilder sb = new StringBuilder(128);
 582             sb.append("Token{");
 583             sb.append(Integer.toHexString(System.identityHashCode(this)));
 584             sb.append(' ');
 585             sb.append(weakActivity.get());
 586             sb.append('}');
 587             return sb.toString();
 588         }
 589     }
 590
 591     static ActivityRecord forTokenLocked(IBinder token) {
 592         try {
 593             return Token.tokenToActivityRecordLocked((Token)token);
 594         } catch (ClassCastException e) {
 595             Slog.w(TAG, "Bad activity token: " + token, e);
 596             return null;
 597         }
 598     }
 599
 600     boolean isResolverActivity() {
 601         return ResolverActivity.class.getName().equals(realActivity.getClassName());
 602     }
 603
 604     ActivityRecord(ActivityManagerService _service, ProcessRecord _caller,
 605             int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
 606             ActivityInfo aInfo, Configuration _configuration,
 607             ActivityRecord _resultTo, String _resultWho, int _reqCode,
 608             boolean _componentSpecified, boolean _rootVoiceInteraction,
 609             ActivityStackSupervisor supervisor,
 610             ActivityContainer container, ActivityOptions options, ActivityRecord sourceRecord) {
 611         service = _service;
 612         appToken = new Token(this, service);
 613         info = aInfo;
 614         launchedFromUid = _launchedFromUid;
 615         launchedFromPackage = _launchedFromPackage;
 616         userId = UserHandle.getUserId(aInfo.applicationInfo.uid);
 617         intent = _intent;
 618         shortComponentName = _intent.getComponent().flattenToShortString();
 619         resolvedType = _resolvedType;
 620         componentSpecified = _componentSpecified;
 621         rootVoiceInteraction = _rootVoiceInteraction;
 622         configuration = _configuration;
 623         taskConfigOverride = Configuration.EMPTY;
 624         resultTo = _resultTo;
 625         resultWho = _resultWho;
 626         requestCode = _reqCode;
 627         state = ActivityState.INITIALIZING;
 628         frontOfTask = false;
 629         launchFailed = false;
 630         stopped = false;
 631         delayedResume = false;
 632         finishing = false;
 633         deferRelaunchUntilPaused = false;
 634         keysPaused = false;
 635         inHistory = false;
 636         visible = false;
 637         nowVisible = false;
 638         idle = false;
 639         hasBeenLaunched = false;
 640         mStackSupervisor = supervisor;
 641         mInitialActivityContainer = container;
 642         if (options != null) {
 643             pendingOptions = options;
 644             mLaunchTaskBehind = pendingOptions.getLaunchTaskBehind();
 645             mRotationAnimationHint = pendingOptions.getRotationAnimationHint();
 646             PendingIntent usageReport = pendingOptions.getUsageTimeReport();
 647             if (usageReport != null) {
 648                 appTimeTracker = new AppTimeTracker(usageReport);
 649             }
 650         }
 651
 652         // This starts out true, since the initial state of an activity
 653         // is that we have everything, and we shouldn't never consider it
 654         // lacking in state to be removed if it dies.
 655         haveState = true;
 656
 657         if (aInfo != null) {
 658             // If the class name in the intent doesn't match that of the target, this is
 659             // probably an alias. We have to create a new ComponentName object to keep track
 660             // of the real activity name, so that FLAG_ACTIVITY_CLEAR_TOP is handled properly.
 661             if (aInfo.targetActivity == null
 662                     || (aInfo.targetActivity.equals(_intent.getComponent().getClassName())
 663                     && (aInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE
 664                     || aInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP))) {
 665                 realActivity = _intent.getComponent();
 666             } else {
 667                 realActivity = new ComponentName(aInfo.packageName, aInfo.targetActivity);
 668             }
 669             taskAffinity = aInfo.taskAffinity;
 670             stateNotNeeded = (aInfo.flags&
 671                     ActivityInfo.FLAG_STATE_NOT_NEEDED) != 0;
 672             appInfo = aInfo.applicationInfo;
 673             nonLocalizedLabel = aInfo.nonLocalizedLabel;
 674             labelRes = aInfo.labelRes;
 675             if (nonLocalizedLabel == null && labelRes == 0) {
 676                 ApplicationInfo app = aInfo.applicationInfo;
 677                 nonLocalizedLabel = app.nonLocalizedLabel;
 678                 labelRes = app.labelRes;
 679             }
 680             icon = aInfo.getIconResource();
 681             logo = aInfo.getLogoResource();
 682             theme = aInfo.getThemeResource();
 683             realTheme = theme;
 684             if (realTheme == 0) {
 685                 realTheme = aInfo.applicationInfo.targetSdkVersion
 686                         < Build.VERSION_CODES.HONEYCOMB
 687                         ? android.R.style.Theme
 688                         : android.R.style.Theme_Holo;
 689             }
 690             if ((aInfo.flags&ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
 691                 windowFlags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
 692             }
 693             if ((aInfo.flags&ActivityInfo.FLAG_MULTIPROCESS) != 0
 694                     && _caller != null
 695                     && (aInfo.applicationInfo.uid == Process.SYSTEM_UID
 696                             || aInfo.applicationInfo.uid == _caller.info.uid)) {
 697                 processName = _caller.processName;
 698             } else {
 699                 processName = aInfo.processName;
 700             }
 701
 702             if (intent != null && (aInfo.flags & ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS) != 0) {
 703                 intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
 704             }
 705
 706             packageName = aInfo.applicationInfo.packageName;
 707             launchMode = aInfo.launchMode;
 708
 709             AttributeCache.Entry ent = AttributeCache.instance().get(packageName,
 710                     realTheme, com.android.internal.R.styleable.Window, userId);
 711             final boolean translucent = ent != null && (ent.array.getBoolean(
 712                     com.android.internal.R.styleable.Window_windowIsTranslucent, false)
 713                     || (!ent.array.hasValue(
 714                             com.android.internal.R.styleable.Window_windowIsTranslucent)
 715                             && ent.array.getBoolean(
 716                                     com.android.internal.R.styleable.Window_windowSwipeToDismiss,
 717                                             false)));
 718             fullscreen = ent != null && !ent.array.getBoolean(
 719                     com.android.internal.R.styleable.Window_windowIsFloating, false)
 720                     && !translucent;
 721             noDisplay = ent != null && ent.array.getBoolean(
 722                     com.android.internal.R.styleable.Window_windowNoDisplay, false);
 723
 724             setActivityType(_componentSpecified, _launchedFromUid, _intent, sourceRecord);
 725
 726             immersive = (aInfo.flags & ActivityInfo.FLAG_IMMERSIVE) != 0;
 727
 728             requestedVrComponent = (aInfo.requestedVrComponent == null) ?
 729                     null : ComponentName.unflattenFromString(aInfo.requestedVrComponent);
 730         } else {
 731             realActivity = null;
 732             taskAffinity = null;
 733             stateNotNeeded = false;
 734             appInfo = null;
 735             processName = null;
 736             packageName = null;
 737             fullscreen = true;
 738             noDisplay = false;
 739             mActivityType = APPLICATION_ACTIVITY_TYPE;
 740             immersive = false;
 741             requestedVrComponent  = null;
 742         }
 743     }
 744
 745     private boolean isHomeIntent(Intent intent) {
 746         return Intent.ACTION_MAIN.equals(intent.getAction())
 747                 && intent.hasCategory(Intent.CATEGORY_HOME)
 748                 && intent.getCategories().size() == 1
 749                 && intent.getData() == null
 750                 && intent.getType() == null;
 751     }
 752
 753     static boolean isMainIntent(Intent intent) {
 754         return Intent.ACTION_MAIN.equals(intent.getAction())
 755                 && intent.hasCategory(Intent.CATEGORY_LAUNCHER)
 756                 && intent.getCategories().size() == 1
 757                 && intent.getData() == null
 758                 && intent.getType() == null;
 759     }
 760
 761     private boolean canLaunchHomeActivity(int uid, ActivityRecord sourceRecord) {
 762         if (uid == Process.myUid() || uid == 0) {
 763             // System process can launch home activity.
 764             return true;
 765         }
 766         // Resolver activity can launch home activity.
 767         return sourceRecord != null && sourceRecord.isResolverActivity();
 768     }
 769
 770     private void setActivityType(boolean componentSpecified,
 771             int launchedFromUid, Intent intent, ActivityRecord sourceRecord) {
 772         if ((!componentSpecified || canLaunchHomeActivity(launchedFromUid, sourceRecord))
 773                 && isHomeIntent(intent) && !isResolverActivity()) {
 774             // This sure looks like a home activity!
 775             mActivityType = HOME_ACTIVITY_TYPE;
 776         } else if (realActivity.getClassName().contains(RECENTS_PACKAGE_NAME)) {
 777             mActivityType = RECENTS_ACTIVITY_TYPE;
 778         } else {
 779             mActivityType = APPLICATION_ACTIVITY_TYPE;
 780         }
 781     }
 782
 783     void setTask(TaskRecord newTask, TaskRecord taskToAffiliateWith) {
 784         if (task != null && task.removeActivity(this) && task != newTask && task.stack != null) {
 785             task.stack.removeTask(task, "setTask");
 786         }
 787         task = newTask;
 788         setTaskToAffiliateWith(taskToAffiliateWith);
 789     }
 790
 791     void setTaskToAffiliateWith(TaskRecord taskToAffiliateWith) {
 792         if (taskToAffiliateWith != null &&
 793                 launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE &&
 794                 launchMode != ActivityInfo.LAUNCH_SINGLE_TASK) {
 795             task.setTaskToAffiliateWith(taskToAffiliateWith);
 796         }
 797     }
 798
 799     boolean changeWindowTranslucency(boolean toOpaque) {
 800         if (fullscreen == toOpaque) {
 801             return false;
 802         }
 803
 804         // Keep track of the number of fullscreen activities in this task.
 805         task.numFullscreen += toOpaque ? +1 : -1;
 806
 807         fullscreen = toOpaque;
 808         return true;
 809     }
 810
 811     void putInHistory() {
 812         if (!inHistory) {
 813             inHistory = true;
 814         }
 815     }
 816
 817     void takeFromHistory() {
 818         if (inHistory) {
 819             inHistory = false;
 820             if (task != null && !finishing) {
 821                 task = null;
 822             }
 823             clearOptionsLocked();
 824         }
 825     }
 826
 827     boolean isInHistory() {
 828         return inHistory;
 829     }
 830
 831     boolean isInStackLocked() {
 832         return task != null && task.stack != null && task.stack.isInStackLocked(this) != null;
 833     }
 834
 835     boolean isHomeActivity() {
 836         return mActivityType == HOME_ACTIVITY_TYPE;
 837     }
 838
 839     boolean isRecentsActivity() {
 840         return mActivityType == RECENTS_ACTIVITY_TYPE;
 841     }
 842
 843     boolean isApplicationActivity() {
 844         return mActivityType == APPLICATION_ACTIVITY_TYPE;
 845     }
 846
 847     boolean isPersistable() {
 848         return (info.persistableMode == ActivityInfo.PERSIST_ROOT_ONLY ||
 849                 info.persistableMode == ActivityInfo.PERSIST_ACROSS_REBOOTS) &&
 850                 (intent == null ||
 851                         (intent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0);
 852     }
 853
 854     boolean isFocusable() {
 855         return StackId.canReceiveKeys(task.stack.mStackId) || isAlwaysFocusable();
 856     }
 857
 858     boolean isResizeable() {
 859         return !isHomeActivity() && ActivityInfo.isResizeableMode(info.resizeMode);
 860     }
 861
 862     boolean isResizeableOrForced() {
 863         return !isHomeActivity() && (isResizeable() || service.mForceResizableActivities);
 864     }
 865
 866     boolean isNonResizableOrForced() {
 867         return !isHomeActivity() && info.resizeMode != RESIZE_MODE_RESIZEABLE
 868                 && info.resizeMode != RESIZE_MODE_RESIZEABLE_AND_PIPABLE;
 869     }
 870
 871     boolean supportsPictureInPicture() {
 872         return !isHomeActivity() && info.resizeMode == RESIZE_MODE_RESIZEABLE_AND_PIPABLE;
 873     }
 874
 875     boolean canGoInDockedStack() {
 876         return !isHomeActivity()
 877                 && (isResizeableOrForced() || info.resizeMode == RESIZE_MODE_CROP_WINDOWS);
 878     }
 879
 880     boolean isAlwaysFocusable() {
 881         return (info.flags & FLAG_ALWAYS_FOCUSABLE) != 0;
 882     }
 883
 884     void makeFinishingLocked() {
 885         if (!finishing) {
 886             if (task != null && task.stack != null
 887                     && this == task.stack.getVisibleBehindActivity()) {
 888                 // A finishing activity should not remain as visible in the background
 889                 mStackSupervisor.requestVisibleBehindLocked(this, false);
 890             }
 891             finishing = true;
 892             if (stopped) {
 893                 clearOptionsLocked();
 894             }
 895         }
 896     }
 897
 898     UriPermissionOwner getUriPermissionsLocked() {
 899         if (uriPermissions == null) {
 900             uriPermissions = new UriPermissionOwner(service, this);
 901         }
 902         return uriPermissions;
 903     }
 904
 905     void addResultLocked(ActivityRecord from, String resultWho,
 906             int requestCode, int resultCode,
 907             Intent resultData) {
 908         ActivityResult r = new ActivityResult(from, resultWho,
 909                 requestCode, resultCode, resultData);
 910         if (results == null) {
 911             results = new ArrayList<ResultInfo>();
 912         }
 913         results.add(r);
 914     }
 915
 916     void removeResultsLocked(ActivityRecord from, String resultWho,
 917             int requestCode) {
 918         if (results != null) {
 919             for (int i=results.size()-1; i>=0; i--) {
 920                 ActivityResult r = (ActivityResult)results.get(i);
 921                 if (r.mFrom != from) continue;
 922                 if (r.mResultWho == null) {
 923                     if (resultWho != null) continue;
 924                 } else {
 925                     if (!r.mResultWho.equals(resultWho)) continue;
 926                 }
 927                 if (r.mRequestCode != requestCode) continue;
 928
 929                 results.remove(i);
 930             }
 931         }
 932     }
 933
 934     void addNewIntentLocked(ReferrerIntent intent) {
 935         if (newIntents == null) {
 936             newIntents = new ArrayList<>();
 937         }
 938         newIntents.add(intent);
 939     }
 940
 941     /**
 942      * Deliver a new Intent to an existing activity, so that its onNewIntent()
 943      * method will be called at the proper time.
 944      */
 945     final void deliverNewIntentLocked(int callingUid, Intent intent, String referrer) {
 946         // The activity now gets access to the data associated with this Intent.
 947         service.grantUriPermissionFromIntentLocked(callingUid, packageName,
 948                 intent, getUriPermissionsLocked(), userId);
 949         // We want to immediately deliver the intent to the activity if
 950         // it is currently the top resumed activity...  however, if the
 951         // device is sleeping, then all activities are stopped, so in that
 952         // case we will deliver it if this is the current top activity on its
 953         // stack.
 954         final ReferrerIntent rintent = new ReferrerIntent(intent, referrer);
 955         boolean unsent = true;
 956         if ((state == ActivityState.RESUMED
 957                 || (service.isSleepingLocked() && task.stack != null
 958                     && task.stack.topRunningActivityLocked() == this))
 959                 && app != null && app.thread != null) {
 960             try {
 961                 ArrayList<ReferrerIntent> ar = new ArrayList<>(1);
 962                 ar.add(rintent);
 963                 app.thread.scheduleNewIntent(ar, appToken);
 964                 unsent = false;
 965             } catch (RemoteException e) {
 966                 Slog.w(TAG, "Exception thrown sending new intent to " + this, e);
 967             } catch (NullPointerException e) {
 968                 Slog.w(TAG, "Exception thrown sending new intent to " + this, e);
 969             }
 970         }
 971         if (unsent) {
 972             addNewIntentLocked(rintent);
 973         }
 974     }
 975
 976     void updateOptionsLocked(ActivityOptions options) {
 977         if (options != null) {
 978             if (pendingOptions != null) {
 979                 pendingOptions.abort();
 980             }
 981             pendingOptions = options;
 982         }
 983     }
 984
 985     void applyOptionsLocked() {
 986         if (pendingOptions != null
 987                 && pendingOptions.getAnimationType() != ActivityOptions.ANIM_SCENE_TRANSITION) {
 988             final int animationType = pendingOptions.getAnimationType();
 989             switch (animationType) {
 990                 case ActivityOptions.ANIM_CUSTOM:
 991                     service.mWindowManager.overridePendingAppTransition(
 992                             pendingOptions.getPackageName(),
 993                             pendingOptions.getCustomEnterResId(),
 994                             pendingOptions.getCustomExitResId(),
 995                             pendingOptions.getOnAnimationStartListener());
 996                     break;
 997                 case ActivityOptions.ANIM_CLIP_REVEAL:
 998                     service.mWindowManager.overridePendingAppTransitionClipReveal(
 999                             pendingOptions.getStartX(), pendingOptions.getStartY(),
1000                             pendingOptions.getWidth(), pendingOptions.getHeight());
1001                     if (intent.getSourceBounds() == null) {
1002                         intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
1003                                 pendingOptions.getStartY(),
1004                                 pendingOptions.getStartX()+pendingOptions.getWidth(),
1005                                 pendingOptions.getStartY()+pendingOptions.getHeight()));
1006                     }
1007                     break;
1008                 case ActivityOptions.ANIM_SCALE_UP:
1009                     service.mWindowManager.overridePendingAppTransitionScaleUp(
1010                             pendingOptions.getStartX(), pendingOptions.getStartY(),
1011                             pendingOptions.getWidth(), pendingOptions.getHeight());
1012                     if (intent.getSourceBounds() == null) {
1013                         intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
1014                                 pendingOptions.getStartY(),
1015                                 pendingOptions.getStartX()+pendingOptions.getWidth(),
1016                                 pendingOptions.getStartY()+pendingOptions.getHeight()));
1017                     }
1018                     break;
1019                 case ActivityOptions.ANIM_THUMBNAIL_SCALE_UP:
1020                 case ActivityOptions.ANIM_THUMBNAIL_SCALE_DOWN:
1021                     boolean scaleUp = (animationType == ActivityOptions.ANIM_THUMBNAIL_SCALE_UP);
1022                     service.mWindowManager.overridePendingAppTransitionThumb(
1023                             pendingOptions.getThumbnail(),
1024                             pendingOptions.getStartX(), pendingOptions.getStartY(),
1025                             pendingOptions.getOnAnimationStartListener(),
1026                             scaleUp);
1027                     if (intent.getSourceBounds() == null) {
1028                         intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
1029                                 pendingOptions.getStartY(),
1030                                 pendingOptions.getStartX()
1031                                         + pendingOptions.getThumbnail().getWidth(),
1032                                 pendingOptions.getStartY()
1033                                         + pendingOptions.getThumbnail().getHeight()));
1034                     }
1035                     break;
1036                 case ActivityOptions.ANIM_THUMBNAIL_ASPECT_SCALE_UP:
1037                 case ActivityOptions.ANIM_THUMBNAIL_ASPECT_SCALE_DOWN:
1038                     final AppTransitionAnimationSpec[] specs = pendingOptions.getAnimSpecs();
1039                     if (animationType == ActivityOptions.ANIM_THUMBNAIL_ASPECT_SCALE_DOWN
1040                             && specs != null) {
1041                         service.mWindowManager.overridePendingAppTransitionMultiThumb(
1042                                 specs, pendingOptions.getOnAnimationStartListener(),
1043                                 pendingOptions.getAnimationFinishedListener(), false);
1044                     } else {
1045                         service.mWindowManager.overridePendingAppTransitionAspectScaledThumb(
1046                                 pendingOptions.getThumbnail(),
1047                                 pendingOptions.getStartX(), pendingOptions.getStartY(),
1048                                 pendingOptions.getWidth(), pendingOptions.getHeight(),
1049                                 pendingOptions.getOnAnimationStartListener(),
1050                                 (animationType == ActivityOptions.ANIM_THUMBNAIL_ASPECT_SCALE_UP));
1051                         if (intent.getSourceBounds() == null) {
1052                             intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
1053                                     pendingOptions.getStartY(),
1054                                     pendingOptions.getStartX() + pendingOptions.getWidth(),
1055                                     pendingOptions.getStartY() + pendingOptions.getHeight()));
1056                         }
1057                     }
1058                     break;
1059                 default:
1060                     Slog.e(TAG, "applyOptionsLocked: Unknown animationType=" + animationType);
1061                     break;
1062             }
1063             pendingOptions = null;
1064         }
1065     }
1066
1067     ActivityOptions getOptionsForTargetActivityLocked() {
1068         return pendingOptions != null ? pendingOptions.forTargetActivity() : null;
1069     }
1070
1071     void clearOptionsLocked() {
1072         if (pendingOptions != null) {
1073             pendingOptions.abort();
1074             pendingOptions = null;
1075         }
1076     }
1077
1078     ActivityOptions takeOptionsLocked() {
1079         ActivityOptions opts = pendingOptions;
1080         pendingOptions = null;
1081         return opts;
1082     }
1083
1084     void removeUriPermissionsLocked() {
1085         if (uriPermissions != null) {
1086             uriPermissions.removeUriPermissionsLocked();
1087             uriPermissions = null;
1088         }
1089     }
1090
1091     void pauseKeyDispatchingLocked() {
1092         if (!keysPaused) {
1093             keysPaused = true;
1094             service.mWindowManager.pauseKeyDispatching(appToken);
1095         }
1096     }
1097
1098     void resumeKeyDispatchingLocked() {
1099         if (keysPaused) {
1100             keysPaused = false;
1101             service.mWindowManager.resumeKeyDispatching(appToken);
1102         }
1103     }
1104
1105     void updateThumbnailLocked(Bitmap newThumbnail, CharSequence description) {
1106         if (newThumbnail != null) {
1107             if (DEBUG_THUMBNAILS) Slog.i(TAG_THUMBNAILS,
1108                     "Setting thumbnail of " + this + " to " + newThumbnail);
1109             boolean thumbnailUpdated = task.setLastThumbnailLocked(newThumbnail);
1110             if (thumbnailUpdated && isPersistable()) {
1111                 mStackSupervisor.mService.notifyTaskPersisterLocked(task, false);
1112             }
1113         }
1114         task.lastDescription = description;
1115     }
1116
1117     void startLaunchTickingLocked() {
1118         if (ActivityManagerService.IS_USER_BUILD) {
1119             return;
1120         }
1121         if (launchTickTime == 0) {
1122             launchTickTime = SystemClock.uptimeMillis();
1123             continueLaunchTickingLocked();
1124         }
1125     }
1126
1127     boolean continueLaunchTickingLocked() {
1128         if (launchTickTime == 0) {
1129             return false;
1130         }
1131
1132         final ActivityStack stack = task.stack;
1133         if (stack == null) {
1134             return false;
1135         }
1136
1137         Message msg = stack.mHandler.obtainMessage(ActivityStack.LAUNCH_TICK_MSG, this);
1138         stack.mHandler.removeMessages(ActivityStack.LAUNCH_TICK_MSG);
1139         stack.mHandler.sendMessageDelayed(msg, ActivityStack.LAUNCH_TICK);
1140         return true;
1141     }
1142
1143     void finishLaunchTickingLocked() {
1144         launchTickTime = 0;
1145         final ActivityStack stack = task.stack;
1146         if (stack != null) {
1147             stack.mHandler.removeMessages(ActivityStack.LAUNCH_TICK_MSG);
1148         }
1149     }
1150
1151     // IApplicationToken
1152
1153     public boolean mayFreezeScreenLocked(ProcessRecord app) {
1154         // Only freeze the screen if this activity is currently attached to
1155         // an application, and that application is not blocked or unresponding.
1156         // In any other case, we can't count on getting the screen unfrozen,
1157         // so it is best to leave as-is.
1158         return app != null && !app.crashing && !app.notResponding;
1159     }
1160
1161     public void startFreezingScreenLocked(ProcessRecord app, int configChanges) {
1162         if (mayFreezeScreenLocked(app)) {
1163             service.mWindowManager.startAppFreezingScreen(appToken, configChanges);
1164         }
1165     }
1166
1167     public void stopFreezingScreenLocked(boolean force) {
1168         if (force || frozenBeforeDestroy) {
1169             frozenBeforeDestroy = false;
1170             service.mWindowManager.stopAppFreezingScreen(appToken, force);
1171         }
1172     }
1173
1174     public void reportFullyDrawnLocked() {
1175         final long curTime = SystemClock.uptimeMillis();
1176         if (displayStartTime != 0) {
1177             reportLaunchTimeLocked(curTime);
1178         }
1179         final ActivityStack stack = task.stack;
1180         if (fullyDrawnStartTime != 0 && stack != null) {
1181             final long thisTime = curTime - fullyDrawnStartTime;
1182             final long totalTime = stack.mFullyDrawnStartTime != 0
1183                     ? (curTime - stack.mFullyDrawnStartTime) : thisTime;
1184             if (SHOW_ACTIVITY_START_TIME) {
1185                 Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER, "drawing", 0);
1186                 EventLog.writeEvent(EventLogTags.AM_ACTIVITY_FULLY_DRAWN_TIME,
1187                         userId, System.identityHashCode(this), shortComponentName,
1188                         thisTime, totalTime);
1189                 StringBuilder sb = service.mStringBuilder;
1190                 sb.setLength(0);
1191                 sb.append("Fully drawn ");
1192                 sb.append(shortComponentName);
1193                 sb.append(": ");
1194                 TimeUtils.formatDuration(thisTime, sb);
1195                 if (thisTime != totalTime) {
1196                     sb.append(" (total ");
1197                     TimeUtils.formatDuration(totalTime, sb);
1198                     sb.append(")");
1199                 }
1200                 Log.i(TAG, sb.toString());
1201             }
1202             if (totalTime > 0) {
1203                 //service.mUsageStatsService.noteFullyDrawnTime(realActivity, (int) totalTime);
1204             }
1205             stack.mFullyDrawnStartTime = 0;
1206         }
1207         fullyDrawnStartTime = 0;
1208     }
1209
1210     private void reportLaunchTimeLocked(final long curTime) {
1211         final ActivityStack stack = task.stack;
1212         if (stack == null) {
1213             return;
1214         }
1215         final long thisTime = curTime - displayStartTime;
1216         final long totalTime = stack.mLaunchStartTime != 0
1217                 ? (curTime - stack.mLaunchStartTime) : thisTime;
1218         if (SHOW_ACTIVITY_START_TIME) {
1219             Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER, "launching: " + packageName, 0);
1220             EventLog.writeEvent(EventLogTags.AM_ACTIVITY_LAUNCH_TIME,
1221                     userId, System.identityHashCode(this), shortComponentName,
1222                     thisTime, totalTime);
1223             StringBuilder sb = service.mStringBuilder;
1224             sb.setLength(0);
1225             sb.append("Displayed ");
1226             sb.append(shortComponentName);
1227             sb.append(": ");
1228             TimeUtils.formatDuration(thisTime, sb);
1229             if (thisTime != totalTime) {
1230                 sb.append(" (total ");
1231                 TimeUtils.formatDuration(totalTime, sb);
1232                 sb.append(")");
1233             }
1234             Log.i(TAG, sb.toString());
1235         }
1236         mStackSupervisor.reportActivityLaunchedLocked(false, this, thisTime, totalTime);
1237         if (totalTime > 0) {
1238             //service.mUsageStatsService.noteLaunchTime(realActivity, (int)totalTime);
1239         }
1240         displayStartTime = 0;
1241         stack.mLaunchStartTime = 0;
1242     }
1243
1244     void windowsDrawnLocked() {
1245         mStackSupervisor.mActivityMetricsLogger.notifyWindowsDrawn();
1246         if (displayStartTime != 0) {
1247             reportLaunchTimeLocked(SystemClock.uptimeMillis());
1248         }
1249         mStackSupervisor.sendWaitingVisibleReportLocked(this);
1250         startTime = 0;
1251         finishLaunchTickingLocked();
1252         if (task != null) {
1253             task.hasBeenVisible = true;
1254         }
1255     }
1256
1257     void windowsVisibleLocked() {
1258         mStackSupervisor.reportActivityVisibleLocked(this);
1259         if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "windowsVisibleLocked(): " + this);
1260         if (!nowVisible) {
1261             nowVisible = true;
1262             lastVisibleTime = SystemClock.uptimeMillis();
1263             if (!idle) {
1264                 // Instead of doing the full stop routine here, let's just hide any activities
1265                 // we now can, and let them stop when the normal idle happens.
1266                 mStackSupervisor.processStoppingActivitiesLocked(false);
1267             } else {
1268                 // If this activity was already idle, then we now need to make sure we perform
1269                 // the full stop of any activities that are waiting to do so. This is because
1270                 // we won't do that while they are still waiting for this one to become visible.
1271                 final int size = mStackSupervisor.mWaitingVisibleActivities.size();
1272                 if (size > 0) {
1273                     for (int i = 0; i < size; i++) {
1274                         ActivityRecord r = mStackSupervisor.mWaitingVisibleActivities.get(i);
1275                         if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "Was waiting for visible: " + r);
1276                     }
1277                     mStackSupervisor.mWaitingVisibleActivities.clear();
1278                     mStackSupervisor.scheduleIdleLocked();
1279                 }
1280             }
1281             service.scheduleAppGcsLocked();
1282         }
1283     }
1284
1285     ActivityRecord getWaitingHistoryRecordLocked() {
1286         // First find the real culprit...  if this activity is waiting for
1287         // another activity to start or has stopped, then the key dispatching
1288         // timeout should not be caused by this.
1289         if (mStackSupervisor.mWaitingVisibleActivities.contains(this) || stopped) {
1290             final ActivityStack stack = mStackSupervisor.getFocusedStack();
1291             // Try to use the one which is closest to top.
1292             ActivityRecord r = stack.mResumedActivity;
1293             if (r == null) {
1294                 r = stack.mPausingActivity;
1295             }
1296             if (r != null) {
1297                 return r;
1298             }
1299         }
1300         return this;
1301     }
1302
1303     /**
1304      * This method will return true if the activity is either visible, is becoming visible, is
1305      * currently pausing, or is resumed.
1306      */
1307     public boolean isInterestingToUserLocked() {
1308         return visible || nowVisible || state == ActivityState.PAUSING ||
1309                 state == ActivityState.RESUMED;
1310     }
1311
1312     public void setSleeping(boolean _sleeping) {
1313         if (sleeping == _sleeping) {
1314             return;
1315         }
1316         if (app != null && app.thread != null) {
1317             try {
1318                 app.thread.scheduleSleeping(appToken, _sleeping);
1319                 if (_sleeping && !mStackSupervisor.mGoingToSleepActivities.contains(this)) {
1320                     mStackSupervisor.mGoingToSleepActivities.add(this);
1321                 }
1322                 sleeping = _sleeping;
1323             } catch (RemoteException e) {
1324                 Slog.w(TAG, "Exception thrown when sleeping: " + intent.getComponent(), e);
1325             }
1326         }
1327     }
1328
1329     static int getTaskForActivityLocked(IBinder token, boolean onlyRoot) {
1330         final ActivityRecord r = ActivityRecord.forTokenLocked(token);
1331         if (r == null) {
1332             return INVALID_TASK_ID;
1333         }
1334         final TaskRecord task = r.task;
1335         final int activityNdx = task.mActivities.indexOf(r);
1336         if (activityNdx < 0 || (onlyRoot && activityNdx > task.findEffectiveRootIndex())) {
1337             return INVALID_TASK_ID;
1338         }
1339         return task.taskId;
1340     }
1341
1342     static ActivityRecord isInStackLocked(IBinder token) {
1343         final ActivityRecord r = ActivityRecord.forTokenLocked(token);
1344         return (r != null) ? r.task.stack.isInStackLocked(r) : null;
1345     }
1346
1347     static ActivityStack getStackLocked(IBinder token) {
1348         final ActivityRecord r = ActivityRecord.isInStackLocked(token);
1349         if (r != null) {
1350             return r.task.stack;
1351         }
1352         return null;
1353     }
1354
1355     final boolean isDestroyable() {
1356         if (finishing || app == null || state == ActivityState.DESTROYING
1357                 || state == ActivityState.DESTROYED) {
1358             // This would be redundant.
1359             return false;
1360         }
1361         if (task == null || task.stack == null || this == task.stack.mResumedActivity
1362                 || this == task.stack.mPausingActivity || !haveState || !stopped) {
1363             // We're not ready for this kind of thing.
1364             return false;
1365         }
1366         if (visible) {
1367             // The user would notice this!
1368             return false;
1369         }
1370         return true;
1371     }
1372
1373     private static String createImageFilename(long createTime, int taskId) {
1374         return String.valueOf(taskId) + ACTIVITY_ICON_SUFFIX + createTime +
1375                 TaskPersister.IMAGE_EXTENSION;
1376     }
1377
1378     void setTaskDescription(TaskDescription _taskDescription) {
1379         Bitmap icon;
1380         if (_taskDescription.getIconFilename() == null &&
1381                 (icon = _taskDescription.getIcon()) != null) {
1382             final String iconFilename = createImageFilename(createTime, task.taskId);
1383             final File iconFile = new File(TaskPersister.getUserImagesDir(userId), iconFilename);
1384             final String iconFilePath = iconFile.getAbsolutePath();
1385             service.mRecentTasks.saveImage(icon, iconFilePath);
1386             _taskDescription.setIconFilename(iconFilePath);
1387         }
1388         taskDescription = _taskDescription;
1389     }
1390
1391     void setVoiceSessionLocked(IVoiceInteractionSession session) {
1392         voiceSession = session;
1393         pendingVoiceInteractionStart = false;
1394     }
1395
1396     void clearVoiceSessionLocked() {
1397         voiceSession = null;
1398         pendingVoiceInteractionStart = false;
1399     }
1400
1401     void showStartingWindow(ActivityRecord prev, boolean createIfNeeded) {
1402         final CompatibilityInfo compatInfo =
1403                 service.compatibilityInfoForPackageLocked(info.applicationInfo);
1404         final boolean shown = service.mWindowManager.setAppStartingWindow(
1405                 appToken, packageName, theme, compatInfo, nonLocalizedLabel, labelRes, icon,
1406                 logo, windowFlags, prev != null ? prev.appToken : null, createIfNeeded);
1407         if (shown) {
1408             mStartingWindowState = STARTING_WINDOW_SHOWN;
1409         }
1410     }
1411
1412     void saveToXml(XmlSerializer out) throws IOException, XmlPullParserException {
1413         out.attribute(null, ATTR_ID, String.valueOf(createTime));
1414         out.attribute(null, ATTR_LAUNCHEDFROMUID, String.valueOf(launchedFromUid));
1415         if (launchedFromPackage != null) {
1416             out.attribute(null, ATTR_LAUNCHEDFROMPACKAGE, launchedFromPackage);
1417         }
1418         if (resolvedType != null) {
1419             out.attribute(null, ATTR_RESOLVEDTYPE, resolvedType);
1420         }
1421         out.attribute(null, ATTR_COMPONENTSPECIFIED, String.valueOf(componentSpecified));
1422         out.attribute(null, ATTR_USERID, String.valueOf(userId));
1423
1424         if (taskDescription != null) {
1425             taskDescription.saveToXml(out);
1426         }
1427
1428         out.startTag(null, TAG_INTENT);
1429         intent.saveToXml(out);
1430         out.endTag(null, TAG_INTENT);
1431
1432         if (isPersistable() && persistentState != null) {
1433             out.startTag(null, TAG_PERSISTABLEBUNDLE);
1434             persistentState.saveToXml(out);
1435             out.endTag(null, TAG_PERSISTABLEBUNDLE);
1436         }
1437     }
1438
1439     static ActivityRecord restoreFromXml(XmlPullParser in,
1440             ActivityStackSupervisor stackSupervisor) throws IOException, XmlPullParserException {
1441         Intent intent = null;
1442         PersistableBundle persistentState = null;
1443         int launchedFromUid = 0;
1444         String launchedFromPackage = null;
1445         String resolvedType = null;
1446         boolean componentSpecified = false;
1447         int userId = 0;
1448         long createTime = -1;
1449         final int outerDepth = in.getDepth();
1450         TaskDescription taskDescription = new TaskDescription();
1451
1452         for (int attrNdx = in.getAttributeCount() - 1; attrNdx >= 0; --attrNdx) {
1453             final String attrName = in.getAttributeName(attrNdx);
1454             final String attrValue = in.getAttributeValue(attrNdx);
1455             if (TaskPersister.DEBUG) Slog.d(TaskPersister.TAG,
1456                         "ActivityRecord: attribute name=" + attrName + " value=" + attrValue);
1457             if (ATTR_ID.equals(attrName)) {
1458                 createTime = Long.valueOf(attrValue);
1459             } else if (ATTR_LAUNCHEDFROMUID.equals(attrName)) {
1460                 launchedFromUid = Integer.parseInt(attrValue);
1461             } else if (ATTR_LAUNCHEDFROMPACKAGE.equals(attrName)) {
1462                 launchedFromPackage = attrValue;
1463             } else if (ATTR_RESOLVEDTYPE.equals(attrName)) {
1464                 resolvedType = attrValue;
1465             } else if (ATTR_COMPONENTSPECIFIED.equals(attrName)) {
1466                 componentSpecified = Boolean.valueOf(attrValue);
1467             } else if (ATTR_USERID.equals(attrName)) {
1468                 userId = Integer.parseInt(attrValue);
1469             } else if (attrName.startsWith(TaskDescription.ATTR_TASKDESCRIPTION_PREFIX)) {
1470                 taskDescription.restoreFromXml(attrName, attrValue);
1471             } else {
1472                 Log.d(TAG, "Unknown ActivityRecord attribute=" + attrName);
1473             }
1474         }
1475
1476         int event;
1477         while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
1478                 (event != XmlPullParser.END_TAG || in.getDepth() >= outerDepth)) {
1479             if (event == XmlPullParser.START_TAG) {
1480                 final String name = in.getName();
1481                 if (TaskPersister.DEBUG)
1482                         Slog.d(TaskPersister.TAG, "ActivityRecord: START_TAG name=" + name);
1483                 if (TAG_INTENT.equals(name)) {
1484                     intent = Intent.restoreFromXml(in);
1485                     if (TaskPersister.DEBUG)
1486                             Slog.d(TaskPersister.TAG, "ActivityRecord: intent=" + intent);
1487                 } else if (TAG_PERSISTABLEBUNDLE.equals(name)) {
1488                     persistentState = PersistableBundle.restoreFromXml(in);
1489                     if (TaskPersister.DEBUG) Slog.d(TaskPersister.TAG,
1490                             "ActivityRecord: persistentState=" + persistentState);
1491                 } else {
1492                     Slog.w(TAG, "restoreActivity: unexpected name=" + name);
1493                     XmlUtils.skipCurrentTag(in);
1494                 }
1495             }
1496         }
1497
1498         if (intent == null) {
1499             throw new XmlPullParserException("restoreActivity error intent=" + intent);
1500         }
1501
1502         final ActivityManagerService service = stackSupervisor.mService;
1503         final ActivityInfo aInfo = stackSupervisor.resolveActivity(intent, resolvedType, 0, null,
1504                 userId);
1505         if (aInfo == null) {
1506             throw new XmlPullParserException("restoreActivity resolver error. Intent=" + intent +
1507                     " resolvedType=" + resolvedType);
1508         }
1509         final ActivityRecord r = new ActivityRecord(service, /*caller*/null, launchedFromUid,
1510                 launchedFromPackage, intent, resolvedType, aInfo, service.getConfiguration(),
1511                 null, null, 0, componentSpecified, false, stackSupervisor, null, null, null);
1512
1513         r.persistentState = persistentState;
1514         r.taskDescription = taskDescription;
1515         r.createTime = createTime;
1516
1517         return r;
1518     }
1519
1520     private static String activityTypeToString(int type) {
1521         switch (type) {
1522             case APPLICATION_ACTIVITY_TYPE: return "APPLICATION_ACTIVITY_TYPE";
1523             case HOME_ACTIVITY_TYPE: return "HOME_ACTIVITY_TYPE";
1524             case RECENTS_ACTIVITY_TYPE: return "RECENTS_ACTIVITY_TYPE";
1525             default: return Integer.toString(type);
1526         }
1527     }
1528
1529     @Override
1530     public String toString() {
1531         if (stringName != null) {
1532             return stringName + " t" + (task == null ? INVALID_TASK_ID : task.taskId) +
1533                     (finishing ? " f}" : "}");
1534         }
1535         StringBuilder sb = new StringBuilder(128);
1536         sb.append("ActivityRecord{");
1537         sb.append(Integer.toHexString(System.identityHashCode(this)));
1538         sb.append(" u");
1539         sb.append(userId);
1540         sb.append(' ');
1541         sb.append(intent.getComponent().flattenToShortString());
1542         stringName = sb.toString();
1543         return toString();
1544     }
1545 }