core/java/android/view/RemoteAnimationAdapter.java

   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 }