849 lines
31 KiB
Java
849 lines
31 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2020 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
package android.window;
|
||
|
|
|
||
|
|
import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;
|
||
|
|
|
||
|
|
import static com.android.internal.jank.InteractionJankMonitor.CUJ_SPLASHSCREEN_AVD;
|
||
|
|
|
||
|
|
import android.animation.Animator;
|
||
|
|
import android.animation.AnimatorListenerAdapter;
|
||
|
|
import android.annotation.ColorInt;
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.TestApi;
|
||
|
|
import android.annotation.UiThread;
|
||
|
|
import android.content.Context;
|
||
|
|
import android.graphics.Bitmap;
|
||
|
|
import android.graphics.Canvas;
|
||
|
|
import android.graphics.PixelFormat;
|
||
|
|
import android.graphics.Rect;
|
||
|
|
import android.graphics.drawable.BitmapDrawable;
|
||
|
|
import android.graphics.drawable.Drawable;
|
||
|
|
import android.os.Build;
|
||
|
|
import android.os.Parcel;
|
||
|
|
import android.os.Parcelable;
|
||
|
|
import android.os.RemoteCallback;
|
||
|
|
import android.os.Trace;
|
||
|
|
import android.util.AttributeSet;
|
||
|
|
import android.util.Log;
|
||
|
|
import android.view.AttachedSurfaceControl;
|
||
|
|
import android.view.Gravity;
|
||
|
|
import android.view.LayoutInflater;
|
||
|
|
import android.view.SurfaceControlViewHost;
|
||
|
|
import android.view.SurfaceView;
|
||
|
|
import android.view.View;
|
||
|
|
import android.view.ViewGroup;
|
||
|
|
import android.view.Window;
|
||
|
|
import android.view.WindowManager;
|
||
|
|
import android.widget.FrameLayout;
|
||
|
|
import android.widget.ImageView;
|
||
|
|
|
||
|
|
import com.android.internal.R;
|
||
|
|
import com.android.internal.jank.InteractionJankMonitor;
|
||
|
|
import com.android.internal.policy.DecorView;
|
||
|
|
|
||
|
|
import java.io.Closeable;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.time.Duration;
|
||
|
|
import java.time.Instant;
|
||
|
|
import java.util.function.Consumer;
|
||
|
|
import java.util.function.LongConsumer;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>The view which allows an activity to customize its splash screen exit animation.</p>
|
||
|
|
*
|
||
|
|
* <p>Activities will receive this view as a parameter of
|
||
|
|
* {@link SplashScreen.OnExitAnimationListener#onSplashScreenExit} if
|
||
|
|
* they set {@link SplashScreen#setOnExitAnimationListener}.
|
||
|
|
* When this callback is called, this view will be on top of the activity.</p>
|
||
|
|
*
|
||
|
|
* <p>This view is composed of a view containing the splashscreen icon (see
|
||
|
|
* windowSplashscreenAnimatedIcon) and a background.
|
||
|
|
* Developers can use {@link #getIconView} to get this view and replace the drawable or
|
||
|
|
* add animation to it. The background of this view is filled with a single color, which can be
|
||
|
|
* edited during the animation by {@link View#setBackground} or {@link View#setBackgroundColor}.</p>
|
||
|
|
*
|
||
|
|
* @see SplashScreen
|
||
|
|
*/
|
||
|
|
public final class SplashScreenView extends FrameLayout {
|
||
|
|
private static final String TAG = SplashScreenView.class.getSimpleName();
|
||
|
|
private static final boolean DEBUG = Build.IS_DEBUGGABLE;
|
||
|
|
|
||
|
|
private boolean mNotCopyable;
|
||
|
|
private boolean mIsCopied;
|
||
|
|
private int mInitBackgroundColor;
|
||
|
|
private View mIconView;
|
||
|
|
private Bitmap mParceledIconBitmap;
|
||
|
|
private View mBrandingImageView;
|
||
|
|
private Bitmap mParceledBrandingBitmap;
|
||
|
|
private Bitmap mParceledIconBackgroundBitmap;
|
||
|
|
private Duration mIconAnimationDuration;
|
||
|
|
private Instant mIconAnimationStart;
|
||
|
|
|
||
|
|
private final Rect mTmpRect = new Rect();
|
||
|
|
private final int[] mTmpPos = new int[2];
|
||
|
|
|
||
|
|
@Nullable
|
||
|
|
private SurfaceControlViewHost.SurfacePackage mSurfacePackageCopy;
|
||
|
|
@Nullable
|
||
|
|
private SurfaceControlViewHost.SurfacePackage mSurfacePackage;
|
||
|
|
@Nullable
|
||
|
|
private SurfaceView mSurfaceView;
|
||
|
|
@Nullable
|
||
|
|
private SurfaceControlViewHost mSurfaceHost;
|
||
|
|
@Nullable
|
||
|
|
private RemoteCallback mClientCallback;
|
||
|
|
|
||
|
|
// cache original window and status
|
||
|
|
private Window mWindow;
|
||
|
|
private boolean mHasRemoved;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal builder to create a SplashScreenView object.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static class Builder {
|
||
|
|
private final Context mContext;
|
||
|
|
private int mIconSize;
|
||
|
|
private @ColorInt int mBackgroundColor;
|
||
|
|
private Bitmap mParceledIconBitmap;
|
||
|
|
private Bitmap mParceledIconBackgroundBitmap;
|
||
|
|
private Drawable mIconDrawable;
|
||
|
|
// It is only set for legacy splash screen which won't be sent across processes.
|
||
|
|
private Drawable mOverlayDrawable;
|
||
|
|
private Drawable mIconBackground;
|
||
|
|
private SurfaceControlViewHost.SurfacePackage mSurfacePackage;
|
||
|
|
private RemoteCallback mClientCallback;
|
||
|
|
private int mBrandingImageWidth;
|
||
|
|
private int mBrandingImageHeight;
|
||
|
|
private Drawable mBrandingDrawable;
|
||
|
|
private Bitmap mParceledBrandingBitmap;
|
||
|
|
private Instant mIconAnimationStart;
|
||
|
|
private Duration mIconAnimationDuration;
|
||
|
|
private Consumer<Runnable> mUiThreadInitTask;
|
||
|
|
private boolean mAllowHandleSolidColor = true;
|
||
|
|
|
||
|
|
public Builder(@NonNull Context context) {
|
||
|
|
mContext = context;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* When create from {@link SplashScreenViewParcelable}, all the materials were be settled so
|
||
|
|
* you do not need to call other set methods.
|
||
|
|
*/
|
||
|
|
public Builder createFromParcel(SplashScreenViewParcelable parcelable) {
|
||
|
|
mIconSize = parcelable.getIconSize();
|
||
|
|
mBackgroundColor = parcelable.getBackgroundColor();
|
||
|
|
mSurfacePackage = parcelable.mSurfacePackage;
|
||
|
|
if (mSurfacePackage == null && parcelable.mIconBitmap != null) {
|
||
|
|
// We only create a Bitmap copies of immobile icons since animated icon are using
|
||
|
|
// a surface view
|
||
|
|
mIconDrawable = new BitmapDrawable(mContext.getResources(), parcelable.mIconBitmap);
|
||
|
|
mParceledIconBitmap = parcelable.mIconBitmap;
|
||
|
|
}
|
||
|
|
if (parcelable.mIconBackground != null) {
|
||
|
|
mIconBackground = new BitmapDrawable(mContext.getResources(),
|
||
|
|
parcelable.mIconBackground);
|
||
|
|
mParceledIconBackgroundBitmap = parcelable.mIconBackground;
|
||
|
|
}
|
||
|
|
if (parcelable.mBrandingBitmap != null) {
|
||
|
|
setBrandingDrawable(new BitmapDrawable(mContext.getResources(),
|
||
|
|
parcelable.mBrandingBitmap), parcelable.mBrandingWidth,
|
||
|
|
parcelable.mBrandingHeight);
|
||
|
|
mParceledBrandingBitmap = parcelable.mBrandingBitmap;
|
||
|
|
}
|
||
|
|
mIconAnimationStart = Instant.ofEpochMilli(parcelable.mIconAnimationStartMillis);
|
||
|
|
mIconAnimationDuration = Duration.ofMillis(parcelable.mIconAnimationDurationMillis);
|
||
|
|
mClientCallback = parcelable.mClientCallback;
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, String.format("Building from parcel drawable: %s", mIconDrawable));
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the rectangle size for the center view.
|
||
|
|
*/
|
||
|
|
public Builder setIconSize(int iconSize) {
|
||
|
|
mIconSize = iconSize;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the background color for the view.
|
||
|
|
*/
|
||
|
|
public Builder setBackgroundColor(@ColorInt int backgroundColor) {
|
||
|
|
mBackgroundColor = backgroundColor;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the Drawable object to fill entire view
|
||
|
|
*/
|
||
|
|
public Builder setOverlayDrawable(@Nullable Drawable drawable) {
|
||
|
|
mOverlayDrawable = drawable;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the Drawable object to fill the center view.
|
||
|
|
*/
|
||
|
|
public Builder setCenterViewDrawable(@Nullable Drawable drawable) {
|
||
|
|
mIconDrawable = drawable;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the background color for the icon.
|
||
|
|
*/
|
||
|
|
public Builder setIconBackground(Drawable iconBackground) {
|
||
|
|
mIconBackground = iconBackground;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the Runnable that can receive the task which should be executed on UI thread.
|
||
|
|
*/
|
||
|
|
public Builder setUiThreadInitConsumer(Consumer<Runnable> uiThreadInitTask) {
|
||
|
|
mUiThreadInitTask = uiThreadInitTask;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the Drawable object and size for the branding view.
|
||
|
|
*/
|
||
|
|
public Builder setBrandingDrawable(@Nullable Drawable branding, int width, int height) {
|
||
|
|
mBrandingDrawable = branding;
|
||
|
|
mBrandingImageWidth = width;
|
||
|
|
mBrandingImageHeight = height;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets whether this view can be copied and transferred to the client if the view is
|
||
|
|
* empty style splash screen.
|
||
|
|
*/
|
||
|
|
public Builder setAllowHandleSolidColor(boolean allowHandleSolidColor) {
|
||
|
|
mAllowHandleSolidColor = allowHandleSolidColor;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create SplashScreenWindowView object from materials.
|
||
|
|
*/
|
||
|
|
public SplashScreenView build() {
|
||
|
|
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "SplashScreenView#build");
|
||
|
|
final LayoutInflater layoutInflater = LayoutInflater.from(mContext);
|
||
|
|
final SplashScreenView view = (SplashScreenView)
|
||
|
|
layoutInflater.inflate(R.layout.splash_screen_view, null, false);
|
||
|
|
view.mInitBackgroundColor = mBackgroundColor;
|
||
|
|
if (mOverlayDrawable != null) {
|
||
|
|
view.setBackground(mOverlayDrawable);
|
||
|
|
} else {
|
||
|
|
view.setBackgroundColor(mBackgroundColor);
|
||
|
|
}
|
||
|
|
view.mClientCallback = mClientCallback;
|
||
|
|
|
||
|
|
view.mBrandingImageView = view.findViewById(R.id.splashscreen_branding_view);
|
||
|
|
|
||
|
|
boolean hasIcon = false;
|
||
|
|
// center icon
|
||
|
|
if (mIconDrawable instanceof SplashScreenView.IconAnimateListener
|
||
|
|
|| mSurfacePackage != null) {
|
||
|
|
hasIcon = true;
|
||
|
|
if (mUiThreadInitTask != null) {
|
||
|
|
mUiThreadInitTask.accept(() -> view.mIconView = createSurfaceView(view));
|
||
|
|
} else {
|
||
|
|
view.mIconView = createSurfaceView(view);
|
||
|
|
}
|
||
|
|
view.initIconAnimation(mIconDrawable);
|
||
|
|
view.mIconAnimationStart = mIconAnimationStart;
|
||
|
|
view.mIconAnimationDuration = mIconAnimationDuration;
|
||
|
|
} else if (mIconSize != 0) {
|
||
|
|
ImageView imageView = view.findViewById(R.id.splashscreen_icon_view);
|
||
|
|
assert imageView != null;
|
||
|
|
|
||
|
|
final ViewGroup.LayoutParams params = imageView.getLayoutParams();
|
||
|
|
params.width = mIconSize;
|
||
|
|
params.height = mIconSize;
|
||
|
|
imageView.setLayoutParams(params);
|
||
|
|
if (mIconDrawable != null) {
|
||
|
|
imageView.setImageDrawable(mIconDrawable);
|
||
|
|
}
|
||
|
|
if (mIconBackground != null) {
|
||
|
|
imageView.setBackground(mIconBackground);
|
||
|
|
}
|
||
|
|
hasIcon = true;
|
||
|
|
view.mIconView = imageView;
|
||
|
|
}
|
||
|
|
if (mOverlayDrawable != null || (!hasIcon && !mAllowHandleSolidColor)) {
|
||
|
|
view.setNotCopyable();
|
||
|
|
}
|
||
|
|
|
||
|
|
view.mParceledIconBackgroundBitmap = mParceledIconBackgroundBitmap;
|
||
|
|
view.mParceledIconBitmap = mParceledIconBitmap;
|
||
|
|
|
||
|
|
// branding image
|
||
|
|
if (mBrandingImageHeight > 0 && mBrandingImageWidth > 0 && mBrandingDrawable != null) {
|
||
|
|
final ViewGroup.LayoutParams params = view.mBrandingImageView.getLayoutParams();
|
||
|
|
params.width = mBrandingImageWidth;
|
||
|
|
params.height = mBrandingImageHeight;
|
||
|
|
view.mBrandingImageView.setLayoutParams(params);
|
||
|
|
view.mBrandingImageView.setBackground(mBrandingDrawable);
|
||
|
|
} else {
|
||
|
|
view.mBrandingImageView.setVisibility(GONE);
|
||
|
|
}
|
||
|
|
if (mParceledBrandingBitmap != null) {
|
||
|
|
view.mParceledBrandingBitmap = mParceledBrandingBitmap;
|
||
|
|
}
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "Build " + view
|
||
|
|
+ "\nIcon: view: " + view.mIconView + " drawable: "
|
||
|
|
+ mIconDrawable + " size: " + mIconSize
|
||
|
|
+ "\nBranding: view: " + view.mBrandingImageView + " drawable: "
|
||
|
|
+ mBrandingDrawable + " size w: " + mBrandingImageWidth + " h: "
|
||
|
|
+ mBrandingImageHeight);
|
||
|
|
}
|
||
|
|
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
|
||
|
|
return view;
|
||
|
|
}
|
||
|
|
|
||
|
|
private SurfaceView createSurfaceView(@NonNull SplashScreenView view) {
|
||
|
|
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "SplashScreenView#createSurfaceView");
|
||
|
|
final Context viewContext = view.getContext();
|
||
|
|
final SurfaceView surfaceView = new SurfaceView(viewContext);
|
||
|
|
surfaceView.setPadding(0, 0, 0, 0);
|
||
|
|
surfaceView.setBackground(mIconBackground);
|
||
|
|
if (mSurfacePackage == null) {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG,
|
||
|
|
"SurfaceControlViewHost created on thread "
|
||
|
|
+ Thread.currentThread().getId());
|
||
|
|
}
|
||
|
|
|
||
|
|
AttachedSurfaceControl attachedSurfaceControl = surfaceView.getRootSurfaceControl();
|
||
|
|
SurfaceControlViewHost viewHost = new SurfaceControlViewHost(viewContext,
|
||
|
|
viewContext.getDisplay(),
|
||
|
|
attachedSurfaceControl == null ? null
|
||
|
|
: attachedSurfaceControl.getInputTransferToken(),
|
||
|
|
"SplashScreenView");
|
||
|
|
ImageView imageView = new ImageView(viewContext);
|
||
|
|
imageView.setBackground(mIconDrawable);
|
||
|
|
final int windowFlag = WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
|
||
|
|
| WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
|
||
|
|
| WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
|
||
|
|
final WindowManager.LayoutParams lp =
|
||
|
|
new WindowManager.LayoutParams(mIconSize, mIconSize,
|
||
|
|
WindowManager.LayoutParams.TYPE_APPLICATION, windowFlag,
|
||
|
|
PixelFormat.TRANSPARENT);
|
||
|
|
viewHost.setView(imageView, lp);
|
||
|
|
SurfaceControlViewHost.SurfacePackage surfacePackage = viewHost.getSurfacePackage();
|
||
|
|
surfaceView.setChildSurfacePackage(surfacePackage);
|
||
|
|
view.mSurfacePackage = surfacePackage;
|
||
|
|
view.mSurfaceHost = viewHost;
|
||
|
|
view.mSurfacePackageCopy = new SurfaceControlViewHost.SurfacePackage(
|
||
|
|
surfacePackage);
|
||
|
|
} else {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "Using copy of SurfacePackage in the client");
|
||
|
|
}
|
||
|
|
view.mSurfacePackage = mSurfacePackage;
|
||
|
|
}
|
||
|
|
if (mIconSize != 0) {
|
||
|
|
LayoutParams lp = new FrameLayout.LayoutParams(mIconSize, mIconSize);
|
||
|
|
lp.gravity = Gravity.CENTER;
|
||
|
|
surfaceView.setLayoutParams(lp);
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "Icon size " + mIconSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// We ensure that we can blend the alpha of the surface view with the SplashScreenView
|
||
|
|
surfaceView.setUseAlpha();
|
||
|
|
surfaceView.setZOrderOnTop(true);
|
||
|
|
surfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
|
||
|
|
|
||
|
|
view.addView(surfaceView);
|
||
|
|
view.mSurfaceView = surfaceView;
|
||
|
|
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
|
||
|
|
return surfaceView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public SplashScreenView(Context context) {
|
||
|
|
super(context);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public SplashScreenView(Context context, AttributeSet attributeSet) {
|
||
|
|
super(context, attributeSet);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Declared this view is not copyable.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void setNotCopyable() {
|
||
|
|
mNotCopyable = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Whether this view is copyable.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public boolean isCopyable() {
|
||
|
|
return !mNotCopyable;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Called when this {@link SplashScreenView} has been copied to be transferred to the client.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void onCopied() {
|
||
|
|
mIsCopied = true;
|
||
|
|
if (mSurfaceView == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "Setting SurfaceView's SurfacePackage to null.");
|
||
|
|
}
|
||
|
|
// If we don't release the surface package, the surface will be reparented to this
|
||
|
|
// surface view. So once it's copied into the client process, we release it.
|
||
|
|
mSurfacePackage.release();
|
||
|
|
mSurfacePackage = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide **/
|
||
|
|
@Nullable
|
||
|
|
public SurfaceControlViewHost getSurfaceHost() {
|
||
|
|
return mSurfaceHost;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void setAlpha(float alpha) {
|
||
|
|
super.setAlpha(alpha);
|
||
|
|
|
||
|
|
// The surface view's alpha is not multiplied with the containing view's alpha, so we
|
||
|
|
// manually do it here
|
||
|
|
if (mSurfaceView != null) {
|
||
|
|
mSurfaceView.setAlpha(mSurfaceView.getAlpha() * alpha);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the duration of the icon animation if icon is animatable.
|
||
|
|
*
|
||
|
|
* Note the return value can be null or 0 if the
|
||
|
|
* {@link android.R.attr#windowSplashScreenAnimatedIcon} is not
|
||
|
|
* {@link android.graphics.drawable.AnimationDrawable} or
|
||
|
|
* {@link android.graphics.drawable.AnimatedVectorDrawable}.
|
||
|
|
*
|
||
|
|
* @see android.R.attr#windowSplashScreenAnimatedIcon
|
||
|
|
* @see android.R.attr#windowSplashScreenAnimationDuration
|
||
|
|
*/
|
||
|
|
@Nullable
|
||
|
|
public Duration getIconAnimationDuration() {
|
||
|
|
return mIconAnimationDuration;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If the replaced icon is animatable, return the animation start time based on system clock.
|
||
|
|
*/
|
||
|
|
@Nullable
|
||
|
|
public Instant getIconAnimationStart() {
|
||
|
|
return mIconAnimationStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void syncTransferSurfaceOnDraw() {
|
||
|
|
if (mSurfacePackage == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (DEBUG) {
|
||
|
|
mSurfacePackage.getSurfaceControl().addOnReparentListener(
|
||
|
|
(transaction, parent) -> Log.e(TAG,
|
||
|
|
String.format("SurfacePackage'surface reparented to %s", parent)));
|
||
|
|
Log.d(TAG, "Transferring surface " + mSurfaceView.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
mSurfaceView.setChildSurfacePackage(mSurfacePackage);
|
||
|
|
}
|
||
|
|
|
||
|
|
void initIconAnimation(Drawable iconDrawable) {
|
||
|
|
if (!(iconDrawable instanceof IconAnimateListener)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
IconAnimateListener aniDrawable = (IconAnimateListener) iconDrawable;
|
||
|
|
aniDrawable.prepareAnimate(this::animationStartCallback);
|
||
|
|
aniDrawable.setAnimationJankMonitoring(new AnimatorListenerAdapter() {
|
||
|
|
@Override
|
||
|
|
public void onAnimationCancel(Animator animation) {
|
||
|
|
InteractionJankMonitor.getInstance().cancel(CUJ_SPLASHSCREEN_AVD);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onAnimationEnd(Animator animation) {
|
||
|
|
InteractionJankMonitor.getInstance().end(CUJ_SPLASHSCREEN_AVD);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onAnimationStart(Animator animation) {
|
||
|
|
InteractionJankMonitor.getInstance().begin(
|
||
|
|
SplashScreenView.this, CUJ_SPLASHSCREEN_AVD);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
private void animationStartCallback(long animDuration) {
|
||
|
|
mIconAnimationStart = Instant.now();
|
||
|
|
if (animDuration >= 0) {
|
||
|
|
mIconAnimationDuration = Duration.ofMillis(animDuration);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>Remove this view and release its resource. </p>
|
||
|
|
* <p><strong>Do not</strong> invoke this method from a drawing method
|
||
|
|
* ({@link #onDraw(android.graphics.Canvas)} for instance).</p>
|
||
|
|
*/
|
||
|
|
@UiThread
|
||
|
|
public void remove() {
|
||
|
|
if (mHasRemoved) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
setVisibility(GONE);
|
||
|
|
if (mParceledIconBitmap != null) {
|
||
|
|
if (mIconView instanceof ImageView) {
|
||
|
|
((ImageView) mIconView).setImageDrawable(null);
|
||
|
|
} else if (mIconView != null) {
|
||
|
|
mIconView.setBackground(null);
|
||
|
|
}
|
||
|
|
mParceledIconBitmap.recycle();
|
||
|
|
mParceledIconBitmap = null;
|
||
|
|
}
|
||
|
|
if (mParceledBrandingBitmap != null) {
|
||
|
|
mBrandingImageView.setBackground(null);
|
||
|
|
mParceledBrandingBitmap.recycle();
|
||
|
|
mParceledBrandingBitmap = null;
|
||
|
|
}
|
||
|
|
if (mParceledIconBackgroundBitmap != null) {
|
||
|
|
if (mIconView != null) {
|
||
|
|
mIconView.setBackground(null);
|
||
|
|
}
|
||
|
|
mParceledIconBackgroundBitmap.recycle();
|
||
|
|
mParceledIconBackgroundBitmap = null;
|
||
|
|
}
|
||
|
|
if (mWindow != null) {
|
||
|
|
final DecorView decorView = (DecorView) mWindow.peekDecorView();
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "remove starting view");
|
||
|
|
}
|
||
|
|
if (decorView != null) {
|
||
|
|
decorView.removeView(this);
|
||
|
|
}
|
||
|
|
mWindow = null;
|
||
|
|
}
|
||
|
|
mHasRemoved = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide **/
|
||
|
|
@Override
|
||
|
|
protected void onDetachedFromWindow() {
|
||
|
|
super.onDetachedFromWindow();
|
||
|
|
releaseAnimationSurfaceHost();
|
||
|
|
if (mIconView instanceof ImageView imageView
|
||
|
|
&& imageView.getDrawable() instanceof Closeable closeableDrawable) {
|
||
|
|
try {
|
||
|
|
closeableDrawable.close();
|
||
|
|
} catch (IOException ignore) { }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
protected void onLayout(boolean changed, int l, int t, int r, int b) {
|
||
|
|
super.onLayout(changed, l, t, r, b);
|
||
|
|
|
||
|
|
mBrandingImageView.getDrawingRect(mTmpRect);
|
||
|
|
final int brandingHeight = mTmpRect.height();
|
||
|
|
if (brandingHeight == 0 || mIconView == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
final int visibility = mBrandingImageView.getVisibility();
|
||
|
|
if (visibility != VISIBLE) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
final int currentHeight = b - t;
|
||
|
|
|
||
|
|
mIconView.getLocationInWindow(mTmpPos);
|
||
|
|
mIconView.getDrawingRect(mTmpRect);
|
||
|
|
final int iconHeight = mTmpRect.height();
|
||
|
|
|
||
|
|
final ViewGroup.MarginLayoutParams params =
|
||
|
|
(ViewGroup.MarginLayoutParams) mBrandingImageView.getLayoutParams();
|
||
|
|
if (params == null) {
|
||
|
|
Log.e(TAG, "Unable to adjust branding image layout, layout changed?");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
final int marginBottom = params.bottomMargin;
|
||
|
|
final int remainingHeight = currentHeight - mTmpPos[1] - iconHeight;
|
||
|
|
final int remainingMaxMargin = remainingHeight - brandingHeight;
|
||
|
|
if (remainingHeight < brandingHeight) {
|
||
|
|
// unable to show the branding image, hide it
|
||
|
|
mBrandingImageView.setVisibility(GONE);
|
||
|
|
} else if (remainingMaxMargin < marginBottom) {
|
||
|
|
// shorter than original margin
|
||
|
|
params.bottomMargin = (int) Math.round(remainingMaxMargin / 2.0);
|
||
|
|
mBrandingImageView.setLayoutParams(params);
|
||
|
|
}
|
||
|
|
// nothing need to adjust
|
||
|
|
}
|
||
|
|
|
||
|
|
private void releaseAnimationSurfaceHost() {
|
||
|
|
if (mSurfaceHost != null && !mIsCopied) {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG,
|
||
|
|
"Shell removed splash screen."
|
||
|
|
+ " Releasing SurfaceControlViewHost on thread #"
|
||
|
|
+ Thread.currentThread().getId());
|
||
|
|
}
|
||
|
|
releaseIconHost(mSurfaceHost);
|
||
|
|
mSurfaceHost = null;
|
||
|
|
} else if (mSurfacePackage != null && mSurfaceHost == null) {
|
||
|
|
mSurfacePackage = null;
|
||
|
|
mClientCallback.sendResult(null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Release the host which hold the SurfaceView of the icon.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static void releaseIconHost(SurfaceControlViewHost host) {
|
||
|
|
final Drawable background = host.getView().getBackground();
|
||
|
|
if (background instanceof SplashScreenView.IconAnimateListener) {
|
||
|
|
((SplashScreenView.IconAnimateListener) background).stopAnimation();
|
||
|
|
}
|
||
|
|
host.release();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Called when this view is attached to a window of an activity.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public void attachHostWindow(Window window) {
|
||
|
|
mWindow = window;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the view containing the Splash Screen icon and its background.
|
||
|
|
* @see android.R.attr#windowSplashScreenAnimatedIcon
|
||
|
|
*/
|
||
|
|
public @Nullable View getIconView() {
|
||
|
|
return mIconView;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the branding image view.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
public @Nullable View getBrandingView() {
|
||
|
|
return mBrandingImageView;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the initial background color of this view.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public @ColorInt int getInitBackgroundColor() {
|
||
|
|
return mInitBackgroundColor;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An interface for an animatable drawable object to register a callback when animation start.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public interface IconAnimateListener {
|
||
|
|
/**
|
||
|
|
* Prepare the animation if this drawable also be animatable.
|
||
|
|
* @param startListener The callback listener used to receive the start of the animation.
|
||
|
|
*/
|
||
|
|
void prepareAnimate(LongConsumer startListener);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stop animation.
|
||
|
|
*/
|
||
|
|
void stopAnimation();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Provides a chance to start interaction jank monitoring in avd animation.
|
||
|
|
* @param listener a listener to start jank monitoring
|
||
|
|
*/
|
||
|
|
default void setAnimationJankMonitoring(AnimatorListenerAdapter listener) {}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Use to create {@link SplashScreenView} object across process.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public static class SplashScreenViewParcelable implements Parcelable {
|
||
|
|
private int mIconSize;
|
||
|
|
private int mBackgroundColor;
|
||
|
|
private Bitmap mIconBackground;
|
||
|
|
|
||
|
|
private Bitmap mIconBitmap = null;
|
||
|
|
private int mBrandingWidth;
|
||
|
|
private int mBrandingHeight;
|
||
|
|
private Bitmap mBrandingBitmap;
|
||
|
|
|
||
|
|
private long mIconAnimationStartMillis;
|
||
|
|
private long mIconAnimationDurationMillis;
|
||
|
|
|
||
|
|
private SurfaceControlViewHost.SurfacePackage mSurfacePackage;
|
||
|
|
private RemoteCallback mClientCallback;
|
||
|
|
|
||
|
|
public SplashScreenViewParcelable(SplashScreenView view) {
|
||
|
|
final View iconView = view.getIconView();
|
||
|
|
mIconSize = iconView != null ? iconView.getWidth() : 0;
|
||
|
|
mBackgroundColor = view.getInitBackgroundColor();
|
||
|
|
mIconBackground = iconView != null ? copyDrawable(iconView.getBackground()) : null;
|
||
|
|
mSurfacePackage = view.mSurfacePackageCopy;
|
||
|
|
if (mSurfacePackage == null) {
|
||
|
|
// We only need to copy the drawable if we are not using a SurfaceView
|
||
|
|
mIconBitmap = iconView != null
|
||
|
|
? copyDrawable(((ImageView) view.getIconView()).getDrawable()) : null;
|
||
|
|
}
|
||
|
|
mBrandingBitmap = copyDrawable(view.getBrandingView().getBackground());
|
||
|
|
|
||
|
|
ViewGroup.LayoutParams params = view.getBrandingView().getLayoutParams();
|
||
|
|
mBrandingWidth = params.width;
|
||
|
|
mBrandingHeight = params.height;
|
||
|
|
|
||
|
|
if (view.getIconAnimationStart() != null) {
|
||
|
|
mIconAnimationStartMillis = view.getIconAnimationStart().toEpochMilli();
|
||
|
|
}
|
||
|
|
if (view.getIconAnimationDuration() != null) {
|
||
|
|
mIconAnimationDurationMillis = view.getIconAnimationDuration().toMillis();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Bitmap copyDrawable(Drawable drawable) {
|
||
|
|
if (drawable != null) {
|
||
|
|
final Rect initialBounds = drawable.copyBounds();
|
||
|
|
final int width = initialBounds.width();
|
||
|
|
final int height = initialBounds.height();
|
||
|
|
if (width <= 0 || height <= 0) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
final Bitmap snapshot = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
|
||
|
|
final Canvas bmpCanvas = new Canvas(snapshot);
|
||
|
|
drawable.setBounds(0, 0, width, height);
|
||
|
|
drawable.draw(bmpCanvas);
|
||
|
|
final Bitmap copyBitmap = snapshot.createAshmemBitmap();
|
||
|
|
snapshot.recycle();
|
||
|
|
return copyBitmap;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private SplashScreenViewParcelable(@NonNull Parcel source) {
|
||
|
|
readParcel(source);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void readParcel(@NonNull Parcel source) {
|
||
|
|
mIconSize = source.readInt();
|
||
|
|
mBackgroundColor = source.readInt();
|
||
|
|
mIconBitmap = source.readTypedObject(Bitmap.CREATOR);
|
||
|
|
mBrandingWidth = source.readInt();
|
||
|
|
mBrandingHeight = source.readInt();
|
||
|
|
mBrandingBitmap = source.readTypedObject(Bitmap.CREATOR);
|
||
|
|
mIconAnimationStartMillis = source.readLong();
|
||
|
|
mIconAnimationDurationMillis = source.readLong();
|
||
|
|
mIconBackground = source.readTypedObject(Bitmap.CREATOR);
|
||
|
|
mSurfacePackage = source.readTypedObject(SurfaceControlViewHost.SurfacePackage.CREATOR);
|
||
|
|
mClientCallback = source.readTypedObject(RemoteCallback.CREATOR);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int describeContents() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void writeToParcel(Parcel dest, int flags) {
|
||
|
|
dest.writeInt(mIconSize);
|
||
|
|
dest.writeInt(mBackgroundColor);
|
||
|
|
dest.writeTypedObject(mIconBitmap, flags);
|
||
|
|
dest.writeInt(mBrandingWidth);
|
||
|
|
dest.writeInt(mBrandingHeight);
|
||
|
|
dest.writeTypedObject(mBrandingBitmap, flags);
|
||
|
|
dest.writeLong(mIconAnimationStartMillis);
|
||
|
|
dest.writeLong(mIconAnimationDurationMillis);
|
||
|
|
dest.writeTypedObject(mIconBackground, flags);
|
||
|
|
dest.writeTypedObject(mSurfacePackage, flags);
|
||
|
|
dest.writeTypedObject(mClientCallback, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static final @NonNull Parcelable.Creator<SplashScreenViewParcelable> CREATOR =
|
||
|
|
new Parcelable.Creator<SplashScreenViewParcelable>() {
|
||
|
|
public SplashScreenViewParcelable createFromParcel(@NonNull Parcel source) {
|
||
|
|
return new SplashScreenViewParcelable(source);
|
||
|
|
}
|
||
|
|
public SplashScreenViewParcelable[] newArray(int size) {
|
||
|
|
return new SplashScreenViewParcelable[size];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Release the bitmap if another process cannot handle it.
|
||
|
|
*/
|
||
|
|
public void clearIfNeeded() {
|
||
|
|
if (mIconBitmap != null) {
|
||
|
|
mIconBitmap.recycle();
|
||
|
|
mIconBitmap = null;
|
||
|
|
}
|
||
|
|
if (mBrandingBitmap != null) {
|
||
|
|
mBrandingBitmap.recycle();
|
||
|
|
mBrandingBitmap = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int getIconSize() {
|
||
|
|
return mIconSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
int getBackgroundColor() {
|
||
|
|
return mBackgroundColor;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the {@link RemoteCallback} that will be called by the client to notify the shell
|
||
|
|
* of the removal of the {@link SplashScreenView}.
|
||
|
|
*/
|
||
|
|
public void setClientCallback(@NonNull RemoteCallback clientCallback) {
|
||
|
|
mClientCallback = clientCallback;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|