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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (C) 2011 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.support.v4.app;
18
  
22
  import android.os.Bundle;
24
  import android.os.Looper;
25
  import android.os.Parcel;
32
  import android.util.Log;
44
  import android.view.Menu;
47
  import android.view.View;
49
  
53
  import java.util.Arrays;
54
  import java.util.List;

Static library support version of the framework's android.app.FragmentManager. Used to write apps that run on platforms prior to Android 3.0. When running on Android 3.0 or above, this implementation is still used; it does not try to switch to the framework's implementation. See the framework FragmentManager documentation for a class overview.

Your activity must derive from FragmentActivity to use this. From such an activity, you can acquire the FragmentManager by calling FragmentActivity.getSupportFragmentManager(). 

66
  
67
  public abstract class FragmentManager {
    
Representation of an entry on the fragment back stack, as created with FragmentTransaction.addToBackStack(). Entries can later be retrieved with FragmentManager.getBackStackEntry().

Note that you should never hold on to a BackStackEntry object; the identifier as returned by getId() is the only thing that will be persisted across activity instances. 

78
  
79
      public interface BackStackEntry {
        
Return the unique identifier for the entry. This is the only representation of the entry that will persist across activity instances. 
84
  
85
          public int getId();

        
Get the name that was supplied to FragmentTransaction.addToBackStack(String) when creating this entry. 
91
  
92
          public String getName();

        
Return the full bread crumb title resource identifier for the entry, or 0 if it does not have one. 
97
  
98
          @StringRes
99
          public int getBreadCrumbTitleRes();

        
Return the short bread crumb title resource identifier for the entry, or 0 if it does not have one. 
104
 
105
         @StringRes
106
         public int getBreadCrumbShortTitleRes();

        
Return the full bread crumb title for the entry, or null if it does not have one. 
111
 
112
         public CharSequence getBreadCrumbTitle();

        
Return the short bread crumb title for the entry, or null if it does not have one. 
117
 
118
         public CharSequence getBreadCrumbShortTitle();
119
     }

    
Interface to watch for changes to the back stack. 
123
 
124
     public interface OnBackStackChangedListener {
        
Called whenever the contents of the back stack change. 
127
 
128
         public void onBackStackChanged();
129
     }

    
Start a series of edit operations on the Fragments associated with this FragmentManager.

Note: A fragment transaction can only be created/committed prior to an activity saving its state. If you try to commit a transaction after FragmentActivity.onSaveInstanceState() (and prior to a following FragmentActivity.onStart or FragmentActivity.onResume(), you will get an error. This is because the framework takes care of saving your current fragments in the state, and if changes are made after the state is saved then they will be lost.

143
 
144
     public abstract FragmentTransaction beginTransaction();

    

Hide:
-- remove once prebuilts are in.
146
 
147
     @Deprecated
148
     public FragmentTransaction openTransaction() {
149
         return beginTransaction();
150
     }
    
    
After a FragmentTransaction is committed with FragmentTransaction.commit(), it is scheduled to be executed asynchronously on the process's main thread. If you want to immediately executing any such pending operations, you can call this function (only from the main thread) to do so. Note that all callbacks and other related behavior will be done from within this call, so be careful about where this is called from.

Returns:
Returns true if there were any pending transactions to be executed.
163
 
164
     public abstract boolean executePendingTransactions();

    
Finds a fragment that was identified by the given id either when inflated from XML or as the container ID when added in a transaction. This first searches through fragments that are currently added to the manager's activity; if no such fragment is found, then all fragments currently on the back stack associated with this ID are searched.

Returns:
The fragment if found or null otherwise.
173
 
174
     public abstract Fragment findFragmentById(@IdRes int id);

    
Finds a fragment that was identified by the given tag either when inflated from XML or as supplied when added in a transaction. This first searches through fragments that are currently added to the manager's activity; if no such fragment is found, then all fragments currently on the back stack are searched.

Returns:
The fragment if found or null otherwise.
183
 
184
     public abstract Fragment findFragmentByTag(String tag);

    
Flag for popBackStack(java.lang.String,int) and popBackStack(int,int): If set, and the name or ID of a back stack entry has been supplied, then all matching entries will be consumed until one that doesn't match is found or the bottom of the stack is reached. Otherwise, all entries up to but not including that entry will be removed. 
193
 
194
     public static final int POP_BACK_STACK_INCLUSIVE = 1<<0;

    
Pop the top state off the back stack. Returns true if there was one to pop, else false. This function is asynchronous -- it enqueues the request to pop, but the action will not be performed until the application returns to its event loop. 
201
 
202
     public abstract void popBackStack();

    
Like popBackStack(), but performs the operation immediately inside of the call. This is like calling executePendingTransactions() afterwards.

Returns:
Returns true if there was something popped, else false.
209
 
210
     public abstract boolean popBackStackImmediate();

    
Pop the last fragment transition from the manager's fragment back stack. If there is nothing to pop, false is returned. This function is asynchronous -- it enqueues the request to pop, but the action will not be performed until the application returns to its event loop.

Parameters:
name If non-null, this is the name of a previous back state to look for; if found, all states up to that state will be popped. The POP_BACK_STACK_INCLUSIVE flag can be used to control whether the named state itself is popped. If null, only the top state is popped.
flags Either 0 or POP_BACK_STACK_INCLUSIVE.
224
 
225
     public abstract void popBackStack(String name, int flags);

    
Like popBackStack(java.lang.String,int), but performs the operation immediately inside of the call. This is like calling executePendingTransactions() afterwards.

Returns:
Returns true if there was something popped, else false.
232
 
233
     public abstract boolean popBackStackImmediate(String name, int flags);

    
Pop all back stack states up to the one with the given identifier. This function is asynchronous -- it enqueues the request to pop, but the action will not be performed until the application returns to its event loop.

Parameters:
id Identifier of the stated to be popped. If no identifier exists, false is returned. The identifier is the number returned by FragmentTransaction.commit(). The POP_BACK_STACK_INCLUSIVE flag can be used to control whether the named state itself is popped.
flags Either 0 or POP_BACK_STACK_INCLUSIVE.
248
 
249
     public abstract void popBackStack(int id, int flags);

    
Like popBackStack(int,int), but performs the operation immediately inside of the call. This is like calling executePendingTransactions() afterwards.

Returns:
Returns true if there was something popped, else false.
256
 
257
     public abstract boolean popBackStackImmediate(int id, int flags);

    
Return the number of entries currently in the back stack. 
261
 
262
     public abstract int getBackStackEntryCount();

    
Return the BackStackEntry at index index in the back stack; entries start index 0 being the bottom of the stack. 
267
 
268
     public abstract BackStackEntry getBackStackEntryAt(int index);

    
Add a new listener for changes to the fragment back stack. 
272
 
273
     public abstract void addOnBackStackChangedListener(OnBackStackChangedListener listener);

    
Remove a listener that was previously added with addOnBackStackChangedListener(android.support.v4.app.FragmentManager.OnBackStackChangedListener). 
278
 
279
     public abstract void removeOnBackStackChangedListener(OnBackStackChangedListener listener);

    
Put a reference to a fragment in a Bundle. This Bundle can be persisted as saved state, and when later restoring getFragment(android.os.Bundle,java.lang.String) will return the current instance of the same fragment.

Parameters:
bundle The bundle in which to put the fragment reference.
key The name of the entry in the bundle.
fragment The Fragment whose reference is to be stored.
290
 
291
     public abstract void putFragment(Bundle bundle, String key, Fragment fragment);

    
Retrieve the current Fragment instance for a reference previously placed with putFragment(android.os.Bundle,java.lang.String,android.support.v4.app.Fragment).

Parameters:
bundle The bundle from which to retrieve the fragment reference.
key The name of the entry in the bundle.
Returns:
Returns the current Fragment instance that is associated with the given reference.
301
 
302
     public abstract Fragment getFragment(Bundle bundle, String key);

    
Get a list of all fragments that have been added to the fragment manager.

Returns:
The list of all fragments or null if none.
Hide:
309
 
310
     public abstract List<Fragment> getFragments();

    
Save the current instance state of the given Fragment. This can be used later when creating a new instance of the Fragment and adding it to the fragment manager, to have it create itself to match the current state returned here. Note that there are limits on how this can be used:
  • The Fragment must currently be attached to the FragmentManager.
  • A new Fragment created using this saved state must be the same class type as the Fragment it was created from.
  • The saved state can not contain dependencies on other fragments -- that is it can't use putFragment(android.os.Bundle,java.lang.String,android.support.v4.app.Fragment) to store a fragment reference because that reference may not be valid when this saved state is later used. Likewise the Fragment's target and result code are not included in this state.

Parameters:
f The Fragment whose state is to be saved.
Returns:
The generated state. This will be null if there was no interesting state created by the fragment.
333
 
334
     public abstract Fragment.SavedState saveFragmentInstanceState(Fragment f);

    
Returns true if the final Activity.onDestroy() call has been made on the FragmentManager's Activity, so this instance is now dead. 
339
 
340
     public abstract boolean isDestroyed();

    
Print the FragmentManager's state into the given stream.

Parameters:
prefix Text to print at the front of each line.
fd The raw file descriptor that the dump is being sent to.
writer A PrintWriter to which the dump is to be set.
args Additional arguments to the dump request.
349
 
350
     public abstract void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args);

    
Control whether the framework's internal fragment manager debugging logs are turned on. If enabled, you will see output in logcat as the framework performs fragment operations. 
356
 
357
     public static void enableDebugLogging(boolean enabled) {
358
         . = enabled;
359
     }
360
 }
361
 
362
 final class FragmentManagerState implements Parcelable {
364
     int[] mAdded;
366
     
367
     public FragmentManagerState() {
368
     }
369
     
370
     public FragmentManagerState(Parcel in) {
372
          = in.createIntArray();
374
     }
375
     
376
     public int describeContents() {
377
         return 0;
378
     }
379
 
380
     public void writeToParcel(Parcel dest, int flags) {
381
         dest.writeTypedArray(, flags);
382
         dest.writeIntArray();
383
         dest.writeTypedArray(, flags);
384
     }
385
     
386
     public static final Parcelable.Creator<FragmentManagerState> CREATOR
387
             = new Parcelable.Creator<FragmentManagerState>() {
388
         public FragmentManagerState createFromParcel(Parcel in) {
389
             return new FragmentManagerState(in);
390
         }
391
         
392
         public FragmentManagerState[] newArray(int size) {
393
             return new FragmentManagerState[size];
394
         }
395
     };
396
 }

Callbacks from FragmentManagerImpl to its container. 
400
 
401
 interface FragmentContainer {
402
     public View findViewById(@IdRes int id);
403
     public boolean hasView();
404
 }

Container for fragments associated with an activity. 
408
 
409
 final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory {
410
     static boolean DEBUG = false;
411
     static final String TAG = "FragmentManager";
412
     
413
     static final boolean HONEYCOMB = .... >= 11;
414
 
415
     static final String TARGET_REQUEST_CODE_STATE_TAG = "android:target_req_state";
416
     static final String TARGET_STATE_TAG = "android:target_state";
417
     static final String VIEW_STATE_TAG = "android:view_state";
418
     static final String USER_VISIBLE_HINT_TAG = "android:user_visible_hint";
419
 
421
     Runnable[] mTmpActions;
422
     boolean mExecutingActions;
423
     
429
     
430
     // Must be accessed while locked.
433
 
435
 
436
     int mCurState = .;
439
     Fragment mParent;
440
     
441
     boolean mNeedMenuInvalidate;
442
     boolean mStateSaved;
443
     boolean mDestroyed;
445
     boolean mHavePendingDeferredStart;
446
     
447
     // Temporary vars for state save and restore.
448
     Bundle mStateBundle = null;
449
     SparseArray<Parcelable> mStateArray = null;
450
     
451
     Runnable mExecCommit = new Runnable() {
452
         @Override
453
         public void run() {
454
             execPendingActions();
455
         }
456
     };
457
 
458
     private void throwException(RuntimeException ex) {
459
         Log.e(, ex.getMessage());
460
         Log.e(, "Activity state:");
461
         LogWriter logw = new LogWriter();
462
         PrintWriter pw = new PrintWriter(logw);
463
         if ( != null) {
464
             try {
465
                 .dump("  ", null, pw, new String[] { });
466
             } catch (Exception e) {
467
                 Log.e(, "Failed dumping state", e);
468
             }
469
         } else {
470
             try {
471
                 dump("  ", null, pw, new String[] { });
472
             } catch (Exception e) {
473
                 Log.e(, "Failed dumping state", e);
474
             }
475
         }
476
         throw ex;
477
     }
478
 
479
     @Override
481
         return new BackStackRecord(this);
482
     }
483
 
484
     @Override
485
     public boolean executePendingTransactions() {
486
         return execPendingActions();
487
     }
488
 
489
     @Override
490
     public void popBackStack() {
491
         enqueueAction(new Runnable() {
492
             @Override public void run() {
493
                 popBackStackState(., null, -1, 0);
494
             }
495
         }, false);
496
     }
497
 
498
     @Override
499
     public boolean popBackStackImmediate() {
500
         checkStateLoss();
501
         executePendingTransactions();
502
         return popBackStackState(., null, -1, 0);
503
     }
504
 
505
     @Override
506
     public void popBackStack(final String name, final int flags) {
507
         enqueueAction(new Runnable() {
508
             @Override public void run() {
509
                 popBackStackState(., name, -1, flags);
510
             }
511
         }, false);
512
     }
513
 
514
     @Override
515
     public boolean popBackStackImmediate(String name, int flags) {
516
         checkStateLoss();
517
         executePendingTransactions();
518
         return popBackStackState(., name, -1, flags);
519
     }
520
 
521
     @Override
522
     public void popBackStack(final int id, final int flags) {
523
         if (id < 0) {
524
             throw new IllegalArgumentException("Bad id: " + id);
525
         }
526
         enqueueAction(new Runnable() {
527
             @Override public void run() {
528
                 popBackStackState(., null, id, flags);
529
             }
530
         }, false);
531
     }
532
 
533
     @Override
534
     public boolean popBackStackImmediate(int id, int flags) {
535
         checkStateLoss();
536
         executePendingTransactions();
537
         if (id < 0) {
538
             throw new IllegalArgumentException("Bad id: " + id);
539
         }
540
         return popBackStackState(., null, id, flags);
541
     }
542
 
543
     @Override
544
     public int getBackStackEntryCount() {
545
         return  != null ? .size() : 0;
546
     }
547
 
548
     @Override
549
     public BackStackEntry getBackStackEntryAt(int index) {
550
         return .get(index);
551
     }
552
 
553
     @Override
554
     public void addOnBackStackChangedListener(OnBackStackChangedListener listener) {
555
         if ( == null) {
557
         }
558
         .add(listener);
559
     }
560
 
561
     @Override
563
         if ( != null) {
564
             .remove(listener);
565
         }
566
     }
567
 
568
     @Override
569
     public void putFragment(Bundle bundle, String key, Fragment fragment) {
570
         if (fragment.mIndex < 0) {
571
             throwException(new IllegalStateException("Fragment " + fragment
572
                     + " is not currently in the FragmentManager"));
573
         }
574
         bundle.putInt(key, fragment.mIndex);
575
     }
576
 
577
     @Override
578
     public Fragment getFragment(Bundle bundle, String key) {
579
         int index = bundle.getInt(key, -1);
580
         if (index == -1) {
581
             return null;
582
         }
583
         if (index >= .size()) {
584
             throwException(new IllegalStateException("Fragment no longer exists for key "
585
                     + key + ": index " + index));
586
         }
587
         Fragment f = .get(index);
588
         if (f == null) {
589
             throwException(new IllegalStateException("Fragment no longer exists for key "
590
                     + key + ": index " + index));
591
         }
592
         return f;
593
     }
594
 
595
     @Override
596
     public List<Fragment> getFragments() {
597
         return ;
598
     }
599
 
600
     @Override
601
     public Fragment.SavedState saveFragmentInstanceState(Fragment fragment) {
602
         if (fragment.mIndex < 0) {
603
             throwException( new IllegalStateException("Fragment " + fragment
604
                     + " is not currently in the FragmentManager"));
605
         }
606
         if (fragment.mState > .) {
607
             Bundle result = saveFragmentBasicState(fragment);
608
             return result != null ? new Fragment.SavedState(result) : null;
609
         }
610
         return null;
611
     }
612
 
613
     @Override
614
     public boolean isDestroyed() {
615
         return ;
616
     }
617
 
618
     @Override
619
     public String toString() {
620
         StringBuilder sb = new StringBuilder(128);
621
         sb.append("FragmentManager{");
622
         sb.append(Integer.toHexString(System.identityHashCode(this)));
623
         sb.append(" in ");
624
         if ( != null) {
625
             DebugUtils.buildShortClassTag(, sb);
626
         } else {
627
             DebugUtils.buildShortClassTag(, sb);
628
         }
629
         sb.append("}}");
630
         return sb.toString();
631
     }
632
 
633
     @Override
634
     public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
635
         String innerPrefix = prefix + "    ";
636
 
637
         int N;
638
         if ( != null) {
639
             N = .size();
640
             if (N > 0) {
641
                 writer.print(prefix); writer.print("Active Fragments in ");
642
                         writer.print(Integer.toHexString(System.identityHashCode(this)));
643
                         writer.println(":");
644
                 for (int i=0; i<N; i++) {
645
                     Fragment f = .get(i);
646
                     writer.print(prefix); writer.print("  #"); writer.print(i);
647
                             writer.print(": "); writer.println(f);
648
                     if (f != null) {
649
                         f.dump(innerPrefix, fd, writer, args);
650
                     }
651
                 }
652
             }
653
         }
654
 
655
         if ( != null) {
656
             N = .size();
657
             if (N > 0) {
658
                 writer.print(prefix); writer.println("Added Fragments:");
659
                 for (int i=0; i<N; i++) {
660
                     Fragment f = .get(i);
661
                     writer.print(prefix); writer.print("  #"); writer.print(i);
662
                             writer.print(": "); writer.println(f.toString());
663
                 }
664
             }
665
         }
666
 
667
         if ( != null) {
668
             N = .size();
669
             if (N > 0) {
670
                 writer.print(prefix); writer.println("Fragments Created Menus:");
671
                 for (int i=0; i<N; i++) {
672
                     Fragment f = .get(i);
673
                     writer.print(prefix); writer.print("  #"); writer.print(i);
674
                             writer.print(": "); writer.println(f.toString());
675
                 }
676
             }
677
         }
678
 
679
         if ( != null) {
680
             N = .size();
681
             if (N > 0) {
682
                 writer.print(prefix); writer.println("Back Stack:");
683
                 for (int i=0; i<N; i++) {
684
                     BackStackRecord bs = .get(i);
685
                     writer.print(prefix); writer.print("  #"); writer.print(i);
686
                             writer.print(": "); writer.println(bs.toString());
687
                     bs.dump(innerPrefix, fd, writer, args);
688
                 }
689
             }
690
         }
691
 
692
         synchronized (this) {
693
             if ( != null) {
694
                 N = .size();
695
                 if (N > 0) {
696
                     writer.print(prefix); writer.println("Back Stack Indices:");
697
                     for (int i=0; i<N; i++) {
698
                         BackStackRecord bs = .get(i);
699
                         writer.print(prefix); writer.print("  #"); writer.print(i);
700
                                 writer.print(": "); writer.println(bs);
701
                     }
702
                 }
703
             }
704
 
705
             if ( != null && .size() > 0) {
706
                 writer.print(prefix); writer.print("mAvailBackStackIndices: ");
707
                         writer.println(Arrays.toString(.toArray()));
708
             }
709
         }
710
 
711
         if ( != null) {
712
             N = .size();
713
             if (N > 0) {
714
                 writer.print(prefix); writer.println("Pending Actions:");
715
                 for (int i=0; i<N; i++) {
716
                     Runnable r = .get(i);
717
                     writer.print(prefix); writer.print("  #"); writer.print(i);
718
                             writer.print(": "); writer.println(r);
719
                 }
720
             }
721
         }
722
 
723
         writer.print(prefix); writer.println("FragmentManager misc state:");
724
         writer.print(prefix); writer.print("  mActivity="); writer.println();
725
         writer.print(prefix); writer.print("  mContainer="); writer.println();
726
         if ( != null) {
727
             writer.print(prefix); writer.print("  mParent="); writer.println();
728
         }
729
         writer.print(prefix); writer.print("  mCurState="); writer.print();
730
                 writer.print(" mStateSaved="); writer.print();
731
                 writer.print(" mDestroyed="); writer.println();
732
         if () {
733
             writer.print(prefix); writer.print("  mNeedMenuInvalidate=");
734
                     writer.println();
735
         }
736
         if ( != null) {
737
             writer.print(prefix); writer.print("  mNoTransactionsBecause=");
738
                     writer.println();
739
         }
740
         if ( != null && .size() > 0) {
741
             writer.print(prefix); writer.print("  mAvailIndices: ");
742
                     writer.println(Arrays.toString(.toArray()));
743
         }
744
     }
745
 
746
     static final Interpolator DECELERATE_QUINT = new DecelerateInterpolator(2.5f);
747
     static final Interpolator DECELERATE_CUBIC = new DecelerateInterpolator(1.5f);
748
     static final Interpolator ACCELERATE_QUINT = new AccelerateInterpolator(2.5f);
749
     static final Interpolator ACCELERATE_CUBIC = new AccelerateInterpolator(1.5f);
750
     
751
     static final int ANIM_DUR = 220;
752
     
753
     static Animation makeOpenCloseAnimation(Context context, float startScale,
754
             float endScale, float startAlpha, float endAlpha) {
755
         AnimationSet set = new AnimationSet(false);
756
         ScaleAnimation scale = new ScaleAnimation(startScale, endScale, startScale, endScale,
757
                 ., .5f, ., .5f);
758
         scale.setInterpolator();
759
         scale.setDuration();
760
         set.addAnimation(scale);
761
         AlphaAnimation alpha = new AlphaAnimation(startAlpha, endAlpha);
762
         alpha.setInterpolator();
763
         alpha.setDuration();
764
         set.addAnimation(alpha);
765
         return set;
766
     }
767
     
768
     static Animation makeFadeAnimation(Context context, float start, float end) {
769
         AlphaAnimation anim = new AlphaAnimation(start, end);
770
         anim.setInterpolator();
771
         anim.setDuration();
772
         return anim;
773
     }
774
     
775
     Animation loadAnimation(Fragment fragment, int transit, boolean enter,
776
             int transitionStyle) {
777
         Animation animObj = fragment.onCreateAnimation(transit, enter,
778
                 fragment.mNextAnim);
779
         if (animObj != null) {
780
             return animObj;
781
         }
782
         
783
         if (fragment.mNextAnim != 0) {
784
             Animation anim = AnimationUtils.loadAnimation(, fragment.mNextAnim);
785
             if (anim != null) {
786
                 return anim;
787
             }
788
         }
789
         
790
         if (transit == 0) {
791
             return null;
792
         }
793
         
794
         int styleIndex = transitToStyleIndex(transit, enter);
795
         if (styleIndex < 0) {
796
             return null;
797
         }
798
         
799
         switch (styleIndex) {
800
             case :
801
                 return makeOpenCloseAnimation(, 1.125f, 1.0f, 0, 1);
802
             case :
803
                 return makeOpenCloseAnimation(, 1.0f, .975f, 1, 0);
804
             case :
805
                 return makeOpenCloseAnimation(, .975f, 1.0f, 0, 1);
806
             case :
807
                 return makeOpenCloseAnimation(, 1.0f, 1.075f, 1, 0);
808
             case :
809
                 return makeFadeAnimation(, 0, 1);
810
             case :
811
                 return makeFadeAnimation(, 1, 0);
812
         }
813
         
814
         if (transitionStyle == 0 && .getWindow() != null) {
815
             transitionStyle = .getWindow().getAttributes().;
816
         }
817
         if (transitionStyle == 0) {
818
             return null;
819
         }
820
         
821
         //TypedArray attrs = mActivity.obtainStyledAttributes(transitionStyle,
822
         //        com.android.internal.R.styleable.FragmentAnimation);
823
         //int anim = attrs.getResourceId(styleIndex, 0);
824
         //attrs.recycle();
825
         
826
         //if (anim == 0) {
827
         //    return null;
828
         //}
829
         
830
         //return AnimatorInflater.loadAnimator(mActivity, anim);
831
         return null;
832
     }
833
     
834
     public void performPendingDeferredStart(Fragment f) {
835
         if (f.mDeferStart) {
836
             if () {
837
                 // Wait until we're done executing our pending transactions
838
                  = true;
839
                 return;
840
             }
841
             f.mDeferStart = false;
842
             moveToState(f, , 0, 0, false);
843
         }
844
     }
845
 
846
     void moveToState(Fragment f, int newState, int transit, int transitionStyle,
847
             boolean keepActive) {
848
         // Fragments that are not currently added will sit in the onCreate() state.
849
         if ((!f.mAdded || f.mDetached) && newState > .) {
850
             newState = .;
851
         }
852
         if (f.mRemoving && newState > f.mState) {
853
             // While removing a fragment, we can't change it to a higher state.
854
             newState = f.mState;
855
         }
856
         // Defer start if requested; don't allow it to move to STARTED or higher
857
         // if it's not already started.
858
         if (f.mDeferStart && f.mState < . && newState > .) {
859
             newState = .;
860
         }
861
         if (f.mState < newState) {
862
             // For fragments that are created from a layout, when restoring from
863
             // state we don't want to allow them to be created until they are
864
             // being reloaded from the layout.
865
             if (f.mFromLayout && !f.mInLayout) {
866
                 return;
867
             }  
868
             if (f.mAnimatingAway != null) {
869
                 // The fragment is currently being animated...  but!  Now we
870
                 // want to move our state back up.  Give up on waiting for the
871
                 // animation, move to whatever the final state should be once
872
                 // the animation is done, and then we can proceed from there.
873
                 f.mAnimatingAway = null;
874
                 moveToState(f, f.mStateAfterAnimating, 0, 0, true);
875
             }
876
             switch (f.mState) {
877
                 case .:
878
                     if () Log.v(, "moveto CREATED: " + f);
879
                     if (f.mSavedFragmentState != null) {
880
                         f.mSavedFragmentState.setClassLoader(.getClassLoader());
881
                         f.mSavedViewState = f.mSavedFragmentState.getSparseParcelableArray(
882
                                 .);
883
                         f.mTarget = getFragment(f.mSavedFragmentState,
884
                                 .);
885
                         if (f.mTarget != null) {
886
                             f.mTargetRequestCode = f.mSavedFragmentState.getInt(
887
                                     ., 0);
888
                         }
889
                         f.mUserVisibleHint = f.mSavedFragmentState.getBoolean(
890
                                 ., true);
891
                         if (!f.mUserVisibleHint) {
892
                             f.mDeferStart = true;
893
                             if (newState > .) {
894
                                 newState = .;
895
                             }
896
                         }
897
                     }
898
                     f.mActivity = ;
899
                     f.mParentFragment = ;
900
                     f.mFragmentManager =  != null
901
                             ? . : .;
902
                     f.mCalled = false;
903
                     f.onAttach();
904
                     if (!f.mCalled) {
905
                         throw new SuperNotCalledException("Fragment " + f
906
                                 + " did not call through to super.onAttach()");
907
                     }
908
                     if (f.mParentFragment == null) {
909
                         .onAttachFragment(f);
910
                     }
911
 
912
                     if (!f.mRetaining) {
913
                         f.performCreate(f.mSavedFragmentState);
914
                     }
915
                     f.mRetaining = false;
916
                     if (f.mFromLayout) {
917
                         // For fragments that are part of the content view
918
                         // layout, we need to instantiate the view immediately
919
                         // and the inflater will take care of adding it.
920
                         f.mView = f.performCreateView(f.getLayoutInflater(
921
                                 f.mSavedFragmentState), null, f.mSavedFragmentState);
922
                         if (f.mView != null) {
923
                             f.mInnerView = f.mView;
924
                             f.mView = NoSaveStateFrameLayout.wrap(f.mView);
925
                             if (f.mHidden) f.mView.setVisibility(.);
926
                             f.onViewCreated(f.mView, f.mSavedFragmentState);
927
                         } else {
928
                             f.mInnerView = null;
929
                         }
930
                     }
931
                 case .:
932
                     if (newState > .) {
933
                         if () Log.v(, "moveto ACTIVITY_CREATED: " + f);
934
                         if (!f.mFromLayout) {
935
                             ViewGroup container = null;
936
                             if (f.mContainerId != 0) {
937
                                 container = (ViewGroup).findViewById(f.mContainerId);
938
                                 if (container == null && !f.mRestored) {
939
                                     throwException(new IllegalArgumentException(
940
                                             "No view found for id 0x"
941
                                             + Integer.toHexString(f.mContainerId) + " ("
942
                                             + f.getResources().getResourceName(f.mContainerId)
943
                                             + ") for fragment " + f));
944
                                 }
945
                             }
946
                             f.mContainer = container;
947
                             f.mView = f.performCreateView(f.getLayoutInflater(
948
                                     f.mSavedFragmentState), container, f.mSavedFragmentState);
949
                             if (f.mView != null) {
950
                                 f.mInnerView = f.mView;
951
                                 f.mView = NoSaveStateFrameLayout.wrap(f.mView);
952
                                 if (container != null) {
953
                                     Animation anim = loadAnimation(f, transit, true,
954
                                             transitionStyle);
955
                                     if (anim != null) {
956
                                         f.mView.startAnimation(anim);
957
                                     }
958
                                     container.addView(f.mView);
959
                                 }
960
                                 if (f.mHidden) f.mView.setVisibility(.);
961
                                 f.onViewCreated(f.mView, f.mSavedFragmentState);
962
                             } else {
963
                                 f.mInnerView = null;
964
                             }
965
                         }
966
 
967
                         f.performActivityCreated(f.mSavedFragmentState);
968
                         if (f.mView != null) {
969
                             f.restoreViewState(f.mSavedFragmentState);
970
                         }
971
                         f.mSavedFragmentState = null;
972
                     }
973
                 case .:
974
                 case .:
975
                     if (newState > .) {
976
                         if () Log.v(, "moveto STARTED: " + f);
977
                         f.performStart();
978
                     }
979
                 case .:
980
                     if (newState > .) {
981
                         if () Log.v(, "moveto RESUMED: " + f);
982
                         f.mResumed = true;
983
                         f.performResume();
984
                         f.mSavedFragmentState = null;
985
                         f.mSavedViewState = null;
986
                     }
987
             }
988
         } else if (f.mState > newState) {
989
             switch (f.mState) {
990
                 case .:
991
                     if (newState < .) {
992
                         if () Log.v(, "movefrom RESUMED: " + f);
993
                         f.performPause();
994
                         f.mResumed = false;
995
                     }
996
                 case .:
997
                     if (newState < .) {
998
                         if () Log.v(, "movefrom STARTED: " + f);
999
                         f.performStop();
1000
                    }
1001
                case .:
1002
                    if (newState < .) {
1003
                        if () Log.v(, "movefrom STOPPED: " + f);
1004
                        f.performReallyStop();
1005
                    }
1006
                case .:
1007
                    if (newState < .) {
1008
                        if () Log.v(, "movefrom ACTIVITY_CREATED: " + f);
1009
                        if (f.mView != null) {
1010
                            // Need to save the current view state if not
1011
                            // done already.
1012
                            if (!.isFinishing() && f.mSavedViewState == null) {
1013
                                saveFragmentViewState(f);
1014
                            }
1015
                        }
1016
                        f.performDestroyView();
1017
                        if (f.mView != null && f.mContainer != null) {
1018
                            Animation anim = null;
1019
                            if ( > . && !) {
1020
                                anim = loadAnimation(f, transit, false,
1021
                                        transitionStyle);
1022
                            }
1023
                            if (anim != null) {
1024
                                final Fragment fragment = f;
1025
                                f.mAnimatingAway = f.mView;
1026
                                f.mStateAfterAnimating = newState;
1027
                                anim.setAnimationListener(new AnimationListener() {
1028
                                    @Override
1029
                                    public void onAnimationEnd(Animation animation) {
1030
                                        if (fragment.mAnimatingAway != null) {
1031
                                            fragment.mAnimatingAway = null;
1032
                                            moveToState(fragment, fragment.mStateAfterAnimating,
1033
                                                    0, 0, false);
1034
                                        }
1035
                                    }
1036
                                    @Override
1037
                                    public void onAnimationRepeat(Animation animation) {
1038
                                    }
1039
                                    @Override
1040
                                    public void onAnimationStart(Animation animation) {
1041
                                    }
1042
                                });
1043
                                f.mView.startAnimation(anim);
1044
                            }
1045
                            f.mContainer.removeView(f.mView);
1046
                        }
1047
                        f.mContainer = null;
1048
                        f.mView = null;
1049
                        f.mInnerView = null;
1050
                    }
1051
                case .:
1052
                    if (newState < .) {
1053
                        if () {
1054
                            if (f.mAnimatingAway != null) {
1055
                                // The fragment's containing activity is
1056
                                // being destroyed, but this fragment is
1057
                                // currently animating away.  Stop the
1058
                                // animation right now -- it is not needed,
1059
                                // and we can't wait any more on destroying
1060
                                // the fragment.
1061
                                View v = f.mAnimatingAway;
1062
                                f.mAnimatingAway = null;
1063
                                v.clearAnimation();
1064
                            }
1065
                        }
1066
                        if (f.mAnimatingAway != null) {
1067
                            // We are waiting for the fragment's view to finish
1068
                            // animating away.  Just make a note of the state
1069
                            // the fragment now should move to once the animation
1070
                            // is done.
1071
                            f.mStateAfterAnimating = newState;
1072
                            newState = .;
1073
                        } else {
1074
                            if () Log.v(, "movefrom CREATED: " + f);
1075
                            if (!f.mRetaining) {
1076
                                f.performDestroy();
1077
                            }
1079
                            f.mCalled = false;
1080
                            f.onDetach();
1081
                            if (!f.mCalled) {
1082
                                throw new SuperNotCalledException("Fragment " + f
1083
                                        + " did not call through to super.onDetach()");
1084
                            }
1085
                            if (!keepActive) {
1086
                                if (!f.mRetaining) {
1087
                                    makeInactive(f);
1088
                                } else {
1089
                                    f.mActivity = null;
1090
                                    f.mParentFragment = null;
1091
                                    f.mFragmentManager = null;
1092
                                    f.mChildFragmentManager = null;
1093
                                }
1094
                            }
1095
                        }
1096
                    }
1097
            }
1098
        }
1099
        
1100
        f.mState = newState;
1101
    }
1102
    
1103
    void moveToState(Fragment f) {
1104
        moveToState(f, , 0, 0, false);
1105
    }
1107
    void moveToState(int newState, boolean always) {
1108
        moveToState(newState, 0, 0, always);
1109
    }
1110
    
1111
    void moveToState(int newState, int transit, int transitStyle, boolean always) {
1112
        if ( == null && newState != .) {
1113
            throw new IllegalStateException("No activity");
1114
        }
1116
        if (!always &&  == newState) {
1117
            return;
1118
        }
1120
         = newState;
1121
        if ( != null) {
1122
            boolean loadersRunning = false;
1123
            for (int i=0; i<.size(); i++) {
1124
                Fragment f = .get(i);
1125
                if (f != null) {
1126
                    moveToState(f, newState, transit, transitStyle, false);
1127
                    if (f.mLoaderManager != null) {
1128
                        loadersRunning |= f.mLoaderManager.hasRunningLoaders();
1129
                    }
1130
                }
1131
            }
1133
            if (!loadersRunning) {
1134
                startPendingDeferredFragments();
1135
            }
1137
            if ( &&  != null &&  == .) {
1138
                .supportInvalidateOptionsMenu();
1139
                 = false;
1140
            }
1141
        }
1142
    }
1145
        if ( == null) return;
1147
        for (int i=0; i<.size(); i++) {
1148
            Fragment f = .get(i);
1149
            if (f != null) {
1150
                performPendingDeferredStart(f);
1151
            }
1152
        }
1153
    }
1154
    
1155
    void makeActive(Fragment f) {
1156
        if (f.mIndex >= 0) {
1157
            return;
1158
        }
1159
        
1160
        if ( == null || .size() <= 0) {
1161
            if ( == null) {
1162
                 = new ArrayList<Fragment>();
1163
            }
1164
            f.setIndex(.size(), );
1165
            .add(f);
1166
            
1167
        } else {
1168
            f.setIndex(.remove(.size()-1), );
1169
            .set(f.mIndex, f);
1170
        }
1171
        if () Log.v(, "Allocated fragment index " + f);
1172
    }
1173
    
1174
    void makeInactive(Fragment f) {
1175
        if (f.mIndex < 0) {
1176
            return;
1177
        }
1178
        
1179
        if () Log.v(, "Freeing fragment index " + f);
1180
        .set(f.mIndex, null);
1181
        if ( == null) {
1182