From ecfd007c8fe29504de517f3243613a7f00cef4fc Mon Sep 17 00:00:00 2001 From: George Mount Date: Sun, 7 Sep 2014 10:06:25 -0700 Subject: [PATCH] Move capturing entering views until just before transition. Bug 17407387 Bug 17420256 Recycler view doesn't instantiate its views until after the onCreateView call. This delays the capturing of final views until just before the entering state is captured for the Transition. Change-Id: I425876eae44e7e0309b5c4407db1643d467cd94e --- core/java/android/app/BackStackRecord.java | 467 +++++++++------------ 1 file changed, 209 insertions(+), 258 deletions(-) diff --git a/core/java/android/app/BackStackRecord.java b/core/java/android/app/BackStackRecord.java index 8227915926d10..b09f169338b57 100644 --- a/core/java/android/app/BackStackRecord.java +++ b/core/java/android/app/BackStackRecord.java @@ -38,7 +38,6 @@ import android.view.ViewTreeObserver; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; -import java.util.Collection; final class BackStackState implements Parcelable { final int[] mOps; @@ -745,13 +744,8 @@ final class BackStackRecord extends FragmentTransaction implements SparseArray firstOutFragments = new SparseArray(); SparseArray lastInFragments = new SparseArray(); - calculateFragments(firstOutFragments, lastInFragments); - - TransitionState state = null; - if (firstOutFragments.size() != 0 || lastInFragments.size() != 0) { - state = beginTransition(firstOutFragments, lastInFragments, false); - } + beginTransition(firstOutFragments, lastInFragments, false); Op op = mHead; while (op != null) { @@ -842,10 +836,6 @@ final class BackStackRecord extends FragmentTransaction implements if (mAddToBackStack) { mManager.addBackStackState(this); } - - if (state != null) { - updateTransitionEndState(state, firstOutFragments, lastInFragments, false); - } } private static void setFirstOut(SparseArray fragments, Fragment fragment) { @@ -920,43 +910,6 @@ final class BackStackRecord extends FragmentTransaction implements op = op.next; } - - if (!haveTransitions(firstOutFragments, lastInFragments, false)) { - firstOutFragments.clear(); - lastInFragments.clear(); - } - } - - /** - * @return true if custom transitions exist on any fragment in firstOutFragments or - * lastInFragments or false otherwise. - */ - private static boolean haveTransitions(SparseArray firstOutFragments, - SparseArray lastInFragments, boolean isBack) { - for (int i = firstOutFragments.size() - 1; i >= 0; i--) { - Fragment f = firstOutFragments.valueAt(i); - if (isBack) { - if (f.getReturnTransition() != null || - f.getSharedElementReturnTransition() != null) { - return true; - } - } else if (f.getExitTransition() != null) { - return true; - } - } - - for (int i = lastInFragments.size() - 1; i >= 0; i--) { - Fragment f = lastInFragments.valueAt(i); - if (isBack) { - if (f.getReenterTransition() != null) { - return true; - } - } else if (f.getEnterTransition() != null || - f.getSharedElementEnterTransition() != null) { - return true; - } - } - return false; } /** @@ -1003,11 +956,6 @@ final class BackStackRecord extends FragmentTransaction implements op = op.next; } - - if (!haveTransitions(firstOutFragments, lastInFragments, true)) { - firstOutFragments.clear(); - lastInFragments.clear(); - } } /** @@ -1038,8 +986,8 @@ final class BackStackRecord extends FragmentTransaction implements * @param isBack true if this is popping the back stack or false if this is a * forward operation. * @return The TransitionState used to complete the operation of the transition - * in {@link #updateTransitionEndState(android.app.BackStackRecord.TransitionState, - * android.util.SparseArray, android.util.SparseArray, boolean)}. + * in {@link #setNameOverrides(android.app.BackStackRecord.TransitionState, java.util.ArrayList, + * java.util.ArrayList)}. */ private TransitionState beginTransition(SparseArray firstOutFragments, SparseArray lastInFragments, boolean isBack) { @@ -1050,16 +998,11 @@ final class BackStackRecord extends FragmentTransaction implements // add any, then no views will be targeted. state.nonExistentView = new View(mManager.mActivity); - ArrayMap tempViews1 = new ArrayMap(); - ArrayMap tempViews2 = new ArrayMap(); - ArrayList tempNames = new ArrayList(); - ArrayList tempViewList = new ArrayList(); - // Go over all leaving fragments. for (int i = 0; i < firstOutFragments.size(); i++) { int containerId = firstOutFragments.keyAt(i); configureTransitions(containerId, state, isBack, firstOutFragments, - lastInFragments, tempViews1, tempViews2, tempNames, tempViewList); + lastInFragments); } // Now go over all entering fragments that didn't have a leaving fragment. @@ -1067,28 +1010,33 @@ final class BackStackRecord extends FragmentTransaction implements int containerId = lastInFragments.keyAt(i); if (firstOutFragments.get(containerId) == null) { configureTransitions(containerId, state, isBack, firstOutFragments, - lastInFragments, tempViews1, tempViews2, tempNames, tempViewList); + lastInFragments); } } - - if (state.overallTransitions.size() == 0) { - state = null; - } return state; } + private static Transition cloneTransition(Transition transition) { + if (transition != null) { + transition = transition.clone(); + } + return transition; + } + private static Transition getEnterTransition(Fragment inFragment, boolean isBack) { if (inFragment == null) { return null; } - return isBack ? inFragment.getReenterTransition() : inFragment.getEnterTransition(); + return cloneTransition(isBack ? inFragment.getReenterTransition() : + inFragment.getEnterTransition()); } private static Transition getExitTransition(Fragment outFragment, boolean isBack) { if (outFragment == null) { return null; } - return isBack ? outFragment.getReturnTransition() : outFragment.getExitTransition(); + return cloneTransition(isBack ? outFragment.getReturnTransition() : + outFragment.getExitTransition()); } private static Transition getSharedElementTransition(Fragment inFragment, Fragment outFragment, @@ -1096,34 +1044,32 @@ final class BackStackRecord extends FragmentTransaction implements if (inFragment == null || outFragment == null) { return null; } - return isBack ? outFragment.getSharedElementReturnTransition() : - inFragment.getSharedElementEnterTransition(); + return cloneTransition(isBack ? outFragment.getSharedElementReturnTransition() : + inFragment.getSharedElementEnterTransition()); } - private static Transition captureExitingViews(Transition exitTransition, Fragment outFragment, - ArrayList viewList) { + private static ArrayList captureExitingViews(Transition exitTransition, + Fragment outFragment) { + ArrayList viewList = null; if (exitTransition != null) { + viewList = new ArrayList(); View root = outFragment.getView(); - viewList.clear(); root.captureTransitioningViews(viewList); - if (viewList.isEmpty()) { - exitTransition = null; - } else { - addTransitioningViews(exitTransition, viewList); - } + addTargets(exitTransition, viewList); } - return exitTransition; + return viewList; } private ArrayMap remapSharedElements(TransitionState state, Fragment outFragment, - ArrayMap namedViews, ArrayMap tempViews2, boolean isBack) { + boolean isBack) { + ArrayMap namedViews = new ArrayMap(); if (mSharedElementSourceNames != null) { outFragment.getView().findNamedViews(namedViews); if (isBack) { namedViews.retainAll(mSharedElementTargetNames); } else { namedViews = remapNames(mSharedElementSourceNames, mSharedElementTargetNames, - namedViews, tempViews2); + namedViews); } } @@ -1147,41 +1093,94 @@ final class BackStackRecord extends FragmentTransaction implements * We will add to the views before the end state of the transition is captured so that the * views will appear. At the start of the transition, we clear the list of targets so that * we can restore the state of the transition and use it again. + * + *

The shared element transition maps its shared elements immediately prior to + * capturing the final state of the Transition.

*/ - private void prepareEnterTransition(TransitionState state, final Transition enterTransition, - final View container, final Fragment inFragment) { - if (enterTransition != null) { - final ArrayList enteringViews = new ArrayList(); - final View nonExistentView = state.nonExistentView; - enterTransition.addTarget(state.nonExistentView); - enterTransition.addListener(new Transition.TransitionListenerAdapter() { - @Override - public void onTransitionStart(Transition transition) { - transition.removeListener(this); - transition.removeTarget(nonExistentView); - int numViews = enteringViews.size(); - for (int i = 0; i < numViews; i++) { - transition.removeTarget(enteringViews.get(i)); - } - } - }); - container.getViewTreeObserver().addOnPreDrawListener( - new ViewTreeObserver.OnPreDrawListener() { - @Override - public boolean onPreDraw() { - container.getViewTreeObserver().removeOnPreDrawListener(this); + private ArrayList addTransitionTargets(final TransitionState state, + final Transition enterTransition, final Transition sharedElementTransition, + final Transition overallTransition, final View container, + final Fragment inFragment, final Fragment outFragment, + final ArrayList hiddenFragmentViews, final boolean isBack) { + if (enterTransition == null && sharedElementTransition == null && + overallTransition == null) { + return null; + } + final ArrayList enteringViews = new ArrayList(); + container.getViewTreeObserver().addOnPreDrawListener( + new ViewTreeObserver.OnPreDrawListener() { + @Override + public boolean onPreDraw() { + container.getViewTreeObserver().removeOnPreDrawListener(this); + + // Don't include any newly-hidden fragments in the transition. + excludeHiddenFragments(hiddenFragmentViews, inFragment.mContainerId, + overallTransition); + + if (sharedElementTransition != null) { + ArrayMap namedViews = mapSharedElementsIn( + state, isBack, inFragment); + + setEpicenterIn(namedViews, state); + + callSharedElementEnd(state, inFragment, outFragment, isBack, + namedViews); + } + + if (enterTransition != null) { View view = inFragment.getView(); if (view != null) { view.captureTransitioningViews(enteringViews); - addTransitioningViews(enterTransition, enteringViews); + addTargets(enterTransition, enteringViews); } - return true; + setSharedElementEpicenter(enterTransition, state); } - }); - setSharedElementEpicenter(enterTransition, state); + return true; + } + }); + return enteringViews; + } + + private void callSharedElementEnd(TransitionState state, Fragment inFragment, + Fragment outFragment, boolean isBack, ArrayMap namedViews) { + SharedElementCallback sharedElementCallback = isBack ? + outFragment.mEnterTransitionCallback : + inFragment.mEnterTransitionCallback; + ArrayList names = new ArrayList(namedViews.keySet()); + ArrayList views = new ArrayList(namedViews.values()); + sharedElementCallback.onSharedElementEnd(names, views, null); + } + + private void setEpicenterIn(ArrayMap namedViews, TransitionState state) { + if (mSharedElementTargetNames != null && !namedViews.isEmpty()) { + // now we know the epicenter of the entering transition. + View epicenter = namedViews + .get(mSharedElementTargetNames.get(0)); + if (epicenter != null) { + state.enteringEpicenterView = epicenter; + } } } + private ArrayMap mapSharedElementsIn(TransitionState state, + boolean isBack, Fragment inFragment) { + // Now map the shared elements in the incoming fragment + ArrayMap namedViews = mapEnteringSharedElements(state, inFragment, isBack); + + // remap shared elements and set the name mapping used + // in the shared element transition. + if (isBack) { + inFragment.mExitTransitionCallback.onMapSharedElements( + mSharedElementTargetNames, namedViews); + setBackNameOverrides(state, namedViews, true); + } else { + inFragment.mEnterTransitionCallback.onMapSharedElements( + mSharedElementTargetNames, namedViews); + setNameOverrides(state, namedViews, true); + } + return namedViews; + } + private static Transition mergeTransitions(Transition enterTransition, Transition exitTransition, Transition sharedElementTransition, Fragment inFragment, boolean isBack) { @@ -1209,26 +1208,16 @@ final class BackStackRecord extends FragmentTransaction implements * Configures custom transitions for a specific fragment container. * * @param containerId The container ID of the fragments to configure the transition for. - * @param state The Transition State to be shared with {@link #updateTransitionEndState( - * android.app.BackStackRecord.TransitionState, android.util.SparseArray, - * android.util.SparseArray, boolean)} later. + * @param state The Transition State keeping track of the executing transitions. * @param firstOutFragments The list of first fragments to be removed, keyed on the * container ID. * @param lastInFragments The list of last fragments to be added, keyed on the * container ID. * @param isBack true if this is popping the back stack or false if this is a * forward operation. - * @param tempViews1 A temporary mapping of names to Views, used to avoid allocation - * inside a loop. - * @param tempViews2 A temporary mapping of names to Views, used to avoid allocation - * inside a loop. - * @param tempNames A temporary list of Strings, used to avoid allocation inside a loop. - * @param tempViewList A temporary list of Views, used to avoid allocation inside a loop. */ private void configureTransitions(int containerId, TransitionState state, boolean isBack, - SparseArray firstOutFragments, SparseArray lastInFragments, - ArrayMap tempViews1, ArrayMap tempViews2, - ArrayList tempNames, ArrayList tempViewList) { + SparseArray firstOutFragments, SparseArray lastInFragments) { ViewGroup sceneRoot = (ViewGroup) mManager.mContainer.findViewById(containerId); if (sceneRoot != null) { Fragment inFragment = lastInFragments.get(containerId); @@ -1238,146 +1227,150 @@ final class BackStackRecord extends FragmentTransaction implements Transition sharedElementTransition = getSharedElementTransition(inFragment, outFragment, isBack); Transition exitTransition = getExitTransition(outFragment, isBack); - exitTransition = captureExitingViews(exitTransition, outFragment, tempViewList); - ArrayMap namedViews = tempViews1; - namedViews.clear(); - if (sharedElementTransition != null) { - namedViews = remapSharedElements(state, - outFragment, namedViews, tempViews2, isBack); + if (enterTransition == null && sharedElementTransition == null && + exitTransition == null) { + return; // no transitions! + } + ArrayList exitingViews = captureExitingViews(exitTransition, outFragment); + if (exitingViews == null || exitingViews.isEmpty()) { + exitTransition = null; } - // Notify the start of the transition. - SharedElementCallback callback = isBack ? - outFragment.mEnterTransitionCallback : - inFragment.mEnterTransitionCallback; - tempNames.clear(); - tempNames.addAll(namedViews.keySet()); - tempViewList.clear(); - tempViewList.addAll(namedViews.values()); - callback.onSharedElementStart(tempNames, tempViewList, null); + ArrayMap namedViews = null; + if (sharedElementTransition != null) { + namedViews = remapSharedElements(state, outFragment, isBack); + + // Notify the start of the transition. + SharedElementCallback callback = isBack ? + outFragment.mEnterTransitionCallback : + inFragment.mEnterTransitionCallback; + ArrayList names = new ArrayList(namedViews.keySet()); + ArrayList views = new ArrayList(namedViews.values()); + callback.onSharedElementStart(names, views, null); + } // Set the epicenter of the exit transition - if (mSharedElementTargetNames != null && exitTransition != null) { + if (mSharedElementTargetNames != null && exitTransition != null && namedViews != null) { View epicenterView = namedViews.get(mSharedElementTargetNames.get(0)); if (epicenterView != null) { setEpicenter(exitTransition, epicenterView); } } - prepareEnterTransition(state, enterTransition, sceneRoot, inFragment); - Transition transition = mergeTransitions(enterTransition, exitTransition, sharedElementTransition, inFragment, isBack); if (transition != null) { - state.overallTransitions.put(containerId, transition); + ArrayList hiddenFragments = new ArrayList(); + ArrayList enteringViews = addTransitionTargets(state, enterTransition, + sharedElementTransition, transition, sceneRoot, inFragment, outFragment, + hiddenFragments, isBack); + transition.setNameOverrides(state.nameOverrides); // We want to exclude hidden views later, so we need a non-null list in the // transition now. transition.excludeTarget(state.nonExistentView, true); // Now exclude all currently hidden fragments. - excludeHiddenFragments(state, containerId, transition); - cleanupHiddenFragments(transition, state); + excludeHiddenFragments(hiddenFragments, containerId, transition); TransitionManager.beginDelayedTransition(sceneRoot, transition); + // Remove the view targeting after the transition starts + removeTargetedViewsFromTransitions(sceneRoot, state.nonExistentView, + enterTransition, enteringViews, exitTransition, exitingViews, + transition, hiddenFragments); } } } + /** + * After the transition has started, remove all targets that we added to the transitions + * so that the transitions are left in a clean state. + */ + private void removeTargetedViewsFromTransitions( + final ViewGroup sceneRoot, final View nonExistingView, + final Transition enterTransition, final ArrayList enteringViews, + final Transition exitTransition, final ArrayList exitingViews, + final Transition overallTransition, final ArrayList hiddenViews) { + if (enterTransition != null || exitTransition != null) { + sceneRoot.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() { + @Override + public boolean onPreDraw() { + sceneRoot.getViewTreeObserver().removeOnPreDrawListener(this); + if (enterTransition != null) { + enterTransition.removeTarget(nonExistingView); + removeTargets(enterTransition, enteringViews); + } + if (exitTransition != null) { + removeTargets(exitTransition, exitingViews); + } + int numViews = hiddenViews.size(); + for (int i = 0; i < numViews; i++) { + overallTransition.excludeTarget(hiddenViews.get(i), false); + } + overallTransition.excludeTarget(nonExistingView, false); + return true; + } + }); + } + } + + private static void removeTargets(Transition transition, ArrayList views) { + int numViews = views.size(); + for (int i = 0; i < numViews; i++) { + transition.removeTarget(views.get(i)); + } + } + + private static void addTargets(Transition transition, ArrayList views) { + int numViews = views.size(); + for (int i = 0; i < numViews; i++) { + transition.addTarget(views.get(i)); + } + } + /** * Remaps a name-to-View map, substituting different names for keys. * * @param inMap A list of keys found in the map, in the order in toGoInMap * @param toGoInMap A list of keys to use for the new map, in the order of inMap * @param namedViews The current mapping - * @param tempMap A temporary mapping that will be filled with the new values. - * @return tempMap after it has been mapped with the new names as keys. + * @return a new Map after it has been mapped with the new names as keys. */ private static ArrayMap remapNames(ArrayList inMap, - ArrayList toGoInMap, ArrayMap namedViews, - ArrayMap tempMap) { - tempMap.clear(); + ArrayList toGoInMap, ArrayMap namedViews) { + ArrayMap remappedViews = new ArrayMap(); if (!namedViews.isEmpty()) { int numKeys = inMap.size(); for (int i = 0; i < numKeys; i++) { View view = namedViews.get(inMap.get(i)); + if (view != null) { - tempMap.put(toGoInMap.get(i), view); + remappedViews.put(toGoInMap.get(i), view); } } } - return tempMap; + return remappedViews; } /** - * After making all fragment changes, this updates the custom transitions to take into - * account the entering views and any remapping. + * Maps shared elements to views in the entering fragment. * * @param state The transition State as returned from {@link #beginTransition( * android.util.SparseArray, android.util.SparseArray, boolean)}. - * @param outFragments The list of first fragments to be removed, keyed on the - * container ID. - * @param inFragments The list of last fragments to be added, keyed on the - * container ID. + * @param inFragment The last fragment to be added. * @param isBack true if this is popping the back stack or false if this is a * forward operation. */ - private void updateTransitionEndState(TransitionState state, SparseArray outFragments, - SparseArray inFragments, boolean isBack) { - ArrayMap tempViews1 = new ArrayMap(); - ArrayMap tempViews2 = new ArrayMap(); - ArrayList tempNames = new ArrayList(); - ArrayList tempViews = new ArrayList(); - - int numInFragments = inFragments.size(); - for (int i = 0; i < numInFragments; i++) { - Fragment inFragment = inFragments.valueAt(i); - tempViews1.clear(); - ArrayMap namedViews = mapEnteringSharedElements(inFragment, tempViews1, - tempViews2, isBack); - // remap shared elements and set the name mapping used in the shared element transition. - if (isBack) { - inFragment.mExitTransitionCallback.onMapSharedElements( - mSharedElementTargetNames, namedViews); - setBackNameOverrides(state, namedViews, true); - } else { - inFragment.mEnterTransitionCallback.onMapSharedElements( - mSharedElementTargetNames, namedViews); - setNameOverrides(state, namedViews, true); - } - - if (mSharedElementTargetNames != null && !namedViews.isEmpty()) { - // now we know the epicenter of the entering transition. - View epicenter = namedViews.get(mSharedElementTargetNames.get(0)); - if (epicenter != null) { - state.enteringEpicenterView = epicenter; - } - } - - int containerId = inFragments.keyAt(i); - SharedElementCallback sharedElementCallback = isBack ? - outFragments.get(containerId).mEnterTransitionCallback : - inFragment.mEnterTransitionCallback; - tempNames.clear(); - tempNames.addAll(namedViews.keySet()); - tempViews.clear(); - tempViews.addAll(namedViews.values()); - sharedElementCallback.onSharedElementEnd(tempNames, tempViews, null); - } - - // Don't include any newly-hidden fragments in the transition. - excludeHiddenFragments(state); - } - - private ArrayMap mapEnteringSharedElements(Fragment inFragment, - ArrayMap namedViews, ArrayMap tempViews2, boolean isBack) { + private ArrayMap mapEnteringSharedElements(TransitionState state, + Fragment inFragment, boolean isBack) { + ArrayMap namedViews = new ArrayMap(); View root = inFragment.getView(); if (root != null) { if (mSharedElementSourceNames != null) { root.findNamedViews(namedViews); if (isBack) { namedViews = remapNames(mSharedElementSourceNames, - mSharedElementTargetNames, namedViews, tempViews2); + mSharedElementTargetNames, namedViews); } else { namedViews.retainAll(mSharedElementTargetNames); } @@ -1386,21 +1379,7 @@ final class BackStackRecord extends FragmentTransaction implements return namedViews; } - private static void cleanupHiddenFragments(Transition transition, TransitionState state) { - final ArrayList hiddenViews = state.hiddenFragmentViews; - transition.addListener(new Transition.TransitionListenerAdapter() { - @Override - public void onTransitionStart(Transition transition) { - transition.removeListener(this); - int numViews = hiddenViews.size(); - for (int i = 0; i < numViews; i++) { - transition.excludeTarget(hiddenViews.get(i), false); - } - } - }); - } - - private void excludeHiddenFragments(TransitionState state, int containerId, + private void excludeHiddenFragments(final ArrayList hiddenFragmentViews, int containerId, Transition transition) { if (mManager.mAdded != null) { for (int i = 0; i < mManager.mAdded.size(); i++) { @@ -1408,44 +1387,19 @@ final class BackStackRecord extends FragmentTransaction implements if (fragment.mView != null && fragment.mContainer != null && fragment.mContainerId == containerId) { if (fragment.mHidden) { - if (!state.hiddenFragmentViews.contains(fragment.mView)) { + if (!hiddenFragmentViews.contains(fragment.mView)) { transition.excludeTarget(fragment.mView, true); - state.hiddenFragmentViews.add(fragment.mView); + hiddenFragmentViews.add(fragment.mView); } } else { transition.excludeTarget(fragment.mView, false); - state.hiddenFragmentViews.remove(fragment.mView); + hiddenFragmentViews.remove(fragment.mView); } } } } } - private void excludeHiddenFragments(TransitionState state) { - int numTransitions = state.overallTransitions.size(); - for (int i = 0; i < numTransitions; i++) { - Transition transition = state.overallTransitions.valueAt(i); - int containerId = state.overallTransitions.keyAt(i); - excludeHiddenFragments(state, containerId, transition); - } - } - - private static void addTransitioningViews(Transition transition, final Collection views) { - for (View view : views) { - transition.addTarget(view); - } - - transition.addListener(new Transition.TransitionListenerAdapter() { - @Override - public void onTransitionStart(Transition transition) { - transition.removeListener(this); - for (View view : views) { - transition.removeTarget(view); - } - } - }); - } - private static void setEpicenter(Transition transition, View view) { final Rect epicenter = new Rect(); view.getBoundsOnScreen(epicenter); @@ -1566,10 +1520,7 @@ final class BackStackRecord extends FragmentTransaction implements if (doStateMove) { mManager.moveToState(mManager.mCurState, FragmentManagerImpl.reverseTransit(mTransition), mTransitionStyle, true); - if (state != null) { - updateTransitionEndState(state, firstOutFragments, lastInFragments, true); - state = null; - } + state = null; } if (mIndex >= 0) { @@ -1609,11 +1560,14 @@ final class BackStackRecord extends FragmentTransaction implements for (int i = 0; i < count; i++) { String source = mSharedElementSourceNames.get(i); String originalTarget = mSharedElementTargetNames.get(i); - String target = namedViews.get(originalTarget).getTransitionName(); - if (isEnd) { - setNameOverride(state.nameOverrides, source, target); - } else { - setNameOverride(state.nameOverrides, target, source); + View view = namedViews.get(originalTarget); + if (view != null) { + String target = view.getTransitionName(); + if (isEnd) { + setNameOverride(state.nameOverrides, source, target); + } else { + setNameOverride(state.nameOverrides, target, source); + } } } } @@ -1649,10 +1603,7 @@ final class BackStackRecord extends FragmentTransaction implements } public class TransitionState { - public SparseArray overallTransitions = new SparseArray(); public ArrayMap nameOverrides = new ArrayMap(); - public ArrayList hiddenFragmentViews = new ArrayList(); - public View enteringEpicenterView; public View nonExistentView; }