PageRenderTime 107ms CodeModel.GetById 19ms app.highlight 79ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://github.com/aizuzi/platform_frameworks_base
Java | 1066 lines | 929 code | 80 blank | 57 comment | 285 complexity | d74914d4a010ee4698e87614d94fd11d MD5 | raw file
   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
  17package com.android.server.am;
  18
  19import android.os.Trace;
  20import com.android.internal.R.styleable;
  21import com.android.internal.app.ResolverActivity;
  22import com.android.server.AttributeCache;
  23import com.android.server.am.ActivityStack.ActivityState;
  24
  25import android.app.ActivityOptions;
  26import android.app.ResultInfo;
  27import android.content.ComponentName;
  28import android.content.Intent;
  29import android.content.pm.ActivityInfo;
  30import android.content.pm.ApplicationInfo;
  31import android.content.res.CompatibilityInfo;
  32import android.content.res.Configuration;
  33import android.graphics.Bitmap;
  34import android.graphics.Rect;
  35import android.os.Build;
  36import android.os.Bundle;
  37import android.os.IBinder;
  38import android.os.Message;
  39import android.os.Process;
  40import android.os.RemoteException;
  41import android.os.SystemClock;
  42import android.os.UserHandle;
  43import android.util.EventLog;
  44import android.util.Log;
  45import android.util.Slog;
  46import android.util.TimeUtils;
  47import android.view.IApplicationToken;
  48import android.view.WindowManager;
  49
  50import java.io.PrintWriter;
  51import java.lang.ref.WeakReference;
  52import java.util.ArrayList;
  53import java.util.HashSet;
  54
  55/**
  56 * An entry in the history stack, representing an activity.
  57 */
  58final class ActivityRecord {
  59    static final String TAG = ActivityManagerService.TAG;
  60    static final boolean DEBUG_SAVED_STATE = ActivityStackSupervisor.DEBUG_SAVED_STATE;
  61    final public static String RECENTS_PACKAGE_NAME = "com.android.systemui.recent";
  62
  63    final ActivityManagerService service; // owner
  64    final IApplicationToken.Stub appToken; // window manager token
  65    final ActivityInfo info; // all about me
  66    final int launchedFromUid; // always the uid who started the activity.
  67    final String launchedFromPackage; // always the package who started the activity.
  68    final int userId;          // Which user is this running for?
  69    final Intent intent;    // the original intent that generated us
  70    final ComponentName realActivity;  // the intent component, or target of an alias.
  71    final String shortComponentName; // the short component name of the intent
  72    final String resolvedType; // as per original caller;
  73    final String packageName; // the package implementing intent's component
  74    final String processName; // process where this component wants to run
  75    final String taskAffinity; // as per ActivityInfo.taskAffinity
  76    final boolean stateNotNeeded; // As per ActivityInfo.flags
  77    boolean fullscreen; // covers the full screen?
  78    final boolean noDisplay;  // activity is not displayed?
  79    final boolean componentSpecified;  // did caller specifiy an explicit component?
  80
  81    static final int APPLICATION_ACTIVITY_TYPE = 0;
  82    static final int HOME_ACTIVITY_TYPE = 1;
  83    static final int RECENTS_ACTIVITY_TYPE = 2;
  84    int mActivityType;
  85
  86    final String baseDir;   // where activity source (resources etc) located
  87    final String resDir;   // where public activity source (public resources etc) located
  88    final String dataDir;   // where activity data should go
  89    CharSequence nonLocalizedLabel;  // the label information from the package mgr.
  90    int labelRes;           // the label information from the package mgr.
  91    int icon;               // resource identifier of activity's icon.
  92    int logo;               // resource identifier of activity's logo.
  93    int theme;              // resource identifier of activity's theme.
  94    int realTheme;          // actual theme resource we will use, never 0.
  95    int windowFlags;        // custom window flags for preview window.
  96    TaskRecord task;        // the task this is in.
  97    ThumbnailHolder thumbHolder; // where our thumbnails should go.
  98    long displayStartTime;  // when we started launching this activity
  99    long fullyDrawnStartTime; // when we started launching this activity
 100    long startTime;         // last time this activity was started
 101    long lastVisibleTime;   // last time this activity became visible
 102    long cpuTimeAtResume;   // the cpu time of host process at the time of resuming activity
 103    long pauseTime;         // last time we started pausing the activity
 104    long launchTickTime;    // base time for launch tick messages
 105    Configuration configuration; // configuration activity was last running in
 106    CompatibilityInfo compat;// last used compatibility mode
 107    ActivityRecord resultTo; // who started this entry, so will get our reply
 108    final String resultWho; // additional identifier for use by resultTo.
 109    final int requestCode;  // code given by requester (resultTo)
 110    ArrayList<ResultInfo> results; // pending ActivityResult objs we have received
 111    HashSet<WeakReference<PendingIntentRecord>> pendingResults; // all pending intents for this act
 112    ArrayList<Intent> newIntents; // any pending new intents for single-top mode
 113    ActivityOptions pendingOptions; // most recently given options
 114    HashSet<ConnectionRecord> connections; // All ConnectionRecord we hold
 115    UriPermissionOwner uriPermissions; // current special URI access perms.
 116    ProcessRecord app;      // if non-null, hosting application
 117    ActivityState state;    // current state we are in
 118    Bundle  icicle;         // last saved activity state
 119    boolean frontOfTask;    // is this the root activity of its task?
 120    boolean launchFailed;   // set if a launched failed, to abort on 2nd try
 121    boolean haveState;      // have we gotten the last activity state?
 122    boolean stopped;        // is activity pause finished?
 123    boolean delayedResume;  // not yet resumed because of stopped app switches?
 124    boolean finishing;      // activity in pending finish list?
 125    boolean configDestroy;  // need to destroy due to config change?
 126    int configChangeFlags;  // which config values have changed
 127    boolean keysPaused;     // has key dispatching been paused for it?
 128    int launchMode;         // the launch mode activity attribute.
 129    boolean visible;        // does this activity's window need to be shown?
 130    boolean sleeping;       // have we told the activity to sleep?
 131    boolean waitingVisible; // true if waiting for a new act to become vis
 132    boolean nowVisible;     // is this activity's window visible?
 133    boolean thumbnailNeeded;// has someone requested a thumbnail?
 134    boolean idle;           // has the activity gone idle?
 135    boolean hasBeenLaunched;// has this activity ever been launched?
 136    boolean frozenBeforeDestroy;// has been frozen but not yet destroyed.
 137    boolean immersive;      // immersive mode (don't interrupt if possible)
 138    boolean forceNewConfig; // force re-create with new config next time
 139    int launchCount;        // count of launches since last state
 140    long lastLaunchTime;    // time of last lauch of this activity
 141
 142    String stringName;      // for caching of toString().
 143
 144    private boolean inHistory;  // are we in the history stack?
 145    final ActivityStackSupervisor mStackSupervisor;
 146
 147    void dump(PrintWriter pw, String prefix) {
 148        final long now = SystemClock.uptimeMillis();
 149        pw.print(prefix); pw.print("packageName="); pw.print(packageName);
 150                pw.print(" processName="); pw.println(processName);
 151        pw.print(prefix); pw.print("launchedFromUid="); pw.print(launchedFromUid);
 152                pw.print(" launchedFromPackage="); pw.print(launchedFromPackage);
 153                pw.print(" userId="); pw.println(userId);
 154        pw.print(prefix); pw.print("app="); pw.println(app);
 155        pw.print(prefix); pw.println(intent.toInsecureStringWithClip());
 156        pw.print(prefix); pw.print("frontOfTask="); pw.print(frontOfTask);
 157                pw.print(" task="); pw.println(task);
 158        pw.print(prefix); pw.print("taskAffinity="); pw.println(taskAffinity);
 159        pw.print(prefix); pw.print("realActivity=");
 160                pw.println(realActivity.flattenToShortString());
 161        pw.print(prefix); pw.print("baseDir="); pw.println(baseDir);
 162        if (!resDir.equals(baseDir)) {
 163            pw.print(prefix); pw.print("resDir="); pw.println(resDir);
 164        }
 165        pw.print(prefix); pw.print("dataDir="); pw.println(dataDir);
 166        pw.print(prefix); pw.print("stateNotNeeded="); pw.print(stateNotNeeded);
 167                pw.print(" componentSpecified="); pw.print(componentSpecified);
 168                pw.print(" mActivityType="); pw.println(mActivityType);
 169        pw.print(prefix); pw.print("compat="); pw.print(compat);
 170                pw.print(" labelRes=0x"); pw.print(Integer.toHexString(labelRes));
 171                pw.print(" icon=0x"); pw.print(Integer.toHexString(icon));
 172                pw.print(" theme=0x"); pw.println(Integer.toHexString(theme));
 173        pw.print(prefix); pw.print("config="); pw.println(configuration);
 174        if (resultTo != null || resultWho != null) {
 175            pw.print(prefix); pw.print("resultTo="); pw.print(resultTo);
 176                    pw.print(" resultWho="); pw.print(resultWho);
 177                    pw.print(" resultCode="); pw.println(requestCode);
 178        }
 179        if (results != null) {
 180            pw.print(prefix); pw.print("results="); pw.println(results);
 181        }
 182        if (pendingResults != null && pendingResults.size() > 0) {
 183            pw.print(prefix); pw.println("Pending Results:");
 184            for (WeakReference<PendingIntentRecord> wpir : pendingResults) {
 185                PendingIntentRecord pir = wpir != null ? wpir.get() : null;
 186                pw.print(prefix); pw.print("  - ");
 187                if (pir == null) {
 188                    pw.println("null");
 189                } else {
 190                    pw.println(pir);
 191                    pir.dump(pw, prefix + "    ");
 192                }
 193            }
 194        }
 195        if (newIntents != null && newIntents.size() > 0) {
 196            pw.print(prefix); pw.println("Pending New Intents:");
 197            for (int i=0; i<newIntents.size(); i++) {
 198                Intent intent = newIntents.get(i);
 199                pw.print(prefix); pw.print("  - ");
 200                if (intent == null) {
 201                    pw.println("null");
 202                } else {
 203                    pw.println(intent.toShortString(false, true, false, true));
 204                }
 205            }
 206        }
 207        if (pendingOptions != null) {
 208            pw.print(prefix); pw.print("pendingOptions="); pw.println(pendingOptions);
 209        }
 210        if (uriPermissions != null) {
 211            if (uriPermissions.readUriPermissions != null) {
 212                pw.print(prefix); pw.print("readUriPermissions=");
 213                        pw.println(uriPermissions.readUriPermissions);
 214            }
 215            if (uriPermissions.writeUriPermissions != null) {
 216                pw.print(prefix); pw.print("writeUriPermissions=");
 217                        pw.println(uriPermissions.writeUriPermissions);
 218            }
 219        }
 220        pw.print(prefix); pw.print("launchFailed="); pw.print(launchFailed);
 221                pw.print(" launchCount="); pw.print(launchCount);
 222                pw.print(" lastLaunchTime=");
 223                if (lastLaunchTime == 0) pw.print("0");
 224                else TimeUtils.formatDuration(lastLaunchTime, now, pw);
 225                pw.println();
 226        pw.print(prefix); pw.print("haveState="); pw.print(haveState);
 227                pw.print(" icicle="); pw.println(icicle);
 228        pw.print(prefix); pw.print("state="); pw.print(state);
 229                pw.print(" stopped="); pw.print(stopped);
 230                pw.print(" delayedResume="); pw.print(delayedResume);
 231                pw.print(" finishing="); pw.println(finishing);
 232        pw.print(prefix); pw.print("keysPaused="); pw.print(keysPaused);
 233                pw.print(" inHistory="); pw.print(inHistory);
 234                pw.print(" visible="); pw.print(visible);
 235                pw.print(" sleeping="); pw.print(sleeping);
 236                pw.print(" idle="); pw.println(idle);
 237        pw.print(prefix); pw.print("fullscreen="); pw.print(fullscreen);
 238                pw.print(" noDisplay="); pw.print(noDisplay);
 239                pw.print(" immersive="); pw.print(immersive);
 240                pw.print(" launchMode="); pw.println(launchMode);
 241        pw.print(prefix); pw.print("frozenBeforeDestroy="); pw.print(frozenBeforeDestroy);
 242                pw.print(" thumbnailNeeded="); pw.print(thumbnailNeeded);
 243                pw.print(" forceNewConfig="); pw.println(forceNewConfig);
 244        pw.print(prefix); pw.print("mActivityType=");
 245                pw.println(activityTypeToString(mActivityType));
 246        pw.print(prefix); pw.print("thumbHolder: ");
 247                pw.print(Integer.toHexString(System.identityHashCode(thumbHolder)));
 248                if (thumbHolder != null) {
 249                    pw.print(" bm="); pw.print(thumbHolder.lastThumbnail);
 250                    pw.print(" desc="); pw.print(thumbHolder.lastDescription);
 251                }
 252                pw.println();
 253        if (displayStartTime != 0 || startTime != 0) {
 254            pw.print(prefix); pw.print("displayStartTime=");
 255                    if (displayStartTime == 0) pw.print("0");
 256                    else TimeUtils.formatDuration(displayStartTime, now, pw);
 257                    pw.print(" startTime=");
 258                    if (startTime == 0) pw.print("0");
 259                    else TimeUtils.formatDuration(startTime, now, pw);
 260                    pw.println();
 261        }
 262        if (lastVisibleTime != 0 || waitingVisible || nowVisible) {
 263            pw.print(prefix); pw.print("waitingVisible="); pw.print(waitingVisible);
 264                    pw.print(" nowVisible="); pw.print(nowVisible);
 265                    pw.print(" lastVisibleTime=");
 266                    if (lastVisibleTime == 0) pw.print("0");
 267                    else TimeUtils.formatDuration(lastVisibleTime, now, pw);
 268                    pw.println();
 269        }
 270        if (configDestroy || configChangeFlags != 0) {
 271            pw.print(prefix); pw.print("configDestroy="); pw.print(configDestroy);
 272                    pw.print(" configChangeFlags=");
 273                    pw.println(Integer.toHexString(configChangeFlags));
 274        }
 275        if (connections != null) {
 276            pw.print(prefix); pw.print("connections="); pw.println(connections);
 277        }
 278    }
 279
 280    static class Token extends IApplicationToken.Stub {
 281        final WeakReference<ActivityRecord> weakActivity;
 282
 283        Token(ActivityRecord activity) {
 284            weakActivity = new WeakReference<ActivityRecord>(activity);
 285        }
 286
 287        @Override public void windowsDrawn() {
 288            ActivityRecord activity = weakActivity.get();
 289            if (activity != null) {
 290                activity.windowsDrawn();
 291            }
 292        }
 293
 294        @Override public void windowsVisible() {
 295            ActivityRecord activity = weakActivity.get();
 296            if (activity != null) {
 297                activity.windowsVisible();
 298            }
 299        }
 300
 301        @Override public void windowsGone() {
 302            ActivityRecord activity = weakActivity.get();
 303            if (activity != null) {
 304                activity.windowsGone();
 305            }
 306        }
 307
 308        @Override public boolean keyDispatchingTimedOut(String reason) {
 309            ActivityRecord activity = weakActivity.get();
 310            return activity != null && activity.keyDispatchingTimedOut(reason);
 311        }
 312
 313        @Override public long getKeyDispatchingTimeout() {
 314            ActivityRecord activity = weakActivity.get();
 315            if (activity != null) {
 316                return activity.getKeyDispatchingTimeout();
 317            }
 318            return 0;
 319        }
 320
 321        @Override
 322        public String toString() {
 323            StringBuilder sb = new StringBuilder(128);
 324            sb.append("Token{");
 325            sb.append(Integer.toHexString(System.identityHashCode(this)));
 326            sb.append(' ');
 327            sb.append(weakActivity.get());
 328            sb.append('}');
 329            return sb.toString();
 330        }
 331    }
 332
 333    static ActivityRecord forToken(IBinder token) {
 334        try {
 335            return token != null ? ((Token)token).weakActivity.get() : null;
 336        } catch (ClassCastException e) {
 337            Slog.w(ActivityManagerService.TAG, "Bad activity token: " + token, e);
 338            return null;
 339        }
 340    }
 341
 342    boolean isNotResolverActivity() {
 343        return !ResolverActivity.class.getName().equals(realActivity.getClassName());
 344    }
 345
 346    ActivityRecord(ActivityManagerService _service, ProcessRecord _caller,
 347            int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
 348            ActivityInfo aInfo, Configuration _configuration,
 349            ActivityRecord _resultTo, String _resultWho, int _reqCode,
 350            boolean _componentSpecified, ActivityStackSupervisor supervisor) {
 351        service = _service;
 352        appToken = new Token(this);
 353        info = aInfo;
 354        launchedFromUid = _launchedFromUid;
 355        launchedFromPackage = _launchedFromPackage;
 356        userId = UserHandle.getUserId(aInfo.applicationInfo.uid);
 357        intent = _intent;
 358        shortComponentName = _intent.getComponent().flattenToShortString();
 359        resolvedType = _resolvedType;
 360        componentSpecified = _componentSpecified;
 361        configuration = _configuration;
 362        resultTo = _resultTo;
 363        resultWho = _resultWho;
 364        requestCode = _reqCode;
 365        state = ActivityState.INITIALIZING;
 366        frontOfTask = false;
 367        launchFailed = false;
 368        stopped = false;
 369        delayedResume = false;
 370        finishing = false;
 371        configDestroy = false;
 372        keysPaused = false;
 373        inHistory = false;
 374        visible = true;
 375        waitingVisible = false;
 376        nowVisible = false;
 377        thumbnailNeeded = false;
 378        idle = false;
 379        hasBeenLaunched = false;
 380        mStackSupervisor = supervisor;
 381
 382        // This starts out true, since the initial state of an activity
 383        // is that we have everything, and we shouldn't never consider it
 384        // lacking in state to be removed if it dies.
 385        haveState = true;
 386
 387        if (aInfo != null) {
 388            if (aInfo.targetActivity == null
 389                    || aInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE
 390                    || aInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
 391                realActivity = _intent.getComponent();
 392            } else {
 393                realActivity = new ComponentName(aInfo.packageName,
 394                        aInfo.targetActivity);
 395            }
 396            taskAffinity = aInfo.taskAffinity;
 397            stateNotNeeded = (aInfo.flags&
 398                    ActivityInfo.FLAG_STATE_NOT_NEEDED) != 0;
 399            baseDir = aInfo.applicationInfo.sourceDir;
 400            resDir = aInfo.applicationInfo.publicSourceDir;
 401            dataDir = aInfo.applicationInfo.dataDir;
 402            nonLocalizedLabel = aInfo.nonLocalizedLabel;
 403            labelRes = aInfo.labelRes;
 404            if (nonLocalizedLabel == null && labelRes == 0) {
 405                ApplicationInfo app = aInfo.applicationInfo;
 406                nonLocalizedLabel = app.nonLocalizedLabel;
 407                labelRes = app.labelRes;
 408            }
 409            icon = aInfo.getIconResource();
 410            logo = aInfo.getLogoResource();
 411            theme = aInfo.getThemeResource();
 412            realTheme = theme;
 413            if (realTheme == 0) {
 414                realTheme = aInfo.applicationInfo.targetSdkVersion
 415                        < Build.VERSION_CODES.HONEYCOMB
 416                        ? android.R.style.Theme
 417                        : android.R.style.Theme_Holo;
 418            }
 419            if ((aInfo.flags&ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
 420                windowFlags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
 421            }
 422            if ((aInfo.flags&ActivityInfo.FLAG_MULTIPROCESS) != 0
 423                    && _caller != null
 424                    && (aInfo.applicationInfo.uid == Process.SYSTEM_UID
 425                            || aInfo.applicationInfo.uid == _caller.info.uid)) {
 426                processName = _caller.processName;
 427            } else {
 428                processName = aInfo.processName;
 429            }
 430
 431            if (intent != null && (aInfo.flags & ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS) != 0) {
 432                intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
 433            }
 434
 435            packageName = aInfo.applicationInfo.packageName;
 436            launchMode = aInfo.launchMode;
 437
 438            AttributeCache.Entry ent = AttributeCache.instance().get(packageName,
 439                    realTheme, com.android.internal.R.styleable.Window, userId);
 440            fullscreen = ent != null && !ent.array.getBoolean(
 441                    com.android.internal.R.styleable.Window_windowIsFloating, false)
 442                    && !ent.array.getBoolean(
 443                    com.android.internal.R.styleable.Window_windowIsTranslucent, false);
 444            noDisplay = ent != null && ent.array.getBoolean(
 445                    com.android.internal.R.styleable.Window_windowNoDisplay, false);
 446
 447            if ((!_componentSpecified || _launchedFromUid == Process.myUid()
 448                    || _launchedFromUid == 0) &&
 449                    Intent.ACTION_MAIN.equals(_intent.getAction()) &&
 450                    _intent.hasCategory(Intent.CATEGORY_HOME) &&
 451                    _intent.getCategories().size() == 1 &&
 452                    _intent.getData() == null &&
 453                    _intent.getType() == null &&
 454                    (intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
 455                    isNotResolverActivity()) {
 456                // This sure looks like a home activity!
 457                mActivityType = HOME_ACTIVITY_TYPE;
 458            } else if (realActivity.getClassName().contains(RECENTS_PACKAGE_NAME)) {
 459                mActivityType = RECENTS_ACTIVITY_TYPE;
 460            } else {
 461                mActivityType = APPLICATION_ACTIVITY_TYPE;
 462            }
 463
 464            immersive = (aInfo.flags & ActivityInfo.FLAG_IMMERSIVE) != 0;
 465        } else {
 466            realActivity = null;
 467            taskAffinity = null;
 468            stateNotNeeded = false;
 469            baseDir = null;
 470            resDir = null;
 471            dataDir = null;
 472            processName = null;
 473            packageName = null;
 474            fullscreen = true;
 475            noDisplay = false;
 476            mActivityType = APPLICATION_ACTIVITY_TYPE;
 477            immersive = false;
 478        }
 479    }
 480
 481    void setTask(TaskRecord newTask, ThumbnailHolder newThumbHolder, boolean isRoot) {
 482        if (task != null && task.removeActivity(this)) {
 483            if (task != newTask) {
 484                mStackSupervisor.removeTask(task);
 485            } else {
 486                Slog.d(TAG, "!!! REMOVE THIS LOG !!! setTask: nearly removed stack=" +
 487                        (newTask == null ? null : newTask.stack));
 488            }
 489        }
 490        if (inHistory && !finishing) {
 491            if (task != null) {
 492                task.numActivities--;
 493            }
 494            if (newTask != null) {
 495                newTask.numActivities++;
 496            }
 497        }
 498        if (newThumbHolder == null) {
 499            newThumbHolder = newTask;
 500        }
 501        task = newTask;
 502        if (!isRoot && (intent.getFlags()&Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0) {
 503            // This is the start of a new sub-task.
 504            if (thumbHolder == null) {
 505                thumbHolder = new ThumbnailHolder();
 506            }
 507        } else {
 508            thumbHolder = newThumbHolder;
 509        }
 510    }
 511
 512    boolean changeWindowTranslucency(boolean toOpaque) {
 513        if (fullscreen == toOpaque) {
 514            return false;
 515        }
 516        AttributeCache.Entry ent =
 517                AttributeCache.instance().get(packageName, realTheme, styleable.Window, userId);
 518        if (ent == null
 519                || !ent.array.getBoolean(styleable.Window_windowIsTranslucent, false)
 520                || ent.array.getBoolean(styleable.Window_windowIsFloating, false)) {
 521            return false;
 522        }
 523
 524        // Keep track of the number of fullscreen activities in this task.
 525        task.numFullscreen += toOpaque ? +1 : -1;
 526
 527        fullscreen = toOpaque;
 528        return true;
 529    }
 530
 531    void putInHistory() {
 532        if (!inHistory) {
 533            inHistory = true;
 534            if (task != null && !finishing) {
 535                task.numActivities++;
 536            }
 537        }
 538    }
 539
 540    void takeFromHistory() {
 541        if (inHistory) {
 542            inHistory = false;
 543            if (task != null && !finishing) {
 544                task.numActivities--;
 545                task = null;
 546            }
 547            clearOptionsLocked();
 548        }
 549    }
 550
 551    boolean isInHistory() {
 552        return inHistory;
 553    }
 554
 555    boolean isHomeActivity() {
 556        return mActivityType == HOME_ACTIVITY_TYPE;
 557    }
 558
 559    boolean isRecentsActivity() {
 560        return mActivityType == RECENTS_ACTIVITY_TYPE;
 561    }
 562
 563    boolean isApplicationActivity() {
 564        return mActivityType == APPLICATION_ACTIVITY_TYPE;
 565    }
 566
 567    void makeFinishing() {
 568        if (!finishing) {
 569            finishing = true;
 570            if (task != null && inHistory) {
 571                task.numActivities--;
 572            }
 573            if (stopped) {
 574                clearOptionsLocked();
 575            }
 576        }
 577    }
 578
 579    boolean isRootActivity() {
 580        final ArrayList<ActivityRecord> activities = task.mActivities;
 581        return activities.size() == 0 || this == activities.get(0);
 582    }
 583
 584    UriPermissionOwner getUriPermissionsLocked() {
 585        if (uriPermissions == null) {
 586            uriPermissions = new UriPermissionOwner(service, this);
 587        }
 588        return uriPermissions;
 589    }
 590
 591    void addResultLocked(ActivityRecord from, String resultWho,
 592            int requestCode, int resultCode,
 593            Intent resultData) {
 594        ActivityResult r = new ActivityResult(from, resultWho,
 595        		requestCode, resultCode, resultData);
 596        if (results == null) {
 597            results = new ArrayList<ResultInfo>();
 598        }
 599        results.add(r);
 600    }
 601
 602    void removeResultsLocked(ActivityRecord from, String resultWho,
 603            int requestCode) {
 604        if (results != null) {
 605            for (int i=results.size()-1; i>=0; i--) {
 606                ActivityResult r = (ActivityResult)results.get(i);
 607                if (r.mFrom != from) continue;
 608                if (r.mResultWho == null) {
 609                    if (resultWho != null) continue;
 610                } else {
 611                    if (!r.mResultWho.equals(resultWho)) continue;
 612                }
 613                if (r.mRequestCode != requestCode) continue;
 614
 615                results.remove(i);
 616            }
 617        }
 618    }
 619
 620    void addNewIntentLocked(Intent intent) {
 621        if (newIntents == null) {
 622            newIntents = new ArrayList<Intent>();
 623        }
 624        newIntents.add(intent);
 625    }
 626
 627    /**
 628     * Deliver a new Intent to an existing activity, so that its onNewIntent()
 629     * method will be called at the proper time.
 630     */
 631    final void deliverNewIntentLocked(int callingUid, Intent intent) {
 632        // The activity now gets access to the data associated with this Intent.
 633        service.grantUriPermissionFromIntentLocked(callingUid, packageName,
 634                intent, getUriPermissionsLocked());
 635        // We want to immediately deliver the intent to the activity if
 636        // it is currently the top resumed activity...  however, if the
 637        // device is sleeping, then all activities are stopped, so in that
 638        // case we will deliver it if this is the current top activity on its
 639        // stack.
 640        boolean unsent = true;
 641        if ((state == ActivityState.RESUMED || (service.mSleeping
 642                        && task.stack.topRunningActivityLocked(null) == this))
 643                && app != null && app.thread != null) {
 644            try {
 645                ArrayList<Intent> ar = new ArrayList<Intent>();
 646                intent = new Intent(intent);
 647                ar.add(intent);
 648                app.thread.scheduleNewIntent(ar, appToken);
 649                unsent = false;
 650            } catch (RemoteException e) {
 651                Slog.w(ActivityManagerService.TAG,
 652                        "Exception thrown sending new intent to " + this, e);
 653            } catch (NullPointerException e) {
 654                Slog.w(ActivityManagerService.TAG,
 655                        "Exception thrown sending new intent to " + this, e);
 656            }
 657        }
 658        if (unsent) {
 659            addNewIntentLocked(new Intent(intent));
 660        }
 661    }
 662
 663    void updateOptionsLocked(Bundle options) {
 664        if (options != null) {
 665            if (pendingOptions != null) {
 666                pendingOptions.abort();
 667            }
 668            pendingOptions = new ActivityOptions(options);
 669        }
 670    }
 671
 672    void updateOptionsLocked(ActivityOptions options) {
 673        if (options != null) {
 674            if (pendingOptions != null) {
 675                pendingOptions.abort();
 676            }
 677            pendingOptions = options;
 678        }
 679    }
 680
 681    void applyOptionsLocked() {
 682        if (pendingOptions != null) {
 683            final int animationType = pendingOptions.getAnimationType();
 684            switch (animationType) {
 685                case ActivityOptions.ANIM_CUSTOM:
 686                    service.mWindowManager.overridePendingAppTransition(
 687                            pendingOptions.getPackageName(),
 688                            pendingOptions.getCustomEnterResId(),
 689                            pendingOptions.getCustomExitResId(),
 690                            pendingOptions.getOnAnimationStartListener());
 691                    break;
 692                case ActivityOptions.ANIM_SCALE_UP:
 693                    service.mWindowManager.overridePendingAppTransitionScaleUp(
 694                            pendingOptions.getStartX(), pendingOptions.getStartY(),
 695                            pendingOptions.getStartWidth(), pendingOptions.getStartHeight());
 696                    if (intent.getSourceBounds() == null) {
 697                        intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
 698                                pendingOptions.getStartY(),
 699                                pendingOptions.getStartX()+pendingOptions.getStartWidth(),
 700                                pendingOptions.getStartY()+pendingOptions.getStartHeight()));
 701                    }
 702                    break;
 703                case ActivityOptions.ANIM_THUMBNAIL_SCALE_UP:
 704                case ActivityOptions.ANIM_THUMBNAIL_SCALE_DOWN:
 705                    boolean scaleUp = (animationType == ActivityOptions.ANIM_THUMBNAIL_SCALE_UP);
 706                    service.mWindowManager.overridePendingAppTransitionThumb(
 707                            pendingOptions.getThumbnail(),
 708                            pendingOptions.getStartX(), pendingOptions.getStartY(),
 709                            pendingOptions.getOnAnimationStartListener(),
 710                            scaleUp);
 711                    if (intent.getSourceBounds() == null) {
 712                        intent.setSourceBounds(new Rect(pendingOptions.getStartX(),
 713                                pendingOptions.getStartY(),
 714                                pendingOptions.getStartX()
 715                                        + pendingOptions.getThumbnail().getWidth(),
 716                                pendingOptions.getStartY()
 717                                        + pendingOptions.getThumbnail().getHeight()));
 718                    }
 719                    break;
 720            }
 721            pendingOptions = null;
 722        }
 723    }
 724
 725    void clearOptionsLocked() {
 726        if (pendingOptions != null) {
 727            pendingOptions.abort();
 728            pendingOptions = null;
 729        }
 730    }
 731
 732    ActivityOptions takeOptionsLocked() {
 733        ActivityOptions opts = pendingOptions;
 734        pendingOptions = null;
 735        return opts;
 736    }
 737
 738    void removeUriPermissionsLocked() {
 739        if (uriPermissions != null) {
 740            uriPermissions.removeUriPermissionsLocked();
 741            uriPermissions = null;
 742        }
 743    }
 744
 745    void pauseKeyDispatchingLocked() {
 746        if (!keysPaused) {
 747            keysPaused = true;
 748            service.mWindowManager.pauseKeyDispatching(appToken);
 749        }
 750    }
 751
 752    void resumeKeyDispatchingLocked() {
 753        if (keysPaused) {
 754            keysPaused = false;
 755            service.mWindowManager.resumeKeyDispatching(appToken);
 756        }
 757    }
 758
 759    void updateThumbnail(Bitmap newThumbnail, CharSequence description) {
 760        if (thumbHolder != null) {
 761            if (newThumbnail != null) {
 762                if (ActivityManagerService.DEBUG_THUMBNAILS) Slog.i(ActivityManagerService.TAG,
 763                        "Setting thumbnail of " + this + " holder " + thumbHolder
 764                        + " to " + newThumbnail);
 765                thumbHolder.lastThumbnail = newThumbnail;
 766            }
 767            thumbHolder.lastDescription = description;
 768        }
 769    }
 770
 771    void startLaunchTickingLocked() {
 772        if (ActivityManagerService.IS_USER_BUILD) {
 773            return;
 774        }
 775        if (launchTickTime == 0) {
 776            launchTickTime = SystemClock.uptimeMillis();
 777            continueLaunchTickingLocked();
 778        }
 779    }
 780
 781    boolean continueLaunchTickingLocked() {
 782        if (launchTickTime != 0) {
 783            final ActivityStack stack = task.stack;
 784            Message msg = stack.mHandler.obtainMessage(ActivityStack.LAUNCH_TICK_MSG, this);
 785            stack.mHandler.removeMessages(ActivityStack.LAUNCH_TICK_MSG);
 786            stack.mHandler.sendMessageDelayed(msg, ActivityStack.LAUNCH_TICK);
 787            return true;
 788        }
 789        return false;
 790    }
 791
 792    void finishLaunchTickingLocked() {
 793        launchTickTime = 0;
 794        task.stack.mHandler.removeMessages(ActivityStack.LAUNCH_TICK_MSG);
 795    }
 796
 797    // IApplicationToken
 798
 799    public boolean mayFreezeScreenLocked(ProcessRecord app) {
 800        // Only freeze the screen if this activity is currently attached to
 801        // an application, and that application is not blocked or unresponding.
 802        // In any other case, we can't count on getting the screen unfrozen,
 803        // so it is best to leave as-is.
 804        return app != null && !app.crashing && !app.notResponding;
 805    }
 806
 807    public void startFreezingScreenLocked(ProcessRecord app, int configChanges) {
 808        if (mayFreezeScreenLocked(app)) {
 809            service.mWindowManager.startAppFreezingScreen(appToken, configChanges);
 810        }
 811    }
 812
 813    public void stopFreezingScreenLocked(boolean force) {
 814        if (force || frozenBeforeDestroy) {
 815            frozenBeforeDestroy = false;
 816            service.mWindowManager.stopAppFreezingScreen(appToken, force);
 817        }
 818    }
 819
 820    public void reportFullyDrawnLocked() {
 821        final long curTime = SystemClock.uptimeMillis();
 822        if (displayStartTime != 0) {
 823            reportLaunchTimeLocked(curTime);
 824        }
 825        if (fullyDrawnStartTime != 0) {
 826            final ActivityStack stack = task.stack;
 827            final long thisTime = curTime - fullyDrawnStartTime;
 828            final long totalTime = stack.mFullyDrawnStartTime != 0
 829                    ? (curTime - stack.mFullyDrawnStartTime) : thisTime;
 830            if (ActivityManagerService.SHOW_ACTIVITY_START_TIME) {
 831                Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER, "drawing", 0);
 832                EventLog.writeEvent(EventLogTags.AM_ACTIVITY_FULLY_DRAWN_TIME,
 833                        userId, System.identityHashCode(this), shortComponentName,
 834                        thisTime, totalTime);
 835                StringBuilder sb = service.mStringBuilder;
 836                sb.setLength(0);
 837                sb.append("Fully drawn ");
 838                sb.append(shortComponentName);
 839                sb.append(": ");
 840                TimeUtils.formatDuration(thisTime, sb);
 841                if (thisTime != totalTime) {
 842                    sb.append(" (total ");
 843                    TimeUtils.formatDuration(totalTime, sb);
 844                    sb.append(")");
 845                }
 846                Log.i(ActivityManagerService.TAG, sb.toString());
 847            }
 848            if (totalTime > 0) {
 849                service.mUsageStatsService.noteFullyDrawnTime(realActivity, (int) totalTime);
 850            }
 851            fullyDrawnStartTime = 0;
 852            stack.mFullyDrawnStartTime = 0;
 853        }
 854    }
 855
 856    private void reportLaunchTimeLocked(final long curTime) {
 857        final ActivityStack stack = task.stack;
 858        final long thisTime = curTime - displayStartTime;
 859        final long totalTime = stack.mLaunchStartTime != 0
 860                ? (curTime - stack.mLaunchStartTime) : thisTime;
 861        if (ActivityManagerService.SHOW_ACTIVITY_START_TIME) {
 862            Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER, "launching", 0);
 863            EventLog.writeEvent(EventLogTags.AM_ACTIVITY_LAUNCH_TIME,
 864                    userId, System.identityHashCode(this), shortComponentName,
 865                    thisTime, totalTime);
 866            StringBuilder sb = service.mStringBuilder;
 867            sb.setLength(0);
 868            sb.append("Displayed ");
 869            sb.append(shortComponentName);
 870            sb.append(": ");
 871            TimeUtils.formatDuration(thisTime, sb);
 872            if (thisTime != totalTime) {
 873                sb.append(" (total ");
 874                TimeUtils.formatDuration(totalTime, sb);
 875                sb.append(")");
 876            }
 877            Log.i(ActivityManagerService.TAG, sb.toString());
 878        }
 879        mStackSupervisor.reportActivityLaunchedLocked(false, this, thisTime, totalTime);
 880        if (totalTime > 0) {
 881            service.mUsageStatsService.noteLaunchTime(realActivity, (int)totalTime);
 882        }
 883        displayStartTime = 0;
 884        stack.mLaunchStartTime = 0;
 885    }
 886
 887    public void windowsDrawn() {
 888        synchronized(service) {
 889            if (displayStartTime != 0) {
 890                reportLaunchTimeLocked(SystemClock.uptimeMillis());
 891            }
 892            startTime = 0;
 893            finishLaunchTickingLocked();
 894        }
 895    }
 896
 897    public void windowsVisible() {
 898        synchronized(service) {
 899            mStackSupervisor.reportActivityVisibleLocked(this);
 900            if (ActivityManagerService.DEBUG_SWITCH) Log.v(
 901                    ActivityManagerService.TAG, "windowsVisible(): " + this);
 902            if (!nowVisible) {
 903                nowVisible = true;
 904                lastVisibleTime = SystemClock.uptimeMillis();
 905                if (!idle) {
 906                    // Instead of doing the full stop routine here, let's just
 907                    // hide any activities we now can, and let them stop when
 908                    // the normal idle happens.
 909                    mStackSupervisor.processStoppingActivitiesLocked(false);
 910                } else {
 911                    // If this activity was already idle, then we now need to
 912                    // make sure we perform the full stop of any activities
 913                    // that are waiting to do so.  This is because we won't
 914                    // do that while they are still waiting for this one to
 915                    // become visible.
 916                    final int N = mStackSupervisor.mWaitingVisibleActivities.size();
 917                    if (N > 0) {
 918                        for (int i=0; i<N; i++) {
 919                            ActivityRecord r = mStackSupervisor.mWaitingVisibleActivities.get(i);
 920                            r.waitingVisible = false;
 921                            if (ActivityManagerService.DEBUG_SWITCH) Log.v(
 922                                    ActivityManagerService.TAG,
 923                                    "Was waiting for visible: " + r);
 924                        }
 925                        mStackSupervisor.mWaitingVisibleActivities.clear();
 926                        mStackSupervisor.scheduleIdleLocked();
 927                    }
 928                }
 929                service.scheduleAppGcsLocked();
 930            }
 931        }
 932    }
 933
 934    public void windowsGone() {
 935        if (ActivityManagerService.DEBUG_SWITCH) Log.v(
 936                ActivityManagerService.TAG, "windowsGone(): " + this);
 937        nowVisible = false;
 938    }
 939
 940    private ActivityRecord getWaitingHistoryRecordLocked() {
 941        // First find the real culprit...  if we are waiting
 942        // for another app to start, then we have paused dispatching
 943        // for this activity.
 944        ActivityRecord r = this;
 945        if (r.waitingVisible) {
 946            final ActivityStack stack = mStackSupervisor.getFocusedStack();
 947            // Hmmm, who might we be waiting for?
 948            r = stack.mResumedActivity;
 949            if (r == null) {
 950                r = stack.mPausingActivity;
 951            }
 952            // Both of those null?  Fall back to 'this' again
 953            if (r == null) {
 954                r = this;
 955            }
 956        }
 957
 958        return r;
 959    }
 960
 961    public boolean keyDispatchingTimedOut(String reason) {
 962        ActivityRecord r;
 963        ProcessRecord anrApp;
 964        synchronized(service) {
 965            r = getWaitingHistoryRecordLocked();
 966            anrApp = r != null ? r.app : null;
 967        }
 968        return service.inputDispatchingTimedOut(anrApp, r, this, false, reason);
 969    }
 970
 971    /** Returns the key dispatching timeout for this application token. */
 972    public long getKeyDispatchingTimeout() {
 973        synchronized(service) {
 974            ActivityRecord r = getWaitingHistoryRecordLocked();
 975            return ActivityManagerService.getInputDispatchingTimeoutLocked(r);
 976        }
 977    }
 978
 979    /**
 980     * This method will return true if the activity is either visible, is becoming visible, is
 981     * currently pausing, or is resumed.
 982     */
 983    public boolean isInterestingToUserLocked() {
 984        return visible || nowVisible || state == ActivityState.PAUSING ||
 985                state == ActivityState.RESUMED;
 986    }
 987
 988    public void setSleeping(boolean _sleeping) {
 989        if (sleeping == _sleeping) {
 990            return;
 991        }
 992        if (app != null && app.thread != null) {
 993            try {
 994                app.thread.scheduleSleeping(appToken, _sleeping);
 995                if (_sleeping && !mStackSupervisor.mGoingToSleepActivities.contains(this)) {
 996                    mStackSupervisor.mGoingToSleepActivities.add(this);
 997                }
 998                sleeping = _sleeping;
 999            } catch (RemoteException e) {
1000                Slog.w(TAG, "Exception thrown when sleeping: " + intent.getComponent(), e);
1001            }
1002        }
1003    }
1004
1005    static void activityResumedLocked(IBinder token) {
1006        final ActivityRecord r = ActivityRecord.forToken(token);
1007        if (DEBUG_SAVED_STATE) Slog.i(TAG, "Resumed activity; dropping state of: " + r);
1008        r.icicle = null;
1009        r.haveState = false;
1010    }
1011
1012    static int getTaskForActivityLocked(IBinder token, boolean onlyRoot) {
1013        final ActivityRecord r = ActivityRecord.forToken(token);
1014        if (r == null) {
1015            return -1;
1016        }
1017        final TaskRecord task = r.task;
1018        switch (task.mActivities.indexOf(r)) {
1019            case -1: return -1;
1020            case 0: return task.taskId;
1021            default: return onlyRoot ? -1 : task.taskId;
1022        }
1023    }
1024
1025    static ActivityRecord isInStackLocked(IBinder token) {
1026        final ActivityRecord r = ActivityRecord.forToken(token);
1027        if (r != null) {
1028            return r.task.stack.isInStackLocked(token);
1029        }
1030        return null;
1031    }
1032
1033    static ActivityStack getStackLocked(IBinder token) {
1034        final ActivityRecord r = ActivityRecord.isInStackLocked(token);
1035        if (r != null) {
1036            return r.task.stack;
1037        }
1038        return null;
1039    }
1040
1041    private String activityTypeToString(int type) {
1042        switch (type) {
1043            case APPLICATION_ACTIVITY_TYPE: return "APPLICATION_ACTIVITY_TYPE";
1044            case HOME_ACTIVITY_TYPE: return "HOME_ACTIVITY_TYPE";
1045            case RECENTS_ACTIVITY_TYPE: return "RECENTS_ACTIVITY_TYPE";
1046            default: return Integer.toString(type);
1047        }
1048    }
1049
1050    @Override
1051    public String toString() {
1052        if (stringName != null) {
1053            return stringName + " t" + (task == null ? -1 : task.taskId) +
1054                    (finishing ? " f}" : "}");
1055        }
1056        StringBuilder sb = new StringBuilder(128);
1057        sb.append("ActivityRecord{");
1058        sb.append(Integer.toHexString(System.identityHashCode(this)));
1059        sb.append(" u");
1060        sb.append(userId);
1061        sb.append(' ');
1062        sb.append(intent.getComponent().flattenToShortString());
1063        stringName = sb.toString();
1064        return toString();
1065    }
1066}