1 /*
2  * Copyright (C) 2014 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 package android.app;
17 
18 import android.os.Bundle;
19 import android.os.ResultReceiver;
20 import android.transition.Transition;
21 import android.util.SparseArray;
22 import android.view.View;
23 import android.view.ViewGroup;
24 import android.view.ViewTreeObserver;
25 import android.view.Window;
26 
27 import java.lang.ref.WeakReference;
28 import java.util.ArrayList;
29 
30 /**
31  * This class contains all persistence-related functionality for Activity Transitions.
32  * Activities start exit and enter Activity Transitions through this class.
33  */
34 class ActivityTransitionState {
35 
36     private static final String ENTERING_SHARED_ELEMENTS = "android:enteringSharedElements";
37 
38     private static final String EXITING_MAPPED_FROM = "android:exitingMappedFrom";
39 
40     private static final String EXITING_MAPPED_TO = "android:exitingMappedTo";
41 
42     /**
43      * The shared elements that the calling Activity has said that they transferred to this
44      * Activity.
45      */
46     private ArrayList<String> mEnteringNames;
47 
48     /**
49      * The names of shared elements that were shared to the called Activity.
50      */
51     private ArrayList<String> mExitingFrom;
52 
53     /**
54      * The names of local Views that were shared out, mapped to those elements in mExitingFrom.
55      */
56     private ArrayList<String> mExitingTo;
57 
58     /**
59      * The local Views that were shared out, mapped to those elements in mExitingFrom.
60      */
61     private ArrayList<View> mExitingToView;
62 
63     /**
64      * The ExitTransitionCoordinator used to start an Activity. Used to make the elements restore
65      * Visibility of exited Views.
66      */
67     private ExitTransitionCoordinator mCalledExitCoordinator;
68 
69     /**
70      * The ExitTransitionCoordinator used to return to a previous Activity when called with
71      * {@link android.app.Activity#finishAfterTransition()}.
72      */
73     private ExitTransitionCoordinator mReturnExitCoordinator;
74 
75     /**
76      * We must be able to cancel entering transitions to stop changing the Window to
77      * opaque when we exit before making the Window opaque.
78      */
79     private EnterTransitionCoordinator mEnterTransitionCoordinator;
80 
81     /**
82      * ActivityOptions used on entering this Activity.
83      */
84     private ActivityOptions mEnterActivityOptions;
85 
86     /**
87      * Has an exit transition been started? If so, we don't want to double-exit.
88      */
89     private boolean mHasExited;
90 
91     /**
92      * Postpone painting and starting the enter transition until this is false.
93      */
94     private boolean mIsEnterPostponed;
95 
96     /**
97      * Potential exit transition coordinators.
98      */
99     private SparseArray<WeakReference<ExitTransitionCoordinator>> mExitTransitionCoordinators;
100 
101     /**
102      * Next key for mExitTransitionCoordinator.
103      */
104     private int mExitTransitionCoordinatorsKey = 1;
105 
106     private boolean mIsEnterTriggered;
107 
ActivityTransitionState()108     public ActivityTransitionState() {
109     }
110 
addExitTransitionCoordinator(ExitTransitionCoordinator exitTransitionCoordinator)111     public int addExitTransitionCoordinator(ExitTransitionCoordinator exitTransitionCoordinator) {
112         if (mExitTransitionCoordinators == null) {
113             mExitTransitionCoordinators =
114                     new SparseArray<WeakReference<ExitTransitionCoordinator>>();
115         }
116         WeakReference<ExitTransitionCoordinator> ref = new WeakReference(exitTransitionCoordinator);
117         // clean up old references:
118         for (int i = mExitTransitionCoordinators.size() - 1; i >= 0; i--) {
119             WeakReference<ExitTransitionCoordinator> oldRef
120                     = mExitTransitionCoordinators.valueAt(i);
121             if (oldRef.get() == null) {
122                 mExitTransitionCoordinators.removeAt(i);
123             }
124         }
125         int newKey = mExitTransitionCoordinatorsKey++;
126         mExitTransitionCoordinators.append(newKey, ref);
127         return newKey;
128     }
129 
readState(Bundle bundle)130     public void readState(Bundle bundle) {
131         if (bundle != null) {
132             if (mEnterTransitionCoordinator == null || mEnterTransitionCoordinator.isReturning()) {
133                 mEnteringNames = bundle.getStringArrayList(ENTERING_SHARED_ELEMENTS);
134             }
135             if (mEnterTransitionCoordinator == null) {
136                 mExitingFrom = bundle.getStringArrayList(EXITING_MAPPED_FROM);
137                 mExitingTo = bundle.getStringArrayList(EXITING_MAPPED_TO);
138             }
139         }
140     }
141 
saveState(Bundle bundle)142     public void saveState(Bundle bundle) {
143         if (mEnteringNames != null) {
144             bundle.putStringArrayList(ENTERING_SHARED_ELEMENTS, mEnteringNames);
145         }
146         if (mExitingFrom != null) {
147             bundle.putStringArrayList(EXITING_MAPPED_FROM, mExitingFrom);
148             bundle.putStringArrayList(EXITING_MAPPED_TO, mExitingTo);
149         }
150     }
151 
setEnterActivityOptions(Activity activity, ActivityOptions options)152     public void setEnterActivityOptions(Activity activity, ActivityOptions options) {
153         final Window window = activity.getWindow();
154         if (window == null) {
155             return;
156         }
157         // ensure Decor View has been created so that the window features are activated
158         window.getDecorView();
159         if (window.hasFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)
160                 && options != null && mEnterActivityOptions == null
161                 && mEnterTransitionCoordinator == null
162                 && options.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
163             mEnterActivityOptions = options;
164             mIsEnterTriggered = false;
165             if (mEnterActivityOptions.isReturning()) {
166                 restoreExitedViews();
167                 int result = mEnterActivityOptions.getResultCode();
168                 if (result != 0) {
169                     activity.onActivityReenter(result, mEnterActivityOptions.getResultData());
170                 }
171             }
172         }
173     }
174 
enterReady(Activity activity)175     public void enterReady(Activity activity) {
176         if (mEnterActivityOptions == null || mIsEnterTriggered) {
177             return;
178         }
179         mIsEnterTriggered = true;
180         mHasExited = false;
181         ArrayList<String> sharedElementNames = mEnterActivityOptions.getSharedElementNames();
182         ResultReceiver resultReceiver = mEnterActivityOptions.getResultReceiver();
183         if (mEnterActivityOptions.isReturning()) {
184             restoreExitedViews();
185             activity.getWindow().getDecorView().setVisibility(View.VISIBLE);
186         }
187         mEnterTransitionCoordinator = new EnterTransitionCoordinator(activity,
188                 resultReceiver, sharedElementNames, mEnterActivityOptions.isReturning());
189 
190         if (!mIsEnterPostponed) {
191             startEnter();
192         }
193     }
194 
postponeEnterTransition()195     public void postponeEnterTransition() {
196         mIsEnterPostponed = true;
197     }
198 
startPostponedEnterTransition()199     public void startPostponedEnterTransition() {
200         if (mIsEnterPostponed) {
201             mIsEnterPostponed = false;
202             if (mEnterTransitionCoordinator != null) {
203                 startEnter();
204             }
205         }
206     }
207 
startEnter()208     private void startEnter() {
209         if (mEnterTransitionCoordinator.isReturning()) {
210             if (mExitingToView != null) {
211                 mEnterTransitionCoordinator.viewInstancesReady(mExitingFrom, mExitingTo,
212                         mExitingToView);
213             } else {
214                 mEnterTransitionCoordinator.namedViewsReady(mExitingFrom, mExitingTo);
215             }
216         } else {
217             mEnterTransitionCoordinator.namedViewsReady(null, null);
218             mEnteringNames = mEnterTransitionCoordinator.getAllSharedElementNames();
219         }
220 
221         mExitingFrom = null;
222         mExitingTo = null;
223         mExitingToView = null;
224         mEnterActivityOptions = null;
225     }
226 
onStop()227     public void onStop() {
228         restoreExitedViews();
229         if (mEnterTransitionCoordinator != null) {
230             mEnterTransitionCoordinator.stop();
231             mEnterTransitionCoordinator = null;
232         }
233         if (mReturnExitCoordinator != null) {
234             mReturnExitCoordinator.stop();
235             mReturnExitCoordinator = null;
236         }
237     }
238 
onResume(Activity activity, boolean isTopOfTask)239     public void onResume(Activity activity, boolean isTopOfTask) {
240         // After orientation change, the onResume can come in before the top Activity has
241         // left, so if the Activity is not top, wait a second for the top Activity to exit.
242         if (isTopOfTask || mEnterTransitionCoordinator == null) {
243             restoreExitedViews();
244             restoreReenteringViews();
245         } else {
246             activity.mHandler.postDelayed(new Runnable() {
247                 @Override
248                 public void run() {
249                     if (mEnterTransitionCoordinator == null ||
250                             mEnterTransitionCoordinator.isWaitingForRemoteExit()) {
251                         restoreExitedViews();
252                         restoreReenteringViews();
253                     }
254                 }
255             }, 1000);
256         }
257     }
258 
clear()259     public void clear() {
260         mEnteringNames = null;
261         mExitingFrom = null;
262         mExitingTo = null;
263         mExitingToView = null;
264         mCalledExitCoordinator = null;
265         mEnterTransitionCoordinator = null;
266         mEnterActivityOptions = null;
267         mExitTransitionCoordinators = null;
268     }
269 
restoreExitedViews()270     private void restoreExitedViews() {
271         if (mCalledExitCoordinator != null) {
272             mCalledExitCoordinator.resetViews();
273             mCalledExitCoordinator = null;
274         }
275     }
276 
restoreReenteringViews()277     private void restoreReenteringViews() {
278         if (mEnterTransitionCoordinator != null && mEnterTransitionCoordinator.isReturning()) {
279             mEnterTransitionCoordinator.forceViewsToAppear();
280             mExitingFrom = null;
281             mExitingTo = null;
282             mExitingToView = null;
283         }
284     }
285 
startExitBackTransition(final Activity activity)286     public boolean startExitBackTransition(final Activity activity) {
287         if (mEnteringNames == null || mCalledExitCoordinator != null) {
288             return false;
289         } else {
290             if (!mHasExited) {
291                 mHasExited = true;
292                 Transition enterViewsTransition = null;
293                 ViewGroup decor = null;
294                 boolean delayExitBack = false;
295                 if (mEnterTransitionCoordinator != null) {
296                     enterViewsTransition = mEnterTransitionCoordinator.getEnterViewsTransition();
297                     decor = mEnterTransitionCoordinator.getDecor();
298                     delayExitBack = mEnterTransitionCoordinator.cancelEnter();
299                     mEnterTransitionCoordinator = null;
300                     if (enterViewsTransition != null && decor != null) {
301                         enterViewsTransition.pause(decor);
302                     }
303                 }
304 
305                 mReturnExitCoordinator =
306                         new ExitTransitionCoordinator(activity, mEnteringNames, null, null, true);
307                 if (enterViewsTransition != null && decor != null) {
308                     enterViewsTransition.resume(decor);
309                 }
310                 if (delayExitBack && decor != null) {
311                     final ViewGroup finalDecor = decor;
312                     decor.getViewTreeObserver().addOnPreDrawListener(
313                             new ViewTreeObserver.OnPreDrawListener() {
314                                 @Override
315                                 public boolean onPreDraw() {
316                                     finalDecor.getViewTreeObserver().removeOnPreDrawListener(this);
317                                     if (mReturnExitCoordinator != null) {
318                                         mReturnExitCoordinator.startExit(activity.mResultCode,
319                                                 activity.mResultData);
320                                     }
321                                     return true;
322                                 }
323                             });
324                 } else {
325                     mReturnExitCoordinator.startExit(activity.mResultCode, activity.mResultData);
326                 }
327             }
328             return true;
329         }
330     }
331 
startExitOutTransition(Activity activity, Bundle options)332     public void startExitOutTransition(Activity activity, Bundle options) {
333         if (!activity.getWindow().hasFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)) {
334             return;
335         }
336         ActivityOptions activityOptions = new ActivityOptions(options);
337         mEnterTransitionCoordinator = null;
338         if (activityOptions.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
339             int key = activityOptions.getExitCoordinatorKey();
340             int index = mExitTransitionCoordinators.indexOfKey(key);
341             if (index >= 0) {
342                 mCalledExitCoordinator = mExitTransitionCoordinators.valueAt(index).get();
343                 mExitTransitionCoordinators.removeAt(index);
344                 if (mCalledExitCoordinator != null) {
345                     mExitingFrom = mCalledExitCoordinator.getAcceptedNames();
346                     mExitingTo = mCalledExitCoordinator.getMappedNames();
347                     mExitingToView = mCalledExitCoordinator.copyMappedViews();
348                     mCalledExitCoordinator.startExit();
349                 }
350             }
351         }
352     }
353 }
354