summaryrefslogtreecommitdiffstats
path: root/core/java/android/app/LocalActivityManager.java
diff options
context:
space:
mode:
authorThe Android Open Source Project <initial-contribution@android.com>2009-03-03 18:28:45 -0800
committerThe Android Open Source Project <initial-contribution@android.com>2009-03-03 18:28:45 -0800
commitd83a98f4ce9cfa908f5c54bbd70f03eec07e7553 (patch)
tree4b825dc642cb6eb9a060e54bf8d69288fbee4904 /core/java/android/app/LocalActivityManager.java
parent076357b8567458d4b6dfdcf839ef751634cd2bfb (diff)
downloadframeworks_base-d83a98f4ce9cfa908f5c54bbd70f03eec07e7553.zip
frameworks_base-d83a98f4ce9cfa908f5c54bbd70f03eec07e7553.tar.gz
frameworks_base-d83a98f4ce9cfa908f5c54bbd70f03eec07e7553.tar.bz2
auto import from //depot/cupcake/@135843
Diffstat (limited to 'core/java/android/app/LocalActivityManager.java')
-rw-r--r--core/java/android/app/LocalActivityManager.java627
1 files changed, 0 insertions, 627 deletions
diff --git a/core/java/android/app/LocalActivityManager.java b/core/java/android/app/LocalActivityManager.java
deleted file mode 100644
index a24fcae..0000000
--- a/core/java/android/app/LocalActivityManager.java
+++ /dev/null
@@ -1,627 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.app;
-
-import android.content.Intent;
-import android.content.pm.ActivityInfo;
-import android.os.Binder;
-import android.os.Bundle;
-import android.util.Config;
-import android.util.Log;
-import android.view.Window;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-
-/**
- * Helper class for managing multiple running embedded activities in the same
- * process. This class is not normally used directly, but rather created for
- * you as part of the {@link android.app.ActivityGroup} implementation.
- *
- * @see ActivityGroup
- */
-public class LocalActivityManager {
- private static final String TAG = "LocalActivityManager";
- private static final boolean localLOGV = false || Config.LOGV;
-
- // Internal token for an Activity being managed by LocalActivityManager.
- private static class LocalActivityRecord extends Binder {
- LocalActivityRecord(String _id, Intent _intent) {
- id = _id;
- intent = _intent;
- }
-
- final String id; // Unique name of this record.
- Intent intent; // Which activity to run here.
- ActivityInfo activityInfo; // Package manager info about activity.
- Activity activity; // Currently instantiated activity.
- Window window; // Activity's top-level window.
- Bundle instanceState; // Last retrieved freeze state.
- int curState = RESTORED; // Current state the activity is in.
- }
-
- static final int RESTORED = 0; // State restored, but no startActivity().
- static final int INITIALIZING = 1; // Ready to launch (after startActivity()).
- static final int CREATED = 2; // Created, not started or resumed.
- static final int STARTED = 3; // Created and started, not resumed.
- static final int RESUMED = 4; // Created started and resumed.
- static final int DESTROYED = 5; // No longer with us.
-
- /** Thread our activities are running in. */
- private final ActivityThread mActivityThread;
- /** The containing activity that owns the activities we create. */
- private final Activity mParent;
-
- /** The activity that is currently resumed. */
- private LocalActivityRecord mResumed;
- /** id -> record of all known activities. */
- private final Map<String, LocalActivityRecord> mActivities
- = new HashMap<String, LocalActivityRecord>();
- /** array of all known activities for easy iterating. */
- private final ArrayList<LocalActivityRecord> mActivityArray
- = new ArrayList<LocalActivityRecord>();
-
- /** True if only one activity can be resumed at a time */
- private boolean mSingleMode;
-
- /** Set to true once we find out the container is finishing. */
- private boolean mFinishing;
-
- /** Current state the owner (ActivityGroup) is in */
- private int mCurState = INITIALIZING;
-
- /** String ids of running activities starting with least recently used. */
- // TODO: put back in stopping of activities.
- //private List<LocalActivityRecord> mLRU = new ArrayList();
-
- /**
- * Create a new LocalActivityManager for holding activities running within
- * the given <var>parent</var>.
- *
- * @param parent the host of the embedded activities
- * @param singleMode True if the LocalActivityManger should keep a maximum
- * of one activity resumed
- */
- public LocalActivityManager(Activity parent, boolean singleMode) {
- mActivityThread = ActivityThread.currentActivityThread();
- mParent = parent;
- mSingleMode = singleMode;
- }
-
- private void moveToState(LocalActivityRecord r, int desiredState) {
- if (r.curState == RESTORED || r.curState == DESTROYED) {
- // startActivity() has not yet been called, so nothing to do.
- return;
- }
-
- if (r.curState == INITIALIZING) {
- // Get the lastNonConfigurationInstance for the activity
- HashMap<String,Object> lastNonConfigurationInstances =
- mParent.getLastNonConfigurationChildInstances();
- Object instance = null;
- if (lastNonConfigurationInstances != null) {
- instance = lastNonConfigurationInstances.get(r.id);
- }
-
- // We need to have always created the activity.
- if (localLOGV) Log.v(TAG, r.id + ": starting " + r.intent);
- if (r.activityInfo == null) {
- r.activityInfo = mActivityThread.resolveActivityInfo(r.intent);
- }
- r.activity = mActivityThread.startActivityNow(
- mParent, r.id, r.intent, r.activityInfo, r, r.instanceState, instance);
- if (r.activity == null) {
- return;
- }
- r.window = r.activity.getWindow();
- r.instanceState = null;
- r.curState = STARTED;
-
- if (desiredState == RESUMED) {
- if (localLOGV) Log.v(TAG, r.id + ": resuming");
- mActivityThread.performResumeActivity(r, true);
- r.curState = RESUMED;
- }
-
- // Don't do anything more here. There is an important case:
- // if this is being done as part of onCreate() of the group, then
- // the launching of the activity gets its state a little ahead
- // of our own (it is now STARTED, while we are only CREATED).
- // If we just leave things as-is, we'll deal with it as the
- // group's state catches up.
- return;
- }
-
- switch (r.curState) {
- case CREATED:
- if (desiredState == STARTED) {
- if (localLOGV) Log.v(TAG, r.id + ": restarting");
- mActivityThread.performRestartActivity(r);
- r.curState = STARTED;
- }
- if (desiredState == RESUMED) {
- if (localLOGV) Log.v(TAG, r.id + ": restarting and resuming");
- mActivityThread.performRestartActivity(r);
- mActivityThread.performResumeActivity(r, true);
- r.curState = RESUMED;
- }
- return;
-
- case STARTED:
- if (desiredState == RESUMED) {
- // Need to resume it...
- if (localLOGV) Log.v(TAG, r.id + ": resuming");
- mActivityThread.performResumeActivity(r, true);
- r.instanceState = null;
- r.curState = RESUMED;
- }
- if (desiredState == CREATED) {
- if (localLOGV) Log.v(TAG, r.id + ": stopping");
- mActivityThread.performStopActivity(r);
- r.curState = CREATED;
- }
- return;
-
- case RESUMED:
- if (desiredState == STARTED) {
- if (localLOGV) Log.v(TAG, r.id + ": pausing");
- performPause(r, mFinishing);
- r.curState = STARTED;
- }
- if (desiredState == CREATED) {
- if (localLOGV) Log.v(TAG, r.id + ": pausing");
- performPause(r, mFinishing);
- if (localLOGV) Log.v(TAG, r.id + ": stopping");
- mActivityThread.performStopActivity(r);
- r.curState = CREATED;
- }
- return;
- }
- }
-
- private void performPause(LocalActivityRecord r, boolean finishing) {
- boolean needState = r.instanceState == null;
- Bundle instanceState = mActivityThread.performPauseActivity(r,
- finishing, needState);
- if (needState) {
- r.instanceState = instanceState;
- }
- }
-
- /**
- * Start a new activity running in the group. Every activity you start
- * must have a unique string ID associated with it -- this is used to keep
- * track of the activity, so that if you later call startActivity() again
- * on it the same activity object will be retained.
- *
- * <p>When there had previously been an activity started under this id,
- * it may either be destroyed and a new one started, or the current
- * one re-used, based on these conditions, in order:</p>
- *
- * <ul>
- * <li> If the Intent maps to a different activity component than is
- * currently running, the current activity is finished and a new one
- * started.
- * <li> If the current activity uses a non-multiple launch mode (such
- * as singleTop), or the Intent has the
- * {@link Intent#FLAG_ACTIVITY_SINGLE_TOP} flag set, then the current
- * activity will remain running and its
- * {@link Activity#onNewIntent(Intent) Activity.onNewIntent()} method
- * called.
- * <li> If the new Intent is the same (excluding extras) as the previous
- * one, and the new Intent does not have the
- * {@link Intent#FLAG_ACTIVITY_CLEAR_TOP} set, then the current activity
- * will remain running as-is.
- * <li> Otherwise, the current activity will be finished and a new
- * one started.
- * </ul>
- *
- * <p>If the given Intent can not be resolved to an available Activity,
- * this method throws {@link android.content.ActivityNotFoundException}.
- *
- * <p>Warning: There is an issue where, if the Intent does not
- * include an explicit component, we can restore the state for a different
- * activity class than was previously running when the state was saved (if
- * the set of available activities changes between those points).
- *
- * @param id Unique identifier of the activity to be started
- * @param intent The Intent describing the activity to be started
- *
- * @return Returns the window of the activity. The caller needs to take
- * care of adding this window to a view hierarchy, and likewise dealing
- * with removing the old window if the activity has changed.
- *
- * @throws android.content.ActivityNotFoundException
- */
- public Window startActivity(String id, Intent intent) {
- if (mCurState == INITIALIZING) {
- throw new IllegalStateException(
- "Activities can't be added until the containing group has been created.");
- }
-
- boolean adding = false;
- boolean sameIntent = false;
-
- ActivityInfo aInfo = null;
-
- // Already have information about the new activity id?
- LocalActivityRecord r = mActivities.get(id);
- if (r == null) {
- // Need to create it...
- r = new LocalActivityRecord(id, intent);
- adding = true;
- } else if (r.intent != null) {
- sameIntent = r.intent.filterEquals(intent);
- if (sameIntent) {
- // We are starting the same activity.
- aInfo = r.activityInfo;
- }
- }
- if (aInfo == null) {
- aInfo = mActivityThread.resolveActivityInfo(intent);
- }
-
- // Pause the currently running activity if there is one and only a single
- // activity is allowed to be running at a time.
- if (mSingleMode) {
- LocalActivityRecord old = mResumed;
-
- // If there was a previous activity, and it is not the current
- // activity, we need to stop it.
- if (old != null && old != r && mCurState == RESUMED) {
- moveToState(old, STARTED);
- }
- }
-
- if (adding) {
- // It's a brand new world.
- mActivities.put(id, r);
- mActivityArray.add(r);
- } else if (r.activityInfo != null) {
- // If the new activity is the same as the current one, then
- // we may be able to reuse it.
- if (aInfo == r.activityInfo ||
- (aInfo.name.equals(r.activityInfo.name) &&
- aInfo.packageName.equals(r.activityInfo.packageName))) {
- if (aInfo.launchMode != ActivityInfo.LAUNCH_MULTIPLE ||
- (intent.getFlags()&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0) {
- // The activity wants onNewIntent() called.
- ArrayList<Intent> intents = new ArrayList<Intent>(1);
- intents.add(intent);
- if (localLOGV) Log.v(TAG, r.id + ": new intent");
- mActivityThread.performNewIntents(r, intents);
- r.intent = intent;
- moveToState(r, mCurState);
- if (mSingleMode) {
- mResumed = r;
- }
- return r.window;
- }
- if (sameIntent &&
- (intent.getFlags()&Intent.FLAG_ACTIVITY_CLEAR_TOP) == 0) {
- // We are showing the same thing, so this activity is
- // just resumed and stays as-is.
- r.intent = intent;
- moveToState(r, mCurState);
- if (mSingleMode) {
- mResumed = r;
- }
- return r.window;
- }
- }
-
- // The new activity is different than the current one, or it
- // is a multiple launch activity, so we need to destroy what
- // is currently there.
- performDestroy(r, true);
- }
-
- r.intent = intent;
- r.curState = INITIALIZING;
- r.activityInfo = aInfo;
-
- moveToState(r, mCurState);
-
- // When in single mode keep track of the current activity
- if (mSingleMode) {
- mResumed = r;
- }
- return r.window;
- }
-
- private Window performDestroy(LocalActivityRecord r, boolean finish) {
- Window win = null;
- win = r.window;
- if (r.curState == RESUMED && !finish) {
- performPause(r, finish);
- }
- if (localLOGV) Log.v(TAG, r.id + ": destroying");
- mActivityThread.performDestroyActivity(r, finish);
- r.activity = null;
- r.window = null;
- if (finish) {
- r.instanceState = null;
- }
- r.curState = DESTROYED;
- return win;
- }
-
- /**
- * Destroy the activity associated with a particular id. This activity
- * will go through the normal lifecycle events and fine onDestroy(), and
- * then the id removed from the group.
- *
- * @param id Unique identifier of the activity to be destroyed
- * @param finish If true, this activity will be finished, so its id and
- * all state are removed from the group.
- *
- * @return Returns the window that was used to display the activity, or
- * null if there was none.
- */
- public Window destroyActivity(String id, boolean finish) {
- LocalActivityRecord r = mActivities.get(id);
- Window win = null;
- if (r != null) {
- win = performDestroy(r, finish);
- if (finish) {
- mActivities.remove(r);
- }
- }
- return win;
- }
-
- /**
- * Retrieve the Activity that is currently running.
- *
- * @return the currently running (resumed) Activity, or null if there is
- * not one
- *
- * @see #startActivity
- * @see #getCurrentId
- */
- public Activity getCurrentActivity() {
- return mResumed != null ? mResumed.activity : null;
- }
-
- /**
- * Retrieve the ID of the activity that is currently running.
- *
- * @return the ID of the currently running (resumed) Activity, or null if
- * there is not one
- *
- * @see #startActivity
- * @see #getCurrentActivity
- */
- public String getCurrentId() {
- return mResumed != null ? mResumed.id : null;
- }
-
- /**
- * Return the Activity object associated with a string ID.
- *
- * @see #startActivity
- *
- * @return the associated Activity object, or null if the id is unknown or
- * its activity is not currently instantiated
- */
- public Activity getActivity(String id) {
- LocalActivityRecord r = mActivities.get(id);
- return r != null ? r.activity : null;
- }
-
- /**
- * Restore a state that was previously returned by {@link #saveInstanceState}. This
- * adds to the activity group information about all activity IDs that had
- * previously been saved, even if they have not been started yet, so if the
- * user later navigates to them the correct state will be restored.
- *
- * <p>Note: This does <b>not</b> change the current running activity, or
- * start whatever activity was previously running when the state was saved.
- * That is up to the client to do, in whatever way it thinks is best.
- *
- * @param state a previously saved state; does nothing if this is null
- *
- * @see #saveInstanceState
- */
- public void dispatchCreate(Bundle state) {
- if (state != null) {
- final Iterator<String> i = state.keySet().iterator();
- while (i.hasNext()) {
- try {
- final String id = i.next();
- final Bundle astate = state.getBundle(id);
- LocalActivityRecord r = mActivities.get(id);
- if (r != null) {
- r.instanceState = astate;
- } else {
- r = new LocalActivityRecord(id, null);
- r.instanceState = astate;
- mActivities.put(id, r);
- mActivityArray.add(r);
- }
- } catch (Exception e) {
- // Recover from -all- app errors.
- Log.e(TAG,
- "Exception thrown when restoring LocalActivityManager state",
- e);
- }
- }
- }
-
- mCurState = CREATED;
- }
-
- /**
- * Retrieve the state of all activities known by the group. For
- * activities that have previously run and are now stopped or finished, the
- * last saved state is used. For the current running activity, its
- * {@link Activity#onSaveInstanceState} is called to retrieve its current state.
- *
- * @return a Bundle holding the newly created state of all known activities
- *
- * @see #dispatchCreate
- */
- public Bundle saveInstanceState() {
- Bundle state = null;
-
- // FIXME: child activities will freeze as part of onPaused. Do we
- // need to do this here?
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- final LocalActivityRecord r = mActivityArray.get(i);
- if (state == null) {
- state = new Bundle();
- }
- if ((r.instanceState != null || r.curState == RESUMED)
- && r.activity != null) {
- // We need to save the state now, if we don't currently
- // already have it or the activity is currently resumed.
- final Bundle childState = new Bundle();
- r.activity.onSaveInstanceState(childState);
- r.instanceState = childState;
- }
- if (r.instanceState != null) {
- state.putBundle(r.id, r.instanceState);
- }
- }
-
- return state;
- }
-
- /**
- * Called by the container activity in its {@link Activity#onResume} so
- * that LocalActivityManager can perform the corresponding action on the
- * activities it holds.
- *
- * @see Activity#onResume
- */
- public void dispatchResume() {
- mCurState = RESUMED;
- if (mSingleMode) {
- if (mResumed != null) {
- moveToState(mResumed, RESUMED);
- }
- } else {
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- moveToState(mActivityArray.get(i), RESUMED);
- }
- }
- }
-
- /**
- * Called by the container activity in its {@link Activity#onPause} so
- * that LocalActivityManager can perform the corresponding action on the
- * activities it holds.
- *
- * @param finishing set to true if the parent activity has been finished;
- * this can be determined by calling
- * Activity.isFinishing()
- *
- * @see Activity#onPause
- * @see Activity#isFinishing
- */
- public void dispatchPause(boolean finishing) {
- if (finishing) {
- mFinishing = true;
- }
- mCurState = STARTED;
- if (mSingleMode) {
- if (mResumed != null) {
- moveToState(mResumed, STARTED);
- }
- } else {
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- LocalActivityRecord r = mActivityArray.get(i);
- if (r.curState == RESUMED) {
- moveToState(r, STARTED);
- }
- }
- }
- }
-
- /**
- * Called by the container activity in its {@link Activity#onStop} so
- * that LocalActivityManager can perform the corresponding action on the
- * activities it holds.
- *
- * @see Activity#onStop
- */
- public void dispatchStop() {
- mCurState = CREATED;
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- LocalActivityRecord r = mActivityArray.get(i);
- moveToState(r, CREATED);
- }
- }
-
- /**
- * Call onRetainNonConfigurationInstance on each child activity and store the
- * results in a HashMap by id. Only construct the HashMap if there is a non-null
- * object to store. Note that this does not support nested ActivityGroups.
- *
- * {@hide}
- */
- public HashMap<String,Object> dispatchRetainNonConfigurationInstance() {
- HashMap<String,Object> instanceMap = null;
-
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- LocalActivityRecord r = mActivityArray.get(i);
- if ((r != null) && (r.activity != null)) {
- Object instance = r.activity.onRetainNonConfigurationInstance();
- if (instance != null) {
- if (instanceMap == null) {
- instanceMap = new HashMap<String,Object>();
- }
- instanceMap.put(r.id, instance);
- }
- }
- }
- return instanceMap;
- }
-
- /**
- * Remove all activities from this LocalActivityManager, performing an
- * {@link Activity#onDestroy} on any that are currently instantiated.
- */
- public void removeAllActivities() {
- dispatchDestroy(true);
- }
-
- /**
- * Called by the container activity in its {@link Activity#onDestroy} so
- * that LocalActivityManager can perform the corresponding action on the
- * activities it holds.
- *
- * @see Activity#onDestroy
- */
- public void dispatchDestroy(boolean finishing) {
- final int N = mActivityArray.size();
- for (int i=0; i<N; i++) {
- LocalActivityRecord r = mActivityArray.get(i);
- if (localLOGV) Log.v(TAG, r.id + ": destroying");
- mActivityThread.performDestroyActivity(r, finishing);
- }
- mActivities.clear();
- mActivityArray.clear();
- }
-}
generated by cgit v1.1 at 2025-04-03 19:43:55 +0000