/*

* Copyright (C) 2010 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.animation.Animator;

import android.animation.AnimatorInflater;

import android.animation.AnimatorListenerAdapter;

import android.animation.AnimatorSet;

import android.animation.PropertyValuesHolder;

import android.animation.ValueAnimator;

import android.content.Context;

import android.content.res.Configuration;

import android.content.res.TypedArray;

import android.os.Bundle;

import android.os.Debug;

import android.os.Handler;

import android.os.Looper;

import android.os.Parcel;

import android.os.Parcelable;

import android.util.AttributeSet;

import android.util.DebugUtils;

import android.util.Log;

import android.util.LogWriter;

import android.util.SparseArray;

import android.util.SuperNotCalledException;

import android.view.LayoutInflater;

import android.view.Menu;

import android.view.MenuInflater;

import android.view.MenuItem;

import android.view.View;

import android.view.ViewGroup;

import com.android.internal.util.FastPrintWriter;

import java.io.FileDescriptor;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/**

* Interface for interacting with {@link Fragment} objects inside of an

* {@link Activity}

*

* <div class="special reference">

* <h3>Developer Guides</h3>

* <p>For more information about using fragments, read the

* <a href="{@docRoot}guide/topics/fundamentals/fragments.html">Fragments</a> developer guide.</p>

* </div>

*

* While the FragmentManager API was introduced in

* {@link android.os.Build.VERSION_CODES#HONEYCOMB}, a version of the API

* at is also available for use on older platforms through

* {@link android.support.v4.app.FragmentActivity}. See the blog post

* <a href="http://android-developers.blogspot.com/2011/03/fragments-for-all.html">

* Fragments For All</a> for more details.

*/

public abstract class FragmentManager {

/**

* Representation of an entry on the fragment back stack, as created

* with {@link FragmentTransaction#addToBackStack(String)

* FragmentTransaction.addToBackStack()}. Entries can later be

* retrieved with {@link FragmentManager#getBackStackEntryAt(int)

* FragmentManager.getBackStackEntryAt()}.

*

* <p>Note that you should never hold on to a BackStackEntry object;

* the identifier as returned by {@link #getId} is the only thing that

* will be persisted across activity instances.

*/

public interface BackStackEntry {

/**

* Return the unique identifier for the entry. This is the only

* representation of the entry that will persist across activity

* instances.

*/

public int getId();

/**

* Get the name that was supplied to

* {@link FragmentTransaction#addToBackStack(String)

* FragmentTransaction.addToBackStack(String)} when creating this entry.

*/

public String getName();

/**

* Return the full bread crumb title resource identifier for the entry,

* or 0 if it does not have one.

*/

public int getBreadCrumbTitleRes();

/**

* Return the short bread crumb title resource identifier for the entry,

* or 0 if it does not have one.

*/

public int getBreadCrumbShortTitleRes();

/**

* Return the full bread crumb title for the entry, or null if it

* does not have one.

*/

public CharSequence getBreadCrumbTitle();

/**

* Return the short bread crumb title for the entry, or null if it

* does not have one.

*/

public CharSequence getBreadCrumbShortTitle();

}

/**

* Interface to watch for changes to the back stack.

*/

public interface OnBackStackChangedListener {

/**

* Called whenever the contents of the back stack change.

*/

public void onBackStackChanged();

}

/**

* Start a series of edit operations on the Fragments associated with

* this FragmentManager.

*

* <p>Note: A fragment transaction can only be created/committed prior

* to an activity saving its state. If you try to commit a transaction

* after {@link Activity#onSaveInstanceState Activity.onSaveInstanceState()}

* (and prior to a following {@link Activity#onStart Activity.onStart}

* or {@link Activity#onResume Activity.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.</p>

*/

public abstract FragmentTransaction beginTransaction();

/** @hide -- remove once prebuilts are in. */

@Deprecated

public FragmentTransaction openTransaction() {

return beginTransaction();

}

/**

* After a {@link FragmentTransaction} is committed with

* {@link FragmentTransaction#commit 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.

*

* @return Returns true if there were any pending transactions to be

* executed.

*/

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.

* @return The fragment if found or null otherwise.

*/

public abstract Fragment findFragmentById(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.

* @return The fragment if found or null otherwise.

*/

public abstract Fragment findFragmentByTag(String tag);

/**

* Flag for {@link #popBackStack(String, int)}

* and {@link #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.

*/

public static final int POP_BACK_STACK_INCLUSIVE = 1<<0;

/**

* Pop the top state off the back stack. 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.

*/

public abstract void popBackStack();

/**

* Like {@link #popBackStack()}, but performs the operation immediately

* inside of the call. This is like calling {@link #executePendingTransactions()}

* afterwards.

* @return Returns true if there was something popped, else false.

*/

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.

*

* @param 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

* {@link #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.

* @param flags Either 0 or {@link #POP_BACK_STACK_INCLUSIVE}.

*/

public abstract void popBackStack(String name, int flags);

/**

* Like {@link #popBackStack(String, int)}, but performs the operation immediately

* inside of the call. This is like calling {@link #executePendingTransactions()}

* afterwards.

* @return Returns true if there was something popped, else false.

*/

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.

*

* @param id Identifier of the stated to be popped. If no identifier exists,

* false is returned.

* The identifier is the number returned by

* {@link FragmentTransaction#commit() FragmentTransaction.commit()}. The

* {@link #POP_BACK_STACK_INCLUSIVE} flag can be used to control whether

* the named state itself is popped.

* @param flags Either 0 or {@link #POP_BACK_STACK_INCLUSIVE}.

*/

public abstract void popBackStack(int id, int flags);

/**

* Like {@link #popBackStack(int, int)}, but performs the operation immediately

* inside of the call. This is like calling {@link #executePendingTransactions()}

* afterwards.

* @return Returns true if there was something popped, else false.

*/

public abstract boolean popBackStackImmediate(int id, int flags);

/**

* Return the number of entries currently in the back stack.

*/

public abstract int getBackStackEntryCount();

/**

* Return the BackStackEntry at index <var>index</var> in the back stack;

* where the item on the bottom of the stack has index 0.

*/

public abstract BackStackEntry getBackStackEntryAt(int index);

/**

* Add a new listener for changes to the fragment back stack.

*/

public abstract void addOnBackStackChangedListener(OnBackStackChangedListener listener);

/**

* Remove a listener that was previously added with

* {@link #addOnBackStackChangedListener(OnBackStackChangedListener)}.

*/

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

* {@link #getFragment(Bundle, String)} will return the current

* instance of the same fragment.

*

* @param bundle The bundle in which to put the fragment reference.

* @param key The name of the entry in the bundle.

* @param fragment The Fragment whose reference is to be stored.

*/

public abstract void putFragment(Bundle bundle, String key, Fragment fragment);

/**

* Retrieve the current Fragment instance for a reference previously

* placed with {@link #putFragment(Bundle, String, Fragment)}.

*

* @param bundle The bundle from which to retrieve the fragment reference.

* @param key The name of the entry in the bundle.

* @return Returns the current Fragment instance that is associated with

* the given reference.

*/

public abstract Fragment getFragment(Bundle bundle, String key);

/**

* 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:

*

* <ul>

* <li>The Fragment must currently be attached to the FragmentManager.

* <li>A new Fragment created using this saved state must be the same class

* type as the Fragment it was created from.

* <li>The saved state can not contain dependencies on other fragments --

* that is it can't use {@link #putFragment(Bundle, String, 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.

* </ul>

*

* @param f The Fragment whose state is to be saved.

* @return The generated state. This will be null if there was no

* interesting state created by the fragment.

*/

public abstract Fragment.SavedState saveFragmentInstanceState(Fragment f);

/**

* Returns true if the final {@link Activity#onDestroy() Activity.onDestroy()}

* call has been made on the FragmentManager's Activity, so this instance is now dead.

*/

public abstract boolean isDestroyed();

/**

* Print the FragmentManager's state into the given stream.

*

* @param prefix Text to print at the front of each line.

* @param fd The raw file descriptor that the dump is being sent to.

* @param writer A PrintWriter to which the dump is to be set.

* @param args Additional arguments to the dump request.

*/

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.

*/

public static void enableDebugLogging(boolean enabled) {

FragmentManagerImpl.DEBUG = enabled;

}

/**

* Invalidate the attached activity's options menu as necessary.

* This may end up being deferred until we move to the resumed state.

*/

public void invalidateOptionsMenu() { }

}

final class FragmentManagerState implements Parcelable {

FragmentState[] mActive;

int[] mAdded;

BackStackState[] mBackStack;

public FragmentManagerState() {

}

public FragmentManagerState(Parcel in) {

mActive = in.createTypedArray(FragmentState.CREATOR);

mAdded = in.createIntArray();

mBackStack = in.createTypedArray(BackStackState.CREATOR);

}

public int describeContents() {

return 0;

}

public void writeToParcel(Parcel dest, int flags) {

dest.writeTypedArray(mActive, flags);

dest.writeIntArray(mAdded);

dest.writeTypedArray(mBackStack, flags);

}

public static final Parcelable.Creator<FragmentManagerState> CREATOR

= new Parcelable.Creator<FragmentManagerState>() {

public FragmentManagerState createFromParcel(Parcel in) {

return new FragmentManagerState(in);

}

public FragmentManagerState[] newArray(int size) {

return new FragmentManagerState[size];

}

};

}

/**

* Container for fragments associated with an activity.

*/

final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory2 {

static boolean DEBUG = false;

static final String TAG = "FragmentManager";

static final String TARGET_REQUEST_CODE_STATE_TAG = "android:target_req_state";

static final String TARGET_STATE_TAG = "android:target_state";

static final String VIEW_STATE_TAG = "android:view_state";

static final String USER_VISIBLE_HINT_TAG = "android:user_visible_hint";

static class AnimateOnHWLayerIfNeededListener implements Animator.AnimatorListener {

private boolean mShouldRunOnHWLayer = false;

private View mView;

public AnimateOnHWLayerIfNeededListener(final View v) {

if (v == null) {

return;

}

mView = v;

}

@Override

public void onAnimationStart(Animator animation) {

mShouldRunOnHWLayer = shouldRunOnHWLayer(mView, animation);

if (mShouldRunOnHWLayer) {

mView.setLayerType(View.LAYER_TYPE_HARDWARE, null);

}

}

@Override

public void onAnimationEnd(Animator animation) {

if (mShouldRunOnHWLayer) {

mView.setLayerType(View.LAYER_TYPE_NONE, null);

}

mView = null;

animation.removeListener(this);

}

@Override

public void onAnimationCancel(Animator animation) {

}

@Override

public void onAnimationRepeat(Animator animation) {

}

}

ArrayList<Runnable> mPendingActions;

Runnable[] mTmpActions;

boolean mExecutingActions;

ArrayList<Fragment> mActive;

ArrayList<Fragment> mAdded;

ArrayList<Integer> mAvailIndices;

ArrayList<BackStackRecord> mBackStack;

ArrayList<Fragment> mCreatedMenus;

// Must be accessed while locked.

ArrayList<BackStackRecord> mBackStackIndices;

ArrayList<Integer> mAvailBackStackIndices;

ArrayList<OnBackStackChangedListener> mBackStackChangeListeners;

int mCurState = Fragment.INITIALIZING;

FragmentHostCallback<?> mHost;

FragmentController mController;

FragmentContainer mContainer;

Fragment mParent;

boolean mNeedMenuInvalidate;

boolean mStateSaved;

boolean mDestroyed;

String mNoTransactionsBecause;

boolean mHavePendingDeferredStart;

// Temporary vars for state save and restore.

Bundle mStateBundle = null;

SparseArray<Parcelable> mStateArray = null;

Runnable mExecCommit = new Runnable() {

@Override

public void run() {

execPendingActions();

}

};

private void throwException(RuntimeException ex) {

Log.e(TAG, ex.getMessage());

LogWriter logw = new LogWriter(Log.ERROR, TAG);

PrintWriter pw = new FastPrintWriter(logw, false, 1024);

if (mHost != null) {

Log.e(TAG, "Activity state:");

try {

mHost.onDump(" ", null, pw, new String[] { });

} catch (Exception e) {

pw.flush();

Log.e(TAG, "Failed dumping state", e);

}

} else {

Log.e(TAG, "Fragment manager state:");

try {

dump(" ", null, pw, new String[] { });

} catch (Exception e) {

pw.flush();

Log.e(TAG, "Failed dumping state", e);

}

}

pw.flush();

throw ex;

}

static boolean modifiesAlpha(Animator anim) {

if (anim == null) {

return false;

}

if (anim instanceof ValueAnimator) {

ValueAnimator valueAnim = (ValueAnimator) anim;

PropertyValuesHolder[] values = valueAnim.getValues();

for (int i = 0; i < values.length; i++) {

if (("alpha").equals(values[i].getPropertyName())) {

return true;

}

}

} else if (anim instanceof AnimatorSet) {

List<Animator> animList = ((AnimatorSet) anim).getChildAnimations();

for (int i = 0; i < animList.size(); i++) {

if (modifiesAlpha(animList.get(i))) {

return true;

}

}

}

return false;

}

static boolean shouldRunOnHWLayer(View v, Animator anim) {

if (v == null || anim == null) {

return false;

}

return v.getLayerType() == View.LAYER_TYPE_NONE

&& v.hasOverlappingRendering()

&& modifiesAlpha(anim);

}

/**

* Sets the to be animated view on hardware layer during the animation.

*/

private void setHWLayerAnimListenerIfAlpha(final View v, Animator anim) {

if (v == null || anim == null) {

return;

}

if (shouldRunOnHWLayer(v, anim)) {

anim.addListener(new AnimateOnHWLayerIfNeededListener(v));

}

}

@Override

public FragmentTransaction beginTransaction() {

return new BackStackRecord(this);

}

@Override

public boolean executePendingTransactions() {

return execPendingActions();

}

@Override

public void popBackStack() {

enqueueAction(new Runnable() {

@Override public void run() {

popBackStackState(mHost.getHandler(), null, -1, 0);

}

}, false);

}

@Override

public boolean popBackStackImmediate() {

checkStateLoss();

executePendingTransactions();

return popBackStackState(mHost.getHandler(), null, -1, 0);

}

@Override

public void popBackStack(final String name, final int flags) {

enqueueAction(new Runnable() {

@Override public void run() {

popBackStackState(mHost.getHandler(), name, -1, flags);

}

}, false);

}

@Override

public boolean popBackStackImmediate(String name, int flags) {

checkStateLoss();

executePendingTransactions();

return popBackStackState(mHost.getHandler(), name, -1, flags);

}

@Override

public void popBackStack(final int id, final int flags) {

if (id < 0) {

throw new IllegalArgumentException("Bad id: " + id);

}

enqueueAction(new Runnable() {

@Override public void run() {

popBackStackState(mHost.getHandler(), null, id, flags);

}

}, false);

}

@Override

public boolean popBackStackImmediate(int id, int flags) {

checkStateLoss();

executePendingTransactions();

if (id < 0) {

throw new IllegalArgumentException("Bad id: " + id);

}

return popBackStackState(mHost.getHandler(), null, id, flags);

}

@Override

public int getBackStackEntryCount() {

return mBackStack != null ? mBackStack.size() : 0;

}

@Override

public BackStackEntry getBackStackEntryAt(int index) {

return mBackStack.get(index);

}

@Override

public void addOnBackStackChangedListener(OnBackStackChangedListener listener) {

if (mBackStackChangeListeners == null) {

mBackStackChangeListeners = new ArrayList<OnBackStackChangedListener>();

}

mBackStackChangeListeners.add(listener);

}

@Override

public void removeOnBackStackChangedListener(OnBackStackChangedListener listener) {

if (mBackStackChangeListeners != null) {

mBackStackChangeListeners.remove(listener);

}

}

@Override

public void putFragment(Bundle bundle, String key, Fragment fragment) {

if (fragment.mIndex < 0) {

throwException(new IllegalStateException("Fragment " + fragment

+ " is not currently in the FragmentManager"));

}

bundle.putInt(key, fragment.mIndex);

}

@Override

public Fragment getFragment(Bundle bundle, String key) {

int index = bundle.getInt(key, -1);

if (index == -1) {

return null;

}

if (index >= mActive.size()) {

throwException(new IllegalStateException("Fragment no longer exists for key "

+ key + ": index " + index));

}

Fragment f = mActive.get(index);

if (f == null) {

throwException(new IllegalStateException("Fragment no longer exists for key "

+ key + ": index " + index));

}

return f;

}

@Override

public Fragment.SavedState saveFragmentInstanceState(Fragment fragment) {

if (fragment.mIndex < 0) {

throwException(new IllegalStateException("Fragment " + fragment

+ " is not currently in the FragmentManager"));

}

if (fragment.mState > Fragment.INITIALIZING) {

Bundle result = saveFragmentBasicState(fragment);

return result != null ? new Fragment.SavedState(result) : null;

}

return null;

}

@Override

public boolean isDestroyed() {

return mDestroyed;

}

@Override

public String toString() {

StringBuilder sb = new StringBuilder(128);

sb.append("FragmentManager{");

sb.append(Integer.toHexString(System.identityHashCode(this)));

sb.append(" in ");

if (mParent != null) {

DebugUtils.buildShortClassTag(mParent, sb);

} else {

DebugUtils.buildShortClassTag(mHost, sb);

}

sb.append("}}");

return sb.toString();

}

@Override

public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {

String innerPrefix = prefix + " ";

int N;

if (mActive != null) {

N = mActive.size();

if (N > 0) {

writer.print(prefix); writer.print("Active Fragments in ");

writer.print(Integer.toHexString(System.identityHashCode(this)));

writer.println(":");

for (int i=0; i<N; i++) {

Fragment f = mActive.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(f);

if (f != null) {

f.dump(innerPrefix, fd, writer, args);

}

}

}

}

if (mAdded != null) {

N = mAdded.size();

if (N > 0) {

writer.print(prefix); writer.println("Added Fragments:");

for (int i=0; i<N; i++) {

Fragment f = mAdded.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(f.toString());

}

}

}

if (mCreatedMenus != null) {

N = mCreatedMenus.size();

if (N > 0) {

writer.print(prefix); writer.println("Fragments Created Menus:");

for (int i=0; i<N; i++) {

Fragment f = mCreatedMenus.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(f.toString());

}

}

}

if (mBackStack != null) {

N = mBackStack.size();

if (N > 0) {

writer.print(prefix); writer.println("Back Stack:");

for (int i=0; i<N; i++) {

BackStackRecord bs = mBackStack.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(bs.toString());

bs.dump(innerPrefix, fd, writer, args);

}

}

}

synchronized (this) {

if (mBackStackIndices != null) {

N = mBackStackIndices.size();

if (N > 0) {

writer.print(prefix); writer.println("Back Stack Indices:");

for (int i=0; i<N; i++) {

BackStackRecord bs = mBackStackIndices.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(bs);

}

}

}

if (mAvailBackStackIndices != null && mAvailBackStackIndices.size() > 0) {

writer.print(prefix); writer.print("mAvailBackStackIndices: ");

writer.println(Arrays.toString(mAvailBackStackIndices.toArray()));

}

}

if (mPendingActions != null) {

N = mPendingActions.size();

if (N > 0) {

writer.print(prefix); writer.println("Pending Actions:");

for (int i=0; i<N; i++) {

Runnable r = mPendingActions.get(i);

writer.print(prefix); writer.print(" #"); writer.print(i);

writer.print(": "); writer.println(r);

}

}

}

writer.print(prefix); writer.println("FragmentManager misc state:");

writer.print(prefix); writer.print(" mHost="); writer.println(mHost);

writer.print(prefix); writer.print(" mContainer="); writer.println(mContainer);

if (mParent != null) {

writer.print(prefix); writer.print(" mParent="); writer.println(mParent);

}

writer.print(prefix); writer.print(" mCurState="); writer.print(mCurState);

writer.print(" mStateSaved="); writer.print(mStateSaved);

writer.print(" mDestroyed="); writer.println(mDestroyed);

if (mNeedMenuInvalidate) {

writer.print(prefix); writer.print(" mNeedMenuInvalidate=");

writer.println(mNeedMenuInvalidate);

}

if (mNoTransactionsBecause != null) {

writer.print(prefix); writer.print(" mNoTransactionsBecause=");

writer.println(mNoTransactionsBecause);

}

if (mAvailIndices != null && mAvailIndices.size() > 0) {

writer.print(prefix); writer.print(" mAvailIndices: ");

writer.println(Arrays.toString(mAvailIndices.toArray()));

}

}

Animator loadAnimator(Fragment fragment, int transit, boolean enter,

int transitionStyle) {

Animator animObj = fragment.onCreateAnimator(transit, enter,

fragment.mNextAnim);

if (animObj != null) {

return animObj;

}

if (fragment.mNextAnim != 0) {

Animator anim = AnimatorInflater.loadAnimator(mHost.getContext(), fragment.mNextAnim);

if (anim != null) {

return anim;

}

}

if (transit == 0) {

return null;

}

int styleIndex = transitToStyleIndex(transit, enter);

if (styleIndex < 0) {

return null;

}

if (transitionStyle == 0 && mHost.onHasWindowAnimations()) {

transitionStyle = mHost.onGetWindowAnimations();

}

if (transitionStyle == 0) {

return null;

}

TypedArray attrs = mHost.getContext().obtainStyledAttributes(transitionStyle,

com.android.internal.R.styleable.FragmentAnimation);

int anim = attrs.getResourceId(styleIndex, 0);

attrs.recycle();

if (anim == 0) {

return null;

}

return AnimatorInflater.loadAnimator(mHost.getContext(), anim);

}

public void performPendingDeferredStart(Fragment f) {

if (f.mDeferStart) {

if (mExecutingActions) {

// Wait until we're done executing our pending transactions

mHavePendingDeferredStart = true;

return;

}

f.mDeferStart = false;

moveToState(f, mCurState, 0, 0, false);

}

}

void moveToState(Fragment f, int newState, int transit, int transitionStyle,

boolean keepActive) {

if (DEBUG && false) Log.v(TAG, "moveToState: " + f

+ " oldState=" + f.mState + " newState=" + newState

+ " mRemoving=" + f.mRemoving + " Callers=" + Debug.getCallers(5));

// Fragments that are not currently added will sit in the onCreate() state.

if ((!f.mAdded || f.mDetached) && newState > Fragment.CREATED) {

newState = Fragment.CREATED;

}

if (f.mRemoving && newState > f.mState) {

// While removing a fragment, we can't change it to a higher state.

newState = f.mState;

}

// Defer start if requested; don't allow it to move to STARTED or higher

// if it's not already started.

if (f.mDeferStart && f.mState < Fragment.STARTED && newState > Fragment.STOPPED) {

newState = Fragment.STOPPED;

}

if (f.mState < newState) {

// For fragments that are created from a layout, when restoring from

// state we don't want to allow them to be created until they are

// being reloaded from the layout.

if (f.mFromLayout && !f.mInLayout) {

return;

}

if (f.mAnimatingAway != null) {

// The fragment is currently being animated... but! Now we

// want to move our state back up. Give up on waiting for the

// animation, move to whatever the final state should be once

// the animation is done, and then we can proceed from there.

f.mAnimatingAway = null;

moveToState(f, f.mStateAfterAnimating, 0, 0, true);

}

switch (f.mState) {

case Fragment.INITIALIZING:

if (DEBUG) Log.v(TAG, "moveto CREATED: " + f);

if (f.mSavedFragmentState != null) {

f.mSavedViewState = f.mSavedFragmentState.getSparseParcelableArray(

FragmentManagerImpl.VIEW_STATE_TAG);

f.mTarget = getFragment(f.mSavedFragmentState,

FragmentManagerImpl.TARGET_STATE_TAG);

if (f.mTarget != null) {

f.mTargetRequestCode = f.mSavedFragmentState.getInt(

FragmentManagerImpl.TARGET_REQUEST_CODE_STATE_TAG, 0);

}

f.mUserVisibleHint = f.mSavedFragmentState.getBoolean(

FragmentManagerImpl.USER_VISIBLE_HINT_TAG, true);

if (!f.mUserVisibleHint) {

f.mDeferStart = true;

if (newState > Fragment.STOPPED) {

newState = Fragment.STOPPED;

}

}

}

f.mHost = mHost;

f.mParentFragment = mParent;

f.mFragmentManager = mParent != null

? mParent.mChildFragmentManager : mHost.getFragmentManagerImpl();

f.mCalled = false;

f.onAttach(mHost.getContext());

if (!f.mCalled) {

throw new SuperNotCalledException("Fragment " + f

+ " did not call through to super.onAttach()");

}

if (f.mParentFragment == null) {

mHost.onAttachFragment(f);

}

if (!f.mRetaining) {

f.performCreate(f.mSavedFragmentState);

}

f.mRetaining = false;

if (f.mFromLayout) {

// For fragments that are part of the content view

// layout, we need to instantiate the view immediately

// and the inflater will take care of adding it.

f.mView = f.performCreateView(f.getLayoutInflater(

f.mSavedFragmentState), null, f.mSavedFragmentState);

if (f.mView != null) {

f.mView.setSaveFromParentEnabled(false);

if (f.mHidden) f.mView.setVisibility(View.GONE);

f.onViewCreated(f.mView, f.mSavedFragmentState);

}

}

case Fragment.CREATED:

if (newState > Fragment.CREATED) {

if (DEBUG) Log.v(TAG, "moveto ACTIVITY_CREATED: " + f);

if (!f.mFromLayout) {

ViewGroup container = null;

if (f.mContainerId != 0) {

container = (ViewGroup)mContainer.onFindViewById(f.mContainerId);

if (container == null && !f.mRestored) {

throwException(new IllegalArgumentException(

"No view found for id 0x"

+ Integer.toHexString(f.mContainerId) + " ("

+ f.getResources().getResourceName(f.mContainerId)

+ ") for fragment " + f));

}

}

f.mContainer = container;

f.mView = f.performCreateView(f.getLayoutInflater(

f.mSavedFragmentState), container, f.mSavedFragmentState);

if (f.mView != null) {

f.mView.setSaveFromParentEnabled(false);

if (container != null) {

Animator anim = loadAnimator(f, transit, true,

transitionStyle);

if (anim != null) {

anim.setTarget(f.mView);

setHWLayerAnimListenerIfAlpha(f.mView, anim);

anim.start();

}

container.addView(f.mView);

}

if (f.mHidden) f.mView.setVisibility(View.GONE);

f.onViewCreated(f.mView, f.mSavedFragmentState);

}

}

f.performActivityCreated(f.mSavedFragmentState);

if (f.mView != null) {

f.restoreViewState(f.mSavedFragmentState);

}

f.mSavedFragmentState = null;

}

case Fragment.ACTIVITY_CREATED:

case Fragment.STOPPED:

if (newState > Fragment.STOPPED) {