Example usage for android.app Fragment onDetach

List of usage examples for android.app Fragment onDetach

Introduction

In this page you can find the example usage for android.app Fragment onDetach.

Prototype

@CallSuper
public void onDetach() 

Source Link

Document

Called when the fragment is no longer attached to its activity.

Usage

From source file:android.app.FragmentManager.java

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;//from  ww  w. java 2s.c o  m
    }
    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.mActivity = mActivity;
            f.mParentFragment = mParent;
            f.mFragmentManager = mParent != null ? mParent.mChildFragmentManager : mActivity.mFragments;
            f.mCalled = false;
            f.onAttach(mActivity);
            if (!f.mCalled) {
                throw new SuperNotCalledException(
                        "Fragment " + f + " did not call through to super.onAttach()");
            }
            if (f.mParentFragment == null) {
                mActivity.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.findViewById(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);
                                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) {
                if (DEBUG)
                    Log.v(TAG, "moveto STARTED: " + f);
                f.performStart();
            }
        case Fragment.STARTED:
            if (newState > Fragment.STARTED) {
                if (DEBUG)
                    Log.v(TAG, "moveto RESUMED: " + f);
                f.mResumed = true;
                f.performResume();
                // Get rid of this in case we saved it and never needed it.
                f.mSavedFragmentState = null;
                f.mSavedViewState = null;
            }
        }
    } else if (f.mState > newState) {
        switch (f.mState) {
        case Fragment.RESUMED:
            if (newState < Fragment.RESUMED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom RESUMED: " + f);
                f.performPause();
                f.mResumed = false;
            }
        case Fragment.STARTED:
            if (newState < Fragment.STARTED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom STARTED: " + f);
                f.performStop();
            }
        case Fragment.STOPPED:
        case Fragment.ACTIVITY_CREATED:
            if (newState < Fragment.ACTIVITY_CREATED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom ACTIVITY_CREATED: " + f);
                if (f.mView != null) {
                    // Need to save the current view state if not
                    // done already.
                    if (!mActivity.isFinishing() && f.mSavedViewState == null) {
                        saveFragmentViewState(f);
                    }
                }
                f.performDestroyView();
                if (f.mView != null && f.mContainer != null) {
                    Animator anim = null;
                    if (mCurState > Fragment.INITIALIZING && !mDestroyed) {
                        anim = loadAnimator(f, transit, false, transitionStyle);
                    }
                    if (anim != null) {
                        final ViewGroup container = f.mContainer;
                        final View view = f.mView;
                        final Fragment fragment = f;
                        container.startViewTransition(view);
                        f.mAnimatingAway = anim;
                        f.mStateAfterAnimating = newState;
                        anim.addListener(new AnimatorListenerAdapter() {
                            @Override
                            public void onAnimationEnd(Animator anim) {
                                container.endViewTransition(view);
                                if (fragment.mAnimatingAway != null) {
                                    fragment.mAnimatingAway = null;
                                    moveToState(fragment, fragment.mStateAfterAnimating, 0, 0, false);
                                }
                            }
                        });
                        anim.setTarget(f.mView);
                        anim.start();

                    }
                    f.mContainer.removeView(f.mView);
                }
                f.mContainer = null;
                f.mView = null;
            }
        case Fragment.CREATED:
            if (newState < Fragment.CREATED) {
                if (mDestroyed) {
                    if (f.mAnimatingAway != null) {
                        // The fragment's containing activity is
                        // being destroyed, but this fragment is
                        // currently animating away.  Stop the
                        // animation right now -- it is not needed,
                        // and we can't wait any more on destroying
                        // the fragment.
                        Animator anim = f.mAnimatingAway;
                        f.mAnimatingAway = null;
                        anim.cancel();
                    }
                }
                if (f.mAnimatingAway != null) {
                    // We are waiting for the fragment's view to finish
                    // animating away.  Just make a note of the state
                    // the fragment now should move to once the animation
                    // is done.
                    f.mStateAfterAnimating = newState;
                    newState = Fragment.CREATED;
                } else {
                    if (DEBUG)
                        Log.v(TAG, "movefrom CREATED: " + f);
                    if (!f.mRetaining) {
                        f.performDestroy();
                    }

                    f.mCalled = false;
                    f.onDetach();
                    if (!f.mCalled) {
                        throw new SuperNotCalledException(
                                "Fragment " + f + " did not call through to super.onDetach()");
                    }
                    if (!keepActive) {
                        if (!f.mRetaining) {
                            makeInactive(f);
                        } else {
                            f.mActivity = null;
                            f.mParentFragment = null;
                            f.mFragmentManager = null;
                        }
                    }
                }
            }
        }
    }

    f.mState = newState;
}

From source file:android.app.FragmentManager.java

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;/*from  w  w  w  . j av a2  s. co  m*/
    }
    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.mActivity = mActivity;
            f.mParentFragment = mParent;
            f.mFragmentManager = mParent != null ? mParent.mChildFragmentManager : mActivity.mFragments;
            f.mCalled = false;
            f.onAttach(mActivity);
            if (!f.mCalled) {
                throw new SuperNotCalledException(
                        "Fragment " + f + " did not call through to super.onAttach()");
            }
            if (f.mParentFragment == null) {
                mActivity.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.findViewById(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);
                                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) {
                if (DEBUG)
                    Log.v(TAG, "moveto STARTED: " + f);
                f.performStart();
            }
        case Fragment.STARTED:
            if (newState > Fragment.STARTED) {
                if (DEBUG)
                    Log.v(TAG, "moveto RESUMED: " + f);
                f.mResumed = true;
                f.performResume();
                // Get rid of this in case we saved it and never needed it.
                f.mSavedFragmentState = null;
                f.mSavedViewState = null;
            }
        }
    } else if (f.mState > newState) {
        switch (f.mState) {
        case Fragment.RESUMED:
            if (newState < Fragment.RESUMED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom RESUMED: " + f);
                f.performPause();
                f.mResumed = false;
            }
        case Fragment.STARTED:
            if (newState < Fragment.STARTED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom STARTED: " + f);
                f.performStop();
            }
        case Fragment.STOPPED:
        case Fragment.ACTIVITY_CREATED:
            if (newState < Fragment.ACTIVITY_CREATED) {
                if (DEBUG)
                    Log.v(TAG, "movefrom ACTIVITY_CREATED: " + f);
                if (f.mView != null) {
                    // Need to save the current view state if not
                    // done already.
                    if (!mActivity.isFinishing() && f.mSavedViewState == null) {
                        saveFragmentViewState(f);
                    }
                }
                f.performDestroyView();
                if (f.mView != null && f.mContainer != null) {
                    Animator anim = null;
                    if (mCurState > Fragment.INITIALIZING && !mDestroyed) {
                        anim = loadAnimator(f, transit, false, transitionStyle);
                    }
                    if (anim != null) {
                        final ViewGroup container = f.mContainer;
                        final View view = f.mView;
                        final Fragment fragment = f;
                        container.startViewTransition(view);
                        f.mAnimatingAway = anim;
                        f.mStateAfterAnimating = newState;
                        anim.addListener(new AnimatorListenerAdapter() {
                            @Override
                            public void onAnimationEnd(Animator anim) {
                                container.endViewTransition(view);
                                if (fragment.mAnimatingAway != null) {
                                    fragment.mAnimatingAway = null;
                                    moveToState(fragment, fragment.mStateAfterAnimating, 0, 0, false);
                                }
                            }
                        });
                        anim.setTarget(f.mView);
                        anim.start();

                    }
                    f.mContainer.removeView(f.mView);
                }
                f.mContainer = null;
                f.mView = null;
            }
        case Fragment.CREATED:
            if (newState < Fragment.CREATED) {
                if (mDestroyed) {
                    if (f.mAnimatingAway != null) {
                        // The fragment's containing activity is
                        // being destroyed, but this fragment is
                        // currently animating away.  Stop the
                        // animation right now -- it is not needed,
                        // and we can't wait any more on destroying
                        // the fragment.
                        Animator anim = f.mAnimatingAway;
                        f.mAnimatingAway = null;
                        anim.cancel();
                    }
                }
                if (f.mAnimatingAway != null) {
                    // We are waiting for the fragment's view to finish
                    // animating away.  Just make a note of the state
                    // the fragment now should move to once the animation
                    // is done.
                    f.mStateAfterAnimating = newState;
                    newState = Fragment.CREATED;
                } else {
                    if (DEBUG)
                        Log.v(TAG, "movefrom CREATED: " + f);
                    if (!f.mRetaining) {
                        f.performDestroy();
                    }

                    f.mCalled = false;
                    f.onDetach();
                    if (!f.mCalled) {
                        throw new SuperNotCalledException(
                                "Fragment " + f + " did not call through to super.onDetach()");
                    }
                    if (!keepActive) {
                        if (!f.mRetaining) {
                            makeInactive(f);
                        } else {
                            f.mActivity = null;
                            f.mParentFragment = null;
                            f.mFragmentManager = null;
                            f.mChildFragmentManager = null;
                        }
                    }
                }
            }
        }
    }

    f.mState = newState;
}