Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
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 android.app;
18
 
26
 
30
 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 ActivityGroup implementation.

See also:
ActivityGroup
38
 
39
 public class LocalActivityManager {
40
     private static final String TAG = "LocalActivityManager";
41
     private static final boolean localLOGV = false || .;
42
 
43
     // Internal token for an Activity being managed by LocalActivityManager.
44
     private static class LocalActivityRecord extends Binder {
45
         LocalActivityRecord(String _id, Intent _intent) {
46
              = _id;
47
              = _intent;
48
         }
49
 
50
         final String id;                // Unique name of this record.
51
         Intent intent;                  // Which activity to run here.
52
         ActivityInfo activityInfo;      // Package manager info about activity.
53
         Activity activity;              // Currently instantiated activity.
54
         Window window;                  // Activity's top-level window.
55
         Bundle instanceState;           // Last retrieved freeze state.
56
         int curState = ;        // Current state the activity is in.
57
     }
58
 
59
     static final int RESTORED = 0;      // State restored, but no startActivity().
60
     static final int INITIALIZING = 1;  // Ready to launch (after startActivity()).
61
     static final int CREATED = 2;       // Created, not started or resumed.
62
     static final int STARTED = 3;       // Created and started, not resumed.
63
     static final int RESUMED = 4;       // Created started and resumed.
64
     static final int DESTROYED = 5;     // No longer with us.
65
     
    
Thread our activities are running in.
66
 
67
     private final ActivityThread mActivityThread;
    
The containing activity that owns the activities we create.
68
 
69
     private final Activity mParent;

    
The activity that is currently resumed.
71
 
72
     private LocalActivityRecord mResumed;
    
id -> record of all known activities.
73
 
74
     private final Map<String, LocalActivityRecord> mActivities
75
             = new HashMap<String, LocalActivityRecord>();
    
array of all known activities for easy iterating.
76
 
77
     private final ArrayList<LocalActivityRecord> mActivityArray
78
             = new ArrayList<LocalActivityRecord>();

    
True if only one activity can be resumed at a time
80
 
81
     private boolean mSingleMode;
    
    
Set to true once we find out the container is finishing.
83
 
84
     private boolean mFinishing;
    
    
Current state the owner (ActivityGroup) is in
86
 
87
     private int mCurState = ;
    
    
String ids of running activities starting with least recently used.
89
 
90
     // TODO: put back in stopping of activities.
91
     //private List<LocalActivityRecord>  mLRU = new ArrayList();
92
 
    
Create a new LocalActivityManager for holding activities running within the given parent.

Parameters:
parent the host of the embedded activities
singleMode True if the LocalActivityManger should keep a maximum of one activity resumed
101
    public LocalActivityManager(Activity parent, boolean singleMode) {
102
         = ActivityThread.currentActivityThread();
103
         = parent;
104
         = singleMode;
105
    }
107
    private void moveToState(LocalActivityRecord r, int desiredState) {
108
        if (r.curState ==  || r.curState == ) {
109
            // startActivity() has not yet been called, so nothing to do.
110
            return;
111
        }
112
        
113
        if (r.curState == ) {
114
            // Get the lastNonConfigurationInstance for the activity
115
            HashMap<String,Object> lastNonConfigurationInstances =
116
                .getLastNonConfigurationChildInstances();
117
            Object instance = null;
118
            if (lastNonConfigurationInstances != null) {
119
                instance = lastNonConfigurationInstances.get(r.id);
120
            }
121
            
122
            // We need to have always created the activity.
123
            if () Log.v(, r.id + ": starting " + r.intent);
124
            if (r.activityInfo == null) {
125
                r.activityInfo = .resolveActivityInfo(r.intent);
126
            }
127
            r.activity = .startActivityNow(
128
                    , r.id, r.intent, r.activityInfo, r, r.instanceState, instance);
129
            if (r.activity == null) {
130
                return;
131
            }
132
            r.window = r.activity.getWindow();
133
            r.instanceState = null;
134
            r.curState = ;
135
            
136
            if (desiredState == ) {
137
                if () Log.v(, r.id + ": resuming");
138
                .performResumeActivity(r, true);
139
                r.curState = ;
140
            }
141
            
142
            // Don't do anything more here.  There is an important case:
143
            // if this is being done as part of onCreate() of the group, then
144
            // the launching of the activity gets its state a little ahead
145
            // of our own (it is now STARTED, while we are only CREATED).
146
            // If we just leave things as-is, we'll deal with it as the
147
            // group's state catches up.
148
            return;
149
        }
150
        
151
        switch (r.curState) {
152
            case :
153
                if (desiredState == ) {
154
                    if () Log.v(, r.id + ": restarting");
155
                    .performRestartActivity(r);
156
                    r.curState = ;
157
                }
158
                if (desiredState == ) {
159
                    if () Log.v(, r.id + ": restarting and resuming");
160
                    .performRestartActivity(r);
161
                    .performResumeActivity(r, true);
162
                    r.curState = ;
163
                }
164
                return;
165
                
166
            case :
167
                if (desiredState == ) {
168
                    // Need to resume it...
169
                    if () Log.v(, r.id + ": resuming");
170
                    .performResumeActivity(r, true);
171
                    r.instanceState = null;
172
                    r.curState = ;
173
                }
174
                if (desiredState == ) {
175
                    if () Log.v(, r.id + ": stopping");
176
                    .performStopActivity(r);
177
                    r.curState = ;
178
                }
179
                return;
180
                
181
            case :
182
                if (desiredState == ) {
183
                    if () Log.v(, r.id + ": pausing");
184
                    performPause(r, );
185
                    r.curState = ;
186
                }
187
                if (desiredState == ) {
188
                    if () Log.v(, r.id + ": pausing");
189
                    performPause(r, );
190
                    if () Log.v(, r.id + ": stopping");
191
                    .performStopActivity(r);
192
                    r.curState = ;
193
                }
194
                return;
195
        }
196
    }
197
    
198
    private void performPause(LocalActivityRecord r, boolean finishing) {
199
        boolean needState = r.instanceState == null;
200
        Bundle instanceState = .performPauseActivity(r,
201
                finishing, needState);
202
        if (needState) {
203
            r.instanceState = instanceState;
204
        }
205
    }
    
    
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.

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:

  • If the Intent maps to a different activity component than is currently running, the current activity is finished and a new one started.
  • If the current activity uses a non-multiple launch mode (such as singleTop), or the Intent has the android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP flag set, then the current activity will remain running and its Activity.onNewIntent() method called.
  • If the new Intent is the same (excluding extras) as the previous one, and the new Intent does not have the android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP set, then the current activity will remain running as-is.
  • Otherwise, the current activity will be finished and a new one started.

If the given Intent can not be resolved to an available Activity, this method throws android.content.ActivityNotFoundException.

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

Parameters:
id Unique identifier of the activity to be started
intent The Intent describing the activity to be started
Returns:
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
252
    public Window startActivity(String id, Intent intent) {
253
        if ( == ) {
254
            throw new IllegalStateException(
255
                    "Activities can't be added until the containing group has been created.");
256
        }
257
        
258
        boolean adding = false;
259
        boolean sameIntent = false;
261
        ActivityInfo aInfo = null;
262
        
263
        // Already have information about the new activity id?
264
        LocalActivityRecord r = .get(id);
265
        if (r == null) {
266
            // Need to create it...
267
            r = new LocalActivityRecord(id, intent);
268
            adding = true;
269
        } else if (r.intent != null) {
270
            sameIntent = r.intent.filterEquals(intent); 
271
            if (sameIntent) {
272
                // We are starting the same activity.
273
                aInfo = r.activityInfo;
274
            }
275
        }
276
        if (aInfo == null) {
277
            aInfo = .resolveActivityInfo(intent);
278
        }
279
        
280
        // Pause the currently running activity if there is one and only a single
281
        // activity is allowed to be running at a time.
282
        if () {
283
            LocalActivityRecord old = ;
284
    
285
            // If there was a previous activity, and it is not the current
286
            // activity, we need to stop it.
287
            if (old != null && old != r &&  == ) {
288
                moveToState(old, );
289
            }
290
        }
292
        if (adding) {
293
            // It's a brand new world.
294
            .put(id, r);
295
            .add(r);
296
        } else if (r.activityInfo != null) {
297
            // If the new activity is the same as the current one, then
298
            // we may be able to reuse it.
299
            if (aInfo == r.activityInfo ||
300
                    (aInfo.name.equals(r.activityInfo.name) &&
301
                            aInfo.packageName.equals(r.activityInfo.packageName))) {
302
                if (aInfo.launchMode != . ||
303
                        (intent.getFlags()&.) != 0) {
304
                    // The activity wants onNewIntent() called.
305
                    ArrayList<Intent> intents = new ArrayList<Intent>(1);
306
                    intents.add(intent);
307
                    if () Log.v(, r.id + ": new intent");
308
                    .performNewIntents(r, intents);
309
                    r.intent = intent;
310
                    moveToState(r, );
311
                    if () {
312
                         = r;
313
                    }
314
                    return r.window;
315
                }
316
                if (sameIntent &&
317
                        (intent.getFlags()&.) == 0) {
318
                    // We are showing the same thing, so this activity is
319
                    // just resumed and stays as-is.
320
                    r.intent = intent;
321
                    moveToState(r, );
322
                    if () {
323
                         = r;
324
                    }
325
                    return r.window;
326
                }
327
            }
328
            
329
            // The new activity is different than the current one, or it
330
            // is a multiple launch activity, so we need to destroy what
331
            // is currently there.
332
            performDestroy(r, true);
333
        }
334
        
335
        r.intent = intent;
336
        r.curState = ;
337
        r.activityInfo = aInfo;
339
        moveToState(r, );
341
        // When in single mode keep track of the current activity
342
        if () {
343
             = r;
344
        }
345
        return r.window;
346
    }
348
    private Window performDestroy(LocalActivityRecord r, boolean finish) {
349
        Window win = null;
350
        win = r.window;
351
        if (r.curState ==  && !finish) {
352
            performPause(r, finish);
353
        }
354
        if () Log.v(, r.id + ": destroying");
355
        .performDestroyActivity(r, finish);
356
        r.activity = null;
357
        r.window = null;
358
        if (finish) {
359
            r.instanceState = null;
360
        }
361
        r.curState = ;
362
        return win;
363
    }
    
    
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.

Parameters:
id Unique identifier of the activity to be destroyed
finish If true, this activity will be finished, so its id and all state are removed from the group.
Returns:
Returns the window that was used to display the activity, or null if there was none.
377
    public Window destroyActivity(String id, boolean finish) {
378
        LocalActivityRecord r = .get(id);
379
        Window win = null;
380
        if (r != null) {
381
            win = performDestroy(r, finish);
382
            if (finish) {
383
                .remove(r);
384
            }
385
        }
386
        return win;
387
    }
    
    
Retrieve the Activity that is currently running.

Returns:
the currently running (resumed) Activity, or null if there is not one
See also:
startActivity(java.lang.String,android.content.Intent)
getCurrentId()
398
    public Activity getCurrentActivity() {
399
        return  != null ? . : null;
400
    }

    
Retrieve the ID of the activity that is currently running.

Returns:
the ID of the currently running (resumed) Activity, or null if there is not one
See also:
startActivity(java.lang.String,android.content.Intent)
getCurrentActivity()
411
    public String getCurrentId() {
412
        return  != null ? . : null;
413
    }

    
Return the Activity object associated with a string ID.

Returns:
the associated Activity object, or null if the id is unknown or its activity is not currently instantiated
See also:
startActivity(java.lang.String,android.content.Intent)
423
    public Activity getActivity(String id) {
424
        LocalActivityRecord r = .get(id);
425
        return r != null ? r.activity : null;
426
    }

    
Restore a state that was previously returned by 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.

Note: This does not 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.

Parameters:
state a previously saved state; does nothing if this is null
See also:
saveInstanceState()
442
    public void dispatchCreate(Bundle state) {
443
        if (state != null) {
444
            final Iterator<String> i = state.keySet().iterator();
445
            while (i.hasNext()) {
446
                try {
447
                    final String id = i.next();
448
                    final Bundle astate = state.getBundle(id);
449
                    LocalActivityRecord r = .get(id);
450
                    if (r != null) {
451
                        r.instanceState = astate;
452
                    } else {
453
                        r = new LocalActivityRecord(id, null);
454
                        r.instanceState = astate;
455
                        .put(id, r);
456
                        .add(r);
457
                    }
458
                } catch (Exception e) {
459
                    // Recover from -all- app errors.
460
                    Log.e(,
461
                          "Exception thrown when restoring LocalActivityManager state",
462
                          e);
463
                }
464
            }
465
        }
466
        
467
         = ;
468
    }

    
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 Activity.onSaveInstanceState(android.os.Bundle) is called to retrieve its current state.

Returns:
a Bundle holding the newly created state of all known activities
See also:
dispatchCreate(android.os.Bundle)
480
    public Bundle saveInstanceState() {
481
        Bundle state = null;
483
        // FIXME: child activities will freeze as part of onPaused. Do we
484
        // need to do this here?
485
        final int N = .size();
486
        for (int i=0; i<N; i++) {
487
            final LocalActivityRecord r = .get(i);
488
            if (state == null) {
489
                state = new Bundle();
490
            }
491
            if ((r.instanceState != null || r.curState == )
492
                    && r.activity != null) {
493
                // We need to save the state now, if we don't currently
494
                // already have it or the activity is currently resumed.
495
                final Bundle childState = new Bundle();
496
                r.activity.onSaveInstanceState(childState);
497
                r.instanceState = childState;
498
            }
499
            if (r.instanceState != null) {
500
                state.putBundle(r.id, r.instanceState);
501
            }
502
        }
504
        return state;
505
    }

    
Called by the container activity in its Activity.onResume() so that LocalActivityManager can perform the corresponding action on the activities it holds.

See also:
Activity.onResume()
514
    public void dispatchResume() {
515
         = ;
516
        if () {
517
            if ( != null) {
518
                moveToState(, );
519
            }
520
        } else {
521
            final int N = .size();
522
            for (int i=0; i<N; i++) {
523
                moveToState(.get(i), );
524
            }
525
        }
526
    }

    
Called by the container activity in its Activity.onPause() so that LocalActivityManager can perform the corresponding action on the activities it holds.

Parameters:
finishing set to true if the parent activity has been finished; this can be determined by calling Activity.isFinishing()
See also:
Activity.onPause()
Activity.isFinishing()
540
    public void dispatchPause(boolean finishing) {
541
        if (finishing) {
542
             = true;
543
        }
544
         = ;
545
        if () {
546
            if ( != null) {
547
                moveToState(, );
548
            }
549
        } else {
550
            final int N = .size();
551
            for (int i=0; i<N; i++) {
552
                LocalActivityRecord r = .get(i);
553
                if (r.curState == ) {
554
                    moveToState(r, );
555
                }
556
            }
557
        }
558
    }

    
Called by the container activity in its Activity.onStop() so that LocalActivityManager can perform the corresponding action on the activities it holds.

See also:
Activity.onStop()
567
    public void dispatchStop() {
568
         = ;
569
        final int N = .size();
570
        for (int i=0; i<N; i++) {
571
            LocalActivityRecord r = .get(i);
572
            moveToState(r, );
573
        }
574
    }
    
    
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. 
584
        HashMap<String,Object> instanceMap = null;
585
        
586
        final int N = .size();
587
        for (int i=0; i<N; i++) {
588
            LocalActivityRecord r = .get(i);
589
            if ((r != null) && (r.activity != null)) {
590
                Object instance = r.activity.onRetainNonConfigurationInstance();
591
                if (instance != null) {
592
                    if (instanceMap == null) {
593
                        instanceMap = new HashMap<String,Object>();
594
                    }
595
                    instanceMap.put(r.id, instance);
596
                }
597
            }
598
        }
599
        return instanceMap;
600
    }

    
Remove all activities from this LocalActivityManager, performing an Activity.onDestroy() on any that are currently instantiated. 
606
    public void removeAllActivities() {
607
        dispatchDestroy(true);
608
    }

    
Called by the container activity in its Activity.onDestroy() so that LocalActivityManager can perform the corresponding action on the activities it holds.

See also:
Activity.onDestroy()
617
    public void dispatchDestroy(boolean finishing) {
618
        final int N = .size();
619
        for (int i=0; i<N; i++) {
620
            LocalActivityRecord r = .get(i);
621
            if () Log.v(, r.id + ": destroying");
622
            .performDestroyActivity(r, finishing);
623
        }
624
        .clear();
625
        .clear();
626
    }
New to GrepCode? Check out our FAQ X