Home | History | Annotate | Download | only in view 
      1 /*
      2  * Copyright (C) 2018 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License
     15  */
     16 
     17 package android.view;
     18 
     19 import android.annotation.UnsupportedAppUsage;
     20 import android.app.ActivityOptions;
     21 import android.os.Parcel;
     22 import android.os.Parcelable;
     23 
     24 /**
     25  * Object that describes how to run a remote animation.
     26  * <p>
     27  * A remote animation lets another app control the entire app transition. It does so by
     28  * <ul>
     29  *     <li>using {@link ActivityOptions#makeRemoteAnimation}</li>
     30  *     <li>using {@link IWindowManager#overridePendingAppTransitionRemote}</li>
     31  * </ul>
     32  * to register a {@link RemoteAnimationAdapter} that describes how the animation should be run:
     33  * Along some meta-data, this object contains a callback that gets invoked from window manager when
     34  * the transition is ready to be started.
     35  * <p>
     36  * Window manager supplies a list of {@link RemoteAnimationTarget}s into the callback. Each target
     37  * contains information about the activity that is animating as well as
     38  * {@link RemoteAnimationTarget#leash}. The controlling app can modify the leash like any other
     39  * {@link SurfaceControl}, including the possibility to synchronize updating the leash's surface
     40  * properties with a frame to be drawn using
     41  * {@link SurfaceControl.Transaction#deferTransactionUntil}.
     42  * <p>
     43  * When the animation is done, the controlling app can invoke
     44  * {@link IRemoteAnimationFinishedCallback} that gets supplied into
     45  * {@link IRemoteAnimationRunner#onStartAnimation}
     46  *
     47  * @hide
     48  */
     49 public class RemoteAnimationAdapter implements Parcelable {
     50 
     51     private final IRemoteAnimationRunner mRunner;
     52     private final long mDuration;
     53     private final long mStatusBarTransitionDelay;
     54     private final boolean mChangeNeedsSnapshot;
     55 
     56     /** @see #getCallingPid */
     57     private int mCallingPid;
     58 
     59     /**
     60      * @param runner The interface that gets notified when we actually need to start the animation.
     61      * @param duration The duration of the animation.
     62      * @param changeNeedsSnapshot For change transitions, whether this should create a snapshot by
     63      *                            screenshotting the task.
     64      * @param statusBarTransitionDelay The desired delay for all visual animations in the
     65      *        status bar caused by this app animation in millis.
     66      */
     67     @UnsupportedAppUsage
     68     public RemoteAnimationAdapter(IRemoteAnimationRunner runner, long duration,
     69             long statusBarTransitionDelay, boolean changeNeedsSnapshot) {
     70         mRunner = runner;
     71         mDuration = duration;
     72         mChangeNeedsSnapshot = changeNeedsSnapshot;
     73         mStatusBarTransitionDelay = statusBarTransitionDelay;
     74     }
     75 
     76     @UnsupportedAppUsage
     77     public RemoteAnimationAdapter(IRemoteAnimationRunner runner, long duration,
     78             long statusBarTransitionDelay) {
     79         this(runner, duration, statusBarTransitionDelay, false /* changeNeedsSnapshot */);
     80     }
     81 
     82     public RemoteAnimationAdapter(Parcel in) {
     83         mRunner = IRemoteAnimationRunner.Stub.asInterface(in.readStrongBinder());
     84         mDuration = in.readLong();
     85         mStatusBarTransitionDelay = in.readLong();
     86         mChangeNeedsSnapshot = in.readBoolean();
     87     }
     88 
     89     public IRemoteAnimationRunner getRunner() {
     90         return mRunner;
     91     }
     92 
     93     public long getDuration() {
     94         return mDuration;
     95     }
     96 
     97     public long getStatusBarTransitionDelay() {
     98         return mStatusBarTransitionDelay;
     99     }
    100 
    101     public boolean getChangeNeedsSnapshot() {
    102         return mChangeNeedsSnapshot;
    103     }
    104 
    105     /**
    106      * To be called by system_server to keep track which pid is running this animation.
    107      */
    108     public void setCallingPid(int pid) {
    109         mCallingPid = pid;
    110     }
    111 
    112     /**
    113      * @return The pid of the process running the animation.
    114      */
    115     public int getCallingPid() {
    116         return mCallingPid;
    117     }
    118 
    119     @Override
    120     public int describeContents() {
    121         return 0;
    122     }
    123 
    124     @Override
    125     public void writeToParcel(Parcel dest, int flags) {
    126         dest.writeStrongInterface(mRunner);
    127         dest.writeLong(mDuration);
    128         dest.writeLong(mStatusBarTransitionDelay);
    129         dest.writeBoolean(mChangeNeedsSnapshot);
    130     }
    131 
    132     public static final @android.annotation.NonNull Creator<RemoteAnimationAdapter> CREATOR
    133             = new Creator<RemoteAnimationAdapter>() {
    134         public RemoteAnimationAdapter createFromParcel(Parcel in) {
    135             return new RemoteAnimationAdapter(in);
    136         }
    137 
    138         public RemoteAnimationAdapter[] newArray(int size) {
    139             return new RemoteAnimationAdapter[size];
    140         }
    141     };
    142 }
    143