giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4380f00a78
script-astra/Android/Sdk/sources/android-35/com/android/internal/policy/TransitionAnimation.java

1401 lines
63 KiB
Java
Raw Normal View History

init
2025-01-20 15:15:20 +00:00
/*
* Copyright (C) 2021 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 com.android.internal.policy;
import static android.view.WindowManager.TRANSIT_CLOSE;
import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION;
import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION;
import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE;
import static android.view.WindowManager.TRANSIT_OLD_ACTIVITY_CLOSE;
import static android.view.WindowManager.TRANSIT_OLD_ACTIVITY_OPEN;
import static android.view.WindowManager.TRANSIT_OLD_NONE;
import static android.view.WindowManager.TRANSIT_OLD_TRANSLUCENT_ACTIVITY_CLOSE;
import static android.view.WindowManager.TRANSIT_OLD_TRANSLUCENT_ACTIVITY_OPEN;
import static android.view.WindowManager.TRANSIT_OLD_UNSET;
import static android.view.WindowManager.TRANSIT_OLD_WALLPAPER_INTRA_CLOSE;
import static android.view.WindowManager.TRANSIT_OLD_WALLPAPER_INTRA_OPEN;
import static android.view.WindowManager.TRANSIT_OPEN;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.ResourceId;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorSpace;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.hardware.HardwareBuffer;
import android.media.Image;
import android.media.ImageReader;
import android.os.Handler;
import android.os.SystemProperties;
import android.util.Slog;
import android.view.InflateException;
import android.view.SurfaceControl;
import android.view.WindowManager.LayoutParams;
import android.view.WindowManager.TransitionOldType;
import android.view.WindowManager.TransitionType;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.AnimationSet;
import android.view.animation.AnimationUtils;
import android.view.animation.ClipRectAnimation;
import android.view.animation.Interpolator;
import android.view.animation.PathInterpolator;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;
import android.window.ScreenCapture;
import com.android.internal.R;
import java.nio.ByteBuffer;
import java.util.List;
/** @hide */
public class TransitionAnimation {
public static final int WALLPAPER_TRANSITION_NONE = 0;
public static final int WALLPAPER_TRANSITION_OPEN = 1;
public static final int WALLPAPER_TRANSITION_CLOSE = 2;
public static final int WALLPAPER_TRANSITION_INTRA_OPEN = 3;
public static final int WALLPAPER_TRANSITION_INTRA_CLOSE = 4;
// These are the possible states for the enter/exit activities during a thumbnail transition
private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_UP = 0;
private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_UP = 1;
private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN = 2;
private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN = 3;
/**
* Maximum duration for the clip reveal animation. This is used when there is a lot of movement
* involved, to make it more understandable.
*/
private static final int MAX_CLIP_REVEAL_TRANSITION_DURATION = 420;
private static final int CLIP_REVEAL_TRANSLATION_Y_DP = 8;
private static final int THUMBNAIL_APP_TRANSITION_DURATION = 336;
public static final int DEFAULT_APP_TRANSITION_DURATION = 336;
/** Fraction of animation at which the recents thumbnail stays completely transparent */
private static final float RECENTS_THUMBNAIL_FADEIN_FRACTION = 0.5f;
/** Fraction of animation at which the recents thumbnail becomes completely transparent */
private static final float RECENTS_THUMBNAIL_FADEOUT_FRACTION = 0.5f;
/** Interpolator to be used for animations that respond directly to a touch */
static final Interpolator TOUCH_RESPONSE_INTERPOLATOR =
new PathInterpolator(0.3f, 0f, 0.1f, 1f);
private static final String DEFAULT_PACKAGE = "android";
private final Context mContext;
private final String mTag;
private final LogDecelerateInterpolator mInterpolator = new LogDecelerateInterpolator(100, 0);
/** Interpolator to be used for animations that respond directly to a touch */
private final Interpolator mTouchResponseInterpolator =
new PathInterpolator(0.3f, 0f, 0.1f, 1f);
private final Interpolator mClipHorizontalInterpolator = new PathInterpolator(0, 0, 0.4f, 1f);
private final Interpolator mDecelerateInterpolator;
private final Interpolator mFastOutLinearInInterpolator;
private final Interpolator mLinearOutSlowInInterpolator;
private final Interpolator mThumbnailFadeInInterpolator;
private final Interpolator mThumbnailFadeOutInterpolator;
private final Rect mTmpFromClipRect = new Rect();
private final Rect mTmpToClipRect = new Rect();
private final Rect mTmpRect = new Rect();
private final int mClipRevealTranslationY;
private final int mConfigShortAnimTime;
private final int mDefaultWindowAnimationStyleResId;
private final boolean mDebug;
private final boolean mLowRamRecentsEnabled;
public TransitionAnimation(Context context, boolean debug, String tag) {
mContext = context;
mDebug = debug;
mTag = tag;
mDecelerateInterpolator = AnimationUtils.loadInterpolator(context,
com.android.internal.R.interpolator.decelerate_cubic);
mFastOutLinearInInterpolator = AnimationUtils.loadInterpolator(context,
com.android.internal.R.interpolator.fast_out_linear_in);
mLinearOutSlowInInterpolator = AnimationUtils.loadInterpolator(context,
com.android.internal.R.interpolator.linear_out_slow_in);
mThumbnailFadeInInterpolator = input -> {
// Linear response for first fraction, then complete after that.
if (input < RECENTS_THUMBNAIL_FADEIN_FRACTION) {
return 0f;
}
float t = (input - RECENTS_THUMBNAIL_FADEIN_FRACTION)
/ (1f - RECENTS_THUMBNAIL_FADEIN_FRACTION);
return mFastOutLinearInInterpolator.getInterpolation(t);
};
mThumbnailFadeOutInterpolator = input -> {
// Linear response for first fraction, then complete after that.
if (input < RECENTS_THUMBNAIL_FADEOUT_FRACTION) {
float t = input / RECENTS_THUMBNAIL_FADEOUT_FRACTION;
return mLinearOutSlowInInterpolator.getInterpolation(t);
}
return 1f;
};
mClipRevealTranslationY = (int) (CLIP_REVEAL_TRANSLATION_Y_DP
* mContext.getResources().getDisplayMetrics().density);
mConfigShortAnimTime = context.getResources().getInteger(
com.android.internal.R.integer.config_shortAnimTime);
mLowRamRecentsEnabled = ActivityManager.isLowRamDeviceStatic();
final TypedArray windowStyle = mContext.getTheme().obtainStyledAttributes(
com.android.internal.R.styleable.Window);
mDefaultWindowAnimationStyleResId = windowStyle.getResourceId(
com.android.internal.R.styleable.Window_windowAnimationStyle, 0);
windowStyle.recycle();
}
/** Loads keyguard animation by transition flags and check it is on wallpaper or not. */
public Animation loadKeyguardExitAnimation(int transitionFlags, boolean onWallpaper) {
if ((transitionFlags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION) != 0) {
return null;
}
final boolean toShade =
(transitionFlags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE) != 0;
final boolean subtle =
(transitionFlags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION) != 0;
return createHiddenByKeyguardExit(mContext, mInterpolator, onWallpaper, toShade, subtle);
}
@Nullable
public Animation loadKeyguardUnoccludeAnimation() {
return loadDefaultAnimationRes(com.android.internal.R.anim.wallpaper_open_exit);
}
@Nullable
public Animation loadVoiceActivityOpenAnimation(boolean enter) {
return loadDefaultAnimationRes(enter
? com.android.internal.R.anim.voice_activity_open_enter
: com.android.internal.R.anim.voice_activity_open_exit);
}
@Nullable
public Animation loadVoiceActivityExitAnimation(boolean enter) {
return loadDefaultAnimationRes(enter
? com.android.internal.R.anim.voice_activity_close_enter
: com.android.internal.R.anim.voice_activity_close_exit);
}
@Nullable
public Animation loadAppTransitionAnimation(String packageName, int resId) {
return loadAnimationRes(packageName, resId);
}
@Nullable
public Animation loadCrossProfileAppEnterAnimation() {
return loadAnimationRes(DEFAULT_PACKAGE,
com.android.internal.R.anim.task_open_enter_cross_profile_apps);
}
@Nullable
public Animation loadCrossProfileAppThumbnailEnterAnimation() {
return loadAnimationRes(
DEFAULT_PACKAGE, com.android.internal.R.anim.cross_profile_apps_thumbnail_enter);
}
@Nullable
public Animation createCrossProfileAppsThumbnailAnimationLocked(Rect appRect) {
final Animation animation = loadCrossProfileAppThumbnailEnterAnimation();
return prepareThumbnailAnimationWithDuration(animation, appRect.width(),
appRect.height(), 0, null);
}
/** Load animation by resource Id from specific package. */
@Nullable
public Animation loadAnimationRes(String packageName, int resId) {
if (ResourceId.isValid(resId)) {
AttributeCache.Entry ent = getCachedAnimations(packageName, resId);
if (ent != null) {
return loadAnimationSafely(ent.context, resId, mTag);
}
}
return null;
}
/** Load animation by resource Id from android package. */
@Nullable
public Animation loadDefaultAnimationRes(int resId) {
return loadAnimationRes(DEFAULT_PACKAGE, resId);
}
/** Load animation by attribute Id from specific LayoutParams */
@Nullable
public Animation loadAnimationAttr(LayoutParams lp, int animAttr, int transit) {
int resId = Resources.ID_NULL;
Context context = mContext;
if (animAttr >= 0) {
AttributeCache.Entry ent = getCachedAnimations(lp);
if (ent != null) {
context = ent.context;
resId = ent.array.getResourceId(animAttr, 0);
}
}
resId = updateToTranslucentAnimIfNeeded(resId, transit);
if (ResourceId.isValid(resId)) {
return loadAnimationSafely(context, resId, mTag);
}
return null;
}
/** Get animation resId by attribute Id from specific LayoutParams */
public int getAnimationResId(LayoutParams lp, int animAttr, int transit) {
int resId = Resources.ID_NULL;
if (animAttr >= 0) {
AttributeCache.Entry ent = getCachedAnimations(lp);
if (ent != null) {
resId = ent.array.getResourceId(animAttr, 0);
}
}
resId = updateToTranslucentAnimIfNeeded(resId, transit);
return resId;
}
/** Get default animation resId */
public int getDefaultAnimationResId(int animAttr, int transit) {
int resId = Resources.ID_NULL;
if (animAttr >= 0) {
AttributeCache.Entry ent = getCachedAnimations(DEFAULT_PACKAGE,
mDefaultWindowAnimationStyleResId);
if (ent != null) {
resId = ent.array.getResourceId(animAttr, 0);
}
}
resId = updateToTranslucentAnimIfNeeded(resId, transit);
return resId;
}
/**
* Load animation by attribute Id from a specific AnimationStyle resource.
*
* @param translucent {@code true} if we're sure that the animation is applied on a translucent
* window container, {@code false} otherwise.
* @param transit {@link TransitionOldType} for the app transition of this animation, or
* {@link TransitionOldType#TRANSIT_OLD_UNSET} if app transition type is unknown.
*/
@Nullable
private Animation loadAnimationAttr(String packageName, int animStyleResId, int animAttr,
boolean translucent, @TransitionOldType int transit) {
if (animStyleResId == 0) {
return null;
}
int resId = Resources.ID_NULL;
Context context = mContext;
if (animAttr >= 0) {
packageName = packageName != null ? packageName : DEFAULT_PACKAGE;
AttributeCache.Entry ent = getCachedAnimations(packageName, animStyleResId);
if (ent != null) {
context = ent.context;
resId = ent.array.getResourceId(animAttr, 0);
}
}
if (translucent) {
resId = updateToTranslucentAnimIfNeeded(resId);
} else if (transit != TRANSIT_OLD_UNSET) {
resId = updateToTranslucentAnimIfNeeded(resId, transit);
}
if (ResourceId.isValid(resId)) {
return loadAnimationSafely(context, resId, mTag);
}
return null;
}
/** Load animation by attribute Id from a specific AnimationStyle resource. */
@Nullable
public Animation loadAnimationAttr(String packageName, int animStyleResId, int animAttr,
boolean translucent) {
return loadAnimationAttr(packageName, animStyleResId, animAttr, translucent,
TRANSIT_OLD_UNSET);
}
/** Load animation by attribute Id from android package. */
@Nullable
public Animation loadDefaultAnimationAttr(int animAttr, boolean translucent) {
return loadAnimationAttr(DEFAULT_PACKAGE, mDefaultWindowAnimationStyleResId, animAttr,
translucent);
}
/** Load animation by attribute Id from android package. */
@Nullable
public Animation loadDefaultAnimationAttr(int animAttr, @TransitionOldType int transit) {
return loadAnimationAttr(DEFAULT_PACKAGE, mDefaultWindowAnimationStyleResId, animAttr,
false /* translucent */, transit);
}
@Nullable
private AttributeCache.Entry getCachedAnimations(LayoutParams lp) {
if (mDebug) {
Slog.v(mTag, "Loading animations: layout params pkg="
+ (lp != null ? lp.packageName : null)
+ " resId=0x" + (lp != null ? Integer.toHexString(lp.windowAnimations) : null));
}
if (lp != null && lp.windowAnimations != 0) {
// If this is a system resource, don't try to load it from the
// application resources. It is nice to avoid loading application
// resources if we can.
String packageName = lp.packageName != null ? lp.packageName : DEFAULT_PACKAGE;
int resId = getAnimationStyleResId(lp);
if ((resId & 0xFF000000) == 0x01000000) {
packageName = DEFAULT_PACKAGE;
}
if (mDebug) {
Slog.v(mTag, "Loading animations: picked package=" + packageName);
}
return AttributeCache.instance().get(packageName, resId,
com.android.internal.R.styleable.WindowAnimation);
}
return null;
}
@Nullable
private AttributeCache.Entry getCachedAnimations(String packageName, int resId) {
if (mDebug) {
Slog.v(mTag, "Loading animations: package="
+ packageName + " resId=0x" + Integer.toHexString(resId));
}
if (packageName != null) {
if ((resId & 0xFF000000) == 0x01000000) {
packageName = DEFAULT_PACKAGE;
}
if (mDebug) {
Slog.v(mTag, "Loading animations: picked package="
+ packageName);
}
return AttributeCache.instance().get(packageName, resId,
com.android.internal.R.styleable.WindowAnimation);
}
return null;
}
/** Returns window animation style ID from {@link LayoutParams} or from system in some cases */
public int getAnimationStyleResId(@NonNull LayoutParams lp) {
int resId = lp.windowAnimations;
if (lp.type == LayoutParams.TYPE_APPLICATION_STARTING) {
// Note that we don't want application to customize starting window animation.
// Since this window is specific for displaying while app starting,
// application should not change its animation directly.
// In this case, it will use system resource to get default animation.
resId = mDefaultWindowAnimationStyleResId;
}
return resId;
}
public Animation createRelaunchAnimation(Rect containingFrame, Rect contentInsets,
Rect startRect) {
setupDefaultNextAppTransitionStartRect(startRect, mTmpFromClipRect);
final int left = mTmpFromClipRect.left;
final int top = mTmpFromClipRect.top;
mTmpFromClipRect.offset(-left, -top);
// TODO: Isn't that strange that we ignore exact position of the containingFrame?
mTmpToClipRect.set(0, 0, containingFrame.width(), containingFrame.height());
AnimationSet set = new AnimationSet(true);
float fromWidth = mTmpFromClipRect.width();
float toWidth = mTmpToClipRect.width();
float fromHeight = mTmpFromClipRect.height();
// While the window might span the whole display, the actual content will be cropped to the
// system decoration frame, for example when the window is docked. We need to take into
// account the visible height when constructing the animation.
float toHeight = mTmpToClipRect.height() - contentInsets.top - contentInsets.bottom;
int translateAdjustment = 0;
if (fromWidth <= toWidth && fromHeight <= toHeight) {
// The final window is larger in both dimensions than current window (e.g. we are
// maximizing), so we can simply unclip the new window and there will be no disappearing
// frame.
set.addAnimation(new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect));
} else {
// The disappearing window has one larger dimension. We need to apply scaling, so the
// first frame of the entry animation matches the old window.
set.addAnimation(new ScaleAnimation(fromWidth / toWidth, 1, fromHeight / toHeight, 1));
// We might not be going exactly full screen, but instead be aligned under the status
// bar using cropping. We still need to account for the cropped part, which will also
// be scaled.
translateAdjustment = (int) (contentInsets.top * fromHeight / toHeight);
}
// We animate the translation from the old position of the removed window, to the new
// position of the added window. The latter might not be full screen, for example docked for
// docked windows.
TranslateAnimation translate = new TranslateAnimation(left - containingFrame.left,
0, top - containingFrame.top - translateAdjustment, 0);
set.addAnimation(translate);
set.setDuration(DEFAULT_APP_TRANSITION_DURATION);
set.setZAdjustment(Animation.ZORDER_TOP);
return set;
}
private void setupDefaultNextAppTransitionStartRect(Rect startRect, Rect rect) {
if (startRect == null) {
Slog.e(mTag, "Starting rect for app requested, but none available", new Throwable());
rect.setEmpty();
} else {
rect.set(startRect);
}
}
public Animation createClipRevealAnimationLocked(@TransitionType int transit,
int wallpaperTransit, boolean enter, Rect appFrame, Rect displayFrame, Rect startRect) {
return createClipRevealAnimationLockedCompat(
getTransitCompatType(transit, wallpaperTransit), enter, appFrame, displayFrame,
startRect);
}
public Animation createClipRevealAnimationLockedCompat(@TransitionOldType int transit,
boolean enter, Rect appFrame, Rect displayFrame, Rect startRect) {
final Animation anim;
if (enter) {
final int appWidth = appFrame.width();
final int appHeight = appFrame.height();
// mTmpRect will contain an area around the launcher icon that was pressed. We will
// clip reveal from that area in the final area of the app.
setupDefaultNextAppTransitionStartRect(startRect, mTmpRect);
float t = 0f;
if (appHeight > 0) {
t = (float) mTmpRect.top / displayFrame.height();
}
int translationY = mClipRevealTranslationY + (int) (displayFrame.height() / 7f * t);
int translationX = 0;
int translationYCorrection = translationY;
int centerX = mTmpRect.centerX();
int centerY = mTmpRect.centerY();
int halfWidth = mTmpRect.width() / 2;
int halfHeight = mTmpRect.height() / 2;
int clipStartX = centerX - halfWidth - appFrame.left;
int clipStartY = centerY - halfHeight - appFrame.top;
boolean cutOff = false;
// If the starting rectangle is fully or partially outside of the target rectangle, we
// need to start the clipping at the edge and then achieve the rest with translation
// and extending the clip rect from that edge.
if (appFrame.top > centerY - halfHeight) {
translationY = (centerY - halfHeight) - appFrame.top;
translationYCorrection = 0;
clipStartY = 0;
cutOff = true;
}
if (appFrame.left > centerX - halfWidth) {
translationX = (centerX - halfWidth) - appFrame.left;
clipStartX = 0;
cutOff = true;
}
if (appFrame.right < centerX + halfWidth) {
translationX = (centerX + halfWidth) - appFrame.right;
clipStartX = appWidth - mTmpRect.width();
cutOff = true;
}
final long duration = calculateClipRevealTransitionDuration(cutOff, translationX,
translationY, displayFrame);
// Clip third of the from size of launch icon, expand to full width/height
Animation clipAnimLR = new ClipRectLRAnimation(
clipStartX, clipStartX + mTmpRect.width(), 0, appWidth);
clipAnimLR.setInterpolator(mClipHorizontalInterpolator);
clipAnimLR.setDuration((long) (duration / 2.5f));
TranslateAnimation translate = new TranslateAnimation(translationX, 0, translationY, 0);
translate.setInterpolator(cutOff ? mTouchResponseInterpolator
: mLinearOutSlowInInterpolator);
translate.setDuration(duration);
Animation clipAnimTB = new ClipRectTBAnimation(
clipStartY, clipStartY + mTmpRect.height(),
0, appHeight,
translationYCorrection, 0,
mLinearOutSlowInInterpolator);
clipAnimTB.setInterpolator(mTouchResponseInterpolator);
clipAnimTB.setDuration(duration);
// Quick fade-in from icon to app window
final long alphaDuration = duration / 4;
AlphaAnimation alpha = new AlphaAnimation(0.5f, 1);
alpha.setDuration(alphaDuration);
alpha.setInterpolator(mLinearOutSlowInInterpolator);
AnimationSet set = new AnimationSet(false);
set.addAnimation(clipAnimLR);
set.addAnimation(clipAnimTB);
set.addAnimation(translate);
set.addAnimation(alpha);
set.setZAdjustment(Animation.ZORDER_TOP);
set.initialize(appWidth, appHeight, appWidth, appHeight);
anim = set;
} else {
final long duration;
switch (transit) {
case TRANSIT_OLD_ACTIVITY_OPEN:
case TRANSIT_OLD_ACTIVITY_CLOSE:
duration = mConfigShortAnimTime;
break;
default:
duration = DEFAULT_APP_TRANSITION_DURATION;
break;
}
if (transit == TRANSIT_OLD_WALLPAPER_INTRA_OPEN
|| transit == TRANSIT_OLD_WALLPAPER_INTRA_CLOSE) {
// If we are on top of the wallpaper, we need an animation that
// correctly handles the wallpaper staying static behind all of
// the animated elements. To do this, will just have the existing
// element fade out.
anim = new AlphaAnimation(1, 0);
anim.setDetachWallpaper(true);
} else {
// For normal animations, the exiting element just holds in place.
anim = new AlphaAnimation(1, 1);
}
anim.setInterpolator(mDecelerateInterpolator);
anim.setDuration(duration);
anim.setFillAfter(true);
}
return anim;
}
public Animation createScaleUpAnimationLocked(@TransitionType int transit, int wallpaperTransit,
boolean enter, Rect containingFrame, Rect startRect) {
return createScaleUpAnimationLockedCompat(getTransitCompatType(transit, wallpaperTransit),
enter, containingFrame, startRect);
}
public Animation createScaleUpAnimationLockedCompat(@TransitionOldType int transit,
boolean enter, Rect containingFrame, Rect startRect) {
Animation a;
setupDefaultNextAppTransitionStartRect(startRect, mTmpRect);
final int appWidth = containingFrame.width();
final int appHeight = containingFrame.height();
if (enter) {
// Entering app zooms out from the center of the initial rect.
float scaleW = mTmpRect.width() / (float) appWidth;
float scaleH = mTmpRect.height() / (float) appHeight;
Animation scale = new ScaleAnimation(scaleW, 1, scaleH, 1,
computePivot(mTmpRect.left, scaleW),
computePivot(mTmpRect.top, scaleH));
scale.setInterpolator(mDecelerateInterpolator);
Animation alpha = new AlphaAnimation(0, 1);
alpha.setInterpolator(mThumbnailFadeOutInterpolator);
AnimationSet set = new AnimationSet(false);
set.addAnimation(scale);
set.addAnimation(alpha);
set.setDetachWallpaper(true);
a = set;
} else if (transit == TRANSIT_OLD_WALLPAPER_INTRA_OPEN
|| transit == TRANSIT_OLD_WALLPAPER_INTRA_CLOSE) {
// If we are on top of the wallpaper, we need an animation that
// correctly handles the wallpaper staying static behind all of
// the animated elements. To do this, will just have the existing
// element fade out.
a = new AlphaAnimation(1, 0);
a.setDetachWallpaper(true);
} else {
// For normal animations, the exiting element just holds in place.
a = new AlphaAnimation(1, 1);
}
// Pick the desired duration. If this is an inter-activity transition,
// it is the standard duration for that. Otherwise we use the longer
// task transition duration.
final long duration;
switch (transit) {
case TRANSIT_OLD_ACTIVITY_OPEN:
case TRANSIT_OLD_ACTIVITY_CLOSE:
duration = mConfigShortAnimTime;
break;
default:
duration = DEFAULT_APP_TRANSITION_DURATION;
break;
}
a.setDuration(duration);
a.setFillAfter(true);
a.setInterpolator(mDecelerateInterpolator);
a.initialize(appWidth, appHeight, appWidth, appHeight);
return a;
}
public Animation createThumbnailEnterExitAnimationLocked(boolean enter, boolean scaleUp,
Rect containingFrame, @TransitionType int transit, int wallpaperTransit,
HardwareBuffer thumbnailHeader, Rect startRect) {
return createThumbnailEnterExitAnimationLockedCompat(enter, scaleUp, containingFrame,
getTransitCompatType(transit, wallpaperTransit), thumbnailHeader, startRect);
}
/**
* This animation is created when we are doing a thumbnail transition, for the activity that is
* leaving, and the activity that is entering.
*/
public Animation createThumbnailEnterExitAnimationLockedCompat(boolean enter, boolean scaleUp,
Rect containingFrame, @TransitionOldType int transit, HardwareBuffer thumbnailHeader,
Rect startRect) {
final int appWidth = containingFrame.width();
final int appHeight = containingFrame.height();
Animation a;
setupDefaultNextAppTransitionStartRect(startRect, mTmpRect);
final int thumbWidthI = thumbnailHeader != null ? thumbnailHeader.getWidth() : appWidth;
final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
final int thumbHeightI = thumbnailHeader != null ? thumbnailHeader.getHeight() : appHeight;
final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
final int thumbTransitState = getThumbnailTransitionState(enter, scaleUp);
switch (thumbTransitState) {
case THUMBNAIL_TRANSITION_ENTER_SCALE_UP: {
// Entering app scales up with the thumbnail
float scaleW = thumbWidth / appWidth;
float scaleH = thumbHeight / appHeight;
a = new ScaleAnimation(scaleW, 1, scaleH, 1,
computePivot(mTmpRect.left, scaleW),
computePivot(mTmpRect.top, scaleH));
break;
}
case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: {
// Exiting app while the thumbnail is scaling up should fade or stay in place
if (transit == TRANSIT_OLD_WALLPAPER_INTRA_OPEN) {
// Fade out while bringing up selected activity. This keeps the
// current activity from showing through a launching wallpaper
// activity.
a = new AlphaAnimation(1, 0);
} else {
// noop animation
a = new AlphaAnimation(1, 1);
}
break;
}
case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: {
// Entering the other app, it should just be visible while we scale the thumbnail
// down above it
a = new AlphaAnimation(1, 1);
break;
}
case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: {
// Exiting the current app, the app should scale down with the thumbnail
float scaleW = thumbWidth / appWidth;
float scaleH = thumbHeight / appHeight;
Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH,
computePivot(mTmpRect.left, scaleW),
computePivot(mTmpRect.top, scaleH));
Animation alpha = new AlphaAnimation(1, 0);
AnimationSet set = new AnimationSet(true);
set.addAnimation(scale);
set.addAnimation(alpha);
set.setZAdjustment(Animation.ZORDER_TOP);
a = set;
break;
}
default:
throw new RuntimeException("Invalid thumbnail transition state");
}
return prepareThumbnailAnimation(a, appWidth, appHeight, transit);
}
/**
* This alternate animation is created when we are doing a thumbnail transition, for the
* activity that is leaving, and the activity that is entering.
*/
public Animation createAspectScaledThumbnailEnterExitAnimationLocked(boolean enter,
boolean scaleUp, int orientation, int transit, Rect containingFrame, Rect contentInsets,
@Nullable Rect surfaceInsets, @Nullable Rect stableInsets, boolean freeform,
Rect startRect, Rect defaultStartRect) {
Animation a;
final int appWidth = containingFrame.width();
final int appHeight = containingFrame.height();
setupDefaultNextAppTransitionStartRect(defaultStartRect, mTmpRect);
final int thumbWidthI = mTmpRect.width();
final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
final int thumbHeightI = mTmpRect.height();
final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
final int thumbStartX = mTmpRect.left - containingFrame.left - contentInsets.left;
final int thumbStartY = mTmpRect.top - containingFrame.top;
final int thumbTransitState = getThumbnailTransitionState(enter, scaleUp);
switch (thumbTransitState) {
case THUMBNAIL_TRANSITION_ENTER_SCALE_UP:
case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: {
if (freeform && scaleUp) {
a = createAspectScaledThumbnailEnterFreeformAnimationLocked(
containingFrame, surfaceInsets, startRect, defaultStartRect);
} else if (freeform) {
a = createAspectScaledThumbnailExitFreeformAnimationLocked(
containingFrame, surfaceInsets, startRect, defaultStartRect);
} else {
AnimationSet set = new AnimationSet(true);
// In portrait, we scale to fit the width
mTmpFromClipRect.set(containingFrame);
mTmpToClipRect.set(containingFrame);
// Containing frame is in screen space, but we need the clip rect in the
// app space.
mTmpFromClipRect.offsetTo(0, 0);
mTmpToClipRect.offsetTo(0, 0);
// Exclude insets region from the source clip.
mTmpFromClipRect.inset(contentInsets);
if (shouldScaleDownThumbnailTransition(orientation)) {
// We scale the width and clip to the top/left square
float scale =
thumbWidth / (appWidth - contentInsets.left - contentInsets.right);
int unscaledThumbHeight = (int) (thumbHeight / scale);
mTmpFromClipRect.bottom = mTmpFromClipRect.top + unscaledThumbHeight;
Animation scaleAnim = new ScaleAnimation(
scaleUp ? scale : 1, scaleUp ? 1 : scale,
scaleUp ? scale : 1, scaleUp ? 1 : scale,
containingFrame.width() / 2f,
containingFrame.height() / 2f + contentInsets.top);
final float targetX = (mTmpRect.left - containingFrame.left);
final float x = containingFrame.width() / 2f
- containingFrame.width() / 2f * scale;
final float targetY = (mTmpRect.top - containingFrame.top);
float y = containingFrame.height() / 2f
- containingFrame.height() / 2f * scale;
// During transition may require clipping offset from any top stable insets
// such as the statusbar height when statusbar is hidden
if (mLowRamRecentsEnabled && contentInsets.top == 0 && scaleUp) {
mTmpFromClipRect.top += stableInsets.top;
y += stableInsets.top;
}
final float startX = targetX - x;
final float startY = targetY - y;
Animation clipAnim = scaleUp
? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect)
: new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect);
Animation translateAnim = scaleUp
? createCurvedMotion(startX, 0, startY - contentInsets.top, 0)
: createCurvedMotion(0, startX, 0, startY - contentInsets.top);
set.addAnimation(clipAnim);
set.addAnimation(scaleAnim);
set.addAnimation(translateAnim);
} else {
// In landscape, we don't scale at all and only crop
mTmpFromClipRect.bottom = mTmpFromClipRect.top + thumbHeightI;
mTmpFromClipRect.right = mTmpFromClipRect.left + thumbWidthI;
Animation clipAnim = scaleUp
? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect)
: new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect);
Animation translateAnim = scaleUp
? createCurvedMotion(thumbStartX, 0,
thumbStartY - contentInsets.top, 0)
: createCurvedMotion(0, thumbStartX, 0,
thumbStartY - contentInsets.top);
set.addAnimation(clipAnim);
set.addAnimation(translateAnim);
}
a = set;
a.setZAdjustment(Animation.ZORDER_TOP);
}
break;
}
case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: {
// Previous app window during the scale up
if (transit == TRANSIT_OLD_WALLPAPER_INTRA_OPEN) {
// Fade out the source activity if we are animating to a wallpaper
// activity.
a = new AlphaAnimation(1, 0);
} else {
a = new AlphaAnimation(1, 1);
}
break;
}
case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: {
// Target app window during the scale down
if (transit == TRANSIT_OLD_WALLPAPER_INTRA_OPEN) {
// Fade in the destination activity if we are animating from a wallpaper
// activity.
a = new AlphaAnimation(0, 1);
} else {
a = new AlphaAnimation(1, 1);
}
break;
}
default:
throw new RuntimeException("Invalid thumbnail transition state");
}
return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight,
THUMBNAIL_APP_TRANSITION_DURATION, mTouchResponseInterpolator);
}
/**
* This animation runs for the thumbnail that gets cross faded with the enter/exit activity
* when a thumbnail is specified with the pending animation override.
*/
public Animation createThumbnailAspectScaleAnimationLocked(Rect appRect,
@Nullable Rect contentInsets, HardwareBuffer thumbnailHeader, int orientation,
Rect startRect, Rect defaultStartRect, boolean scaleUp) {
Animation a;
final int thumbWidthI = thumbnailHeader.getWidth();
final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
final int thumbHeightI = thumbnailHeader.getHeight();
final int appWidth = appRect.width();
float scaleW = appWidth / thumbWidth;
getNextAppTransitionStartRect(startRect, defaultStartRect, mTmpRect);
final float fromX;
float fromY;
final float toX;
float toY;
final float pivotX;
final float pivotY;
if (shouldScaleDownThumbnailTransition(orientation)) {
fromX = mTmpRect.left;
fromY = mTmpRect.top;
// For the curved translate animation to work, the pivot points needs to be at the
// same absolute position as the one from the real surface.
toX = mTmpRect.width() / 2 * (scaleW - 1f) + appRect.left;
toY = appRect.height() / 2 * (1 - 1 / scaleW) + appRect.top;
pivotX = mTmpRect.width() / 2;
pivotY = appRect.height() / 2 / scaleW;
} else {
pivotX = 0;
pivotY = 0;
fromX = mTmpRect.left;
fromY = mTmpRect.top;
toX = appRect.left;
toY = appRect.top;
}
if (scaleUp) {
// Animation up from the thumbnail to the full screen
Animation scale = new ScaleAnimation(1f, scaleW, 1f, scaleW, pivotX, pivotY);
scale.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
scale.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
Animation alpha = new AlphaAnimation(1f, 0f);
alpha.setInterpolator(mThumbnailFadeOutInterpolator);
alpha.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
Animation translate = createCurvedMotion(fromX, toX, fromY, toY);
translate.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
translate.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
mTmpFromClipRect.set(0, 0, thumbWidthI, thumbHeightI);
mTmpToClipRect.set(appRect);
// Containing frame is in screen space, but we need the clip rect in the
// app space.
mTmpToClipRect.offsetTo(0, 0);
mTmpToClipRect.right = (int) (mTmpToClipRect.right / scaleW);
mTmpToClipRect.bottom = (int) (mTmpToClipRect.bottom / scaleW);
if (contentInsets != null) {
mTmpToClipRect.inset((int) (-contentInsets.left * scaleW),
(int) (-contentInsets.top * scaleW),
(int) (-contentInsets.right * scaleW),
(int) (-contentInsets.bottom * scaleW));
}
Animation clipAnim = new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect);
clipAnim.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
clipAnim.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
// This AnimationSet uses the Interpolators assigned above.
AnimationSet set = new AnimationSet(false);
set.addAnimation(scale);
set.addAnimation(alpha);
set.addAnimation(translate);
set.addAnimation(clipAnim);
a = set;
} else {
// Animation down from the full screen to the thumbnail
Animation scale = new ScaleAnimation(scaleW, 1f, scaleW, 1f, pivotX, pivotY);
scale.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
scale.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
Animation alpha = new AlphaAnimation(0f, 1f);
alpha.setInterpolator(mThumbnailFadeInInterpolator);
alpha.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
Animation translate = createCurvedMotion(toX, fromX, toY, fromY);
translate.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
translate.setDuration(THUMBNAIL_APP_TRANSITION_DURATION);
// This AnimationSet uses the Interpolators assigned above.
AnimationSet set = new AnimationSet(false);
set.addAnimation(scale);
set.addAnimation(alpha);
set.addAnimation(translate);
a = set;
}
return prepareThumbnailAnimationWithDuration(a, appWidth, appRect.height(), 0,
null);
}
/**
* Creates an overlay with a background color and a thumbnail for the cross profile apps
* animation.
*/
public HardwareBuffer createCrossProfileAppsThumbnail(
Drawable thumbnailDrawable, Rect frame) {
final int width = frame.width();
final int height = frame.height();
final Picture picture = new Picture();
final Canvas canvas = picture.beginRecording(width, height);
canvas.drawColor(Color.argb(0.6f, 0, 0, 0));
final int thumbnailSize = mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.cross_profile_apps_thumbnail_size);
thumbnailDrawable.setBounds(
(width - thumbnailSize) / 2,
(height - thumbnailSize) / 2,
(width + thumbnailSize) / 2,
(height + thumbnailSize) / 2);
thumbnailDrawable.setTint(mContext.getColor(android.R.color.white));
thumbnailDrawable.draw(canvas);
picture.endRecording();
return Bitmap.createBitmap(picture).getHardwareBuffer();
}
/**
* Prepares the specified animation with a standard duration, interpolator, etc.
*/
private Animation prepareThumbnailAnimation(Animation a, int appWidth, int appHeight,
@TransitionOldType int transit) {
// Pick the desired duration. If this is an inter-activity transition,
// it is the standard duration for that. Otherwise we use the longer
// task transition duration.
final int duration;
switch (transit) {
case TRANSIT_OLD_ACTIVITY_OPEN:
case TRANSIT_OLD_ACTIVITY_CLOSE:
duration = mConfigShortAnimTime;
break;
default:
duration = DEFAULT_APP_TRANSITION_DURATION;
break;
}
return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight, duration,
mDecelerateInterpolator);
}
private Animation createAspectScaledThumbnailEnterFreeformAnimationLocked(Rect frame,
@Nullable Rect surfaceInsets, @Nullable Rect startRect,
@Nullable Rect defaultStartRect) {
getNextAppTransitionStartRect(startRect, defaultStartRect, mTmpRect);
return createAspectScaledThumbnailFreeformAnimationLocked(mTmpRect, frame, surfaceInsets,
true);
}
private Animation createAspectScaledThumbnailExitFreeformAnimationLocked(Rect frame,
@Nullable Rect surfaceInsets, @Nullable Rect startRect,
@Nullable Rect defaultStartRect) {
getNextAppTransitionStartRect(startRect, defaultStartRect, mTmpRect);
return createAspectScaledThumbnailFreeformAnimationLocked(frame, mTmpRect, surfaceInsets,
false);
}
private void getNextAppTransitionStartRect(Rect startRect, Rect defaultStartRect, Rect rect) {
if (startRect == null && defaultStartRect == null) {
Slog.e(mTag, "Starting rect for container not available", new Throwable());
rect.setEmpty();
} else {
rect.set(startRect != null ? startRect : defaultStartRect);
}
}
private AnimationSet createAspectScaledThumbnailFreeformAnimationLocked(Rect sourceFrame,
Rect destFrame, @Nullable Rect surfaceInsets, boolean enter) {
final float sourceWidth = sourceFrame.width();
final float sourceHeight = sourceFrame.height();
final float destWidth = destFrame.width();
final float destHeight = destFrame.height();
final float scaleH = enter ? sourceWidth / destWidth : destWidth / sourceWidth;
final float scaleV = enter ? sourceHeight / destHeight : destHeight / sourceHeight;
AnimationSet set = new AnimationSet(true);
final int surfaceInsetsH = surfaceInsets == null
? 0 : surfaceInsets.left + surfaceInsets.right;
final int surfaceInsetsV = surfaceInsets == null
? 0 : surfaceInsets.top + surfaceInsets.bottom;
// We want the scaling to happen from the center of the surface. In order to achieve that,
// we need to account for surface insets that will be used to enlarge the surface.
final float scaleHCenter = ((enter ? destWidth : sourceWidth) + surfaceInsetsH) / 2;
final float scaleVCenter = ((enter ? destHeight : sourceHeight) + surfaceInsetsV) / 2;
final ScaleAnimation scale = enter
? new ScaleAnimation(scaleH, 1, scaleV, 1, scaleHCenter, scaleVCenter)
: new ScaleAnimation(1, scaleH, 1, scaleV, scaleHCenter, scaleVCenter);
final int sourceHCenter = sourceFrame.left + sourceFrame.width() / 2;
final int sourceVCenter = sourceFrame.top + sourceFrame.height() / 2;
final int destHCenter = destFrame.left + destFrame.width() / 2;
final int destVCenter = destFrame.top + destFrame.height() / 2;
final int fromX = enter ? sourceHCenter - destHCenter : destHCenter - sourceHCenter;
final int fromY = enter ? sourceVCenter - destVCenter : destVCenter - sourceVCenter;
final TranslateAnimation translation = enter ? new TranslateAnimation(fromX, 0, fromY, 0)
: new TranslateAnimation(0, fromX, 0, fromY);
set.addAnimation(scale);
set.addAnimation(translation);
return set;
}
/**
* @return whether the transition should show the thumbnail being scaled down.
*/
private boolean shouldScaleDownThumbnailTransition(int orientation) {
return orientation == Configuration.ORIENTATION_PORTRAIT;
}
private static int updateToTranslucentAnimIfNeeded(int anim, @TransitionOldType int transit) {
if (transit == TRANSIT_OLD_TRANSLUCENT_ACTIVITY_OPEN
&& anim == R.anim.activity_open_enter) {
return R.anim.activity_translucent_open_enter;
}
if (transit == TRANSIT_OLD_TRANSLUCENT_ACTIVITY_CLOSE
&& anim == R.anim.activity_close_exit) {
return R.anim.activity_translucent_close_exit;
}
return anim;
}
private static int updateToTranslucentAnimIfNeeded(int anim) {
if (anim == R.anim.activity_open_enter) {
return R.anim.activity_translucent_open_enter;
}
if (anim == R.anim.activity_close_exit) {
return R.anim.activity_translucent_close_exit;
}
return anim;
}
private static @TransitionOldType int getTransitCompatType(@TransitionType int transit,
int wallpaperTransit) {
if (wallpaperTransit == WALLPAPER_TRANSITION_INTRA_OPEN) {
return TRANSIT_OLD_WALLPAPER_INTRA_OPEN;
} else if (wallpaperTransit == WALLPAPER_TRANSITION_INTRA_CLOSE) {
return TRANSIT_OLD_WALLPAPER_INTRA_CLOSE;
} else if (transit == TRANSIT_OPEN) {
return TRANSIT_OLD_ACTIVITY_OPEN;
} else if (transit == TRANSIT_CLOSE) {
return TRANSIT_OLD_ACTIVITY_CLOSE;
}
// We only do some special handle for above type, so use type NONE for default behavior.
return TRANSIT_OLD_NONE;
}
/**
* Calculates the duration for the clip reveal animation. If the clip is "cut off", meaning that
* the start rect is outside of the target rect, and there is a lot of movement going on.
*
* @param cutOff whether the start rect was not fully contained by the end rect
* @param translationX the total translation the surface moves in x direction
* @param translationY the total translation the surfaces moves in y direction
* @param displayFrame our display frame
*
* @return the duration of the clip reveal animation, in milliseconds
*/
private static long calculateClipRevealTransitionDuration(boolean cutOff, float translationX,
float translationY, Rect displayFrame) {
if (!cutOff) {
return DEFAULT_APP_TRANSITION_DURATION;
}
final float fraction = Math.max(Math.abs(translationX) / displayFrame.width(),
Math.abs(translationY) / displayFrame.height());
return (long) (DEFAULT_APP_TRANSITION_DURATION + fraction
* (MAX_CLIP_REVEAL_TRANSITION_DURATION - DEFAULT_APP_TRANSITION_DURATION));
}
/**
* Return the current thumbnail transition state.
*/
private int getThumbnailTransitionState(boolean enter, boolean scaleUp) {
if (enter) {
if (scaleUp) {
return THUMBNAIL_TRANSITION_ENTER_SCALE_UP;
} else {
return THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN;
}
} else {
if (scaleUp) {
return THUMBNAIL_TRANSITION_EXIT_SCALE_UP;
} else {
return THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN;
}
}
}
/**
* Prepares the specified animation with a standard duration, interpolator, etc.
*/
public static Animation prepareThumbnailAnimationWithDuration(Animation a, int appWidth,
int appHeight, long duration, Interpolator interpolator) {
if (a == null) {
return null;
}
if (duration > 0) {
a.setDuration(duration);
}
a.setFillAfter(true);
if (interpolator != null) {
a.setInterpolator(interpolator);
}
a.initialize(appWidth, appHeight, appWidth, appHeight);
return a;
}
private static Animation createCurvedMotion(float fromX, float toX, float fromY, float toY) {
return new TranslateAnimation(fromX, toX, fromY, toY);
}
/**
* Compute the pivot point for an animation that is scaling from a small
* rect on screen to a larger rect. The pivot point varies depending on
* the distance between the inner and outer edges on both sides. This
* function computes the pivot point for one dimension.
* @param startPos Offset from left/top edge of outer rectangle to
* left/top edge of inner rectangle.
* @param finalScale The scaling factor between the size of the outer
* and inner rectangles.
*/
public static float computePivot(int startPos, float finalScale) {
/*
Theorem of intercepting lines:
+ + +-----------------------------------------------+
| | | |
| | | |
| | | |
| | | |
x | y | | |
| | | |
| | | |
| | | |
| | | |
| + | +--------------------+ |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | +--------------------+ |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| +-----------------------------------------------+
|
|
|
|
|
|
|
|
|
+ ++
p ++
scale = (x - y) / x
<=> x = -y / (scale - 1)
*/
final float denom = finalScale - 1;
if (Math.abs(denom) < .0001f) {
return startPos;
}
return -startPos / denom;
}
@Nullable
public static Animation loadAnimationSafely(Context context, int resId, String tag) {
try {
return AnimationUtils.loadAnimation(context, resId);
} catch (Resources.NotFoundException | InflateException e) {
Slog.w(tag, "Unable to load animation resource", e);
return null;
}
}
public static Animation createHiddenByKeyguardExit(Context context,
LogDecelerateInterpolator interpolator, boolean onWallpaper,
boolean goingToNotificationShade, boolean subtleAnimation) {
if (goingToNotificationShade) {
return AnimationUtils.loadAnimation(context, R.anim.lock_screen_behind_enter_fade_in);
}
final int resource;
if (subtleAnimation) {
resource = R.anim.lock_screen_behind_enter_subtle;
} else if (onWallpaper) {
resource = R.anim.lock_screen_behind_enter_wallpaper;
} else {
resource = R.anim.lock_screen_behind_enter;
}
AnimationSet set = (AnimationSet) AnimationUtils.loadAnimation(context, resource);
// TODO: Use XML interpolators when we have log interpolators available in XML.
final List<Animation> animations = set.getAnimations();
for (int i = animations.size() - 1; i >= 0; --i) {
animations.get(i).setInterpolator(interpolator);
}
return set;
}
/** Sets the default attributes of the screenshot layer used for animation. */
public static void configureScreenshotLayer(SurfaceControl.Transaction t, SurfaceControl layer,
ScreenCapture.ScreenshotHardwareBuffer buffer) {
t.setBuffer(layer, buffer.getHardwareBuffer());
t.setDataSpace(layer, buffer.getColorSpace().getDataSpace());
// Avoid showing dimming effect for HDR content when running animations.
if (buffer.containsHdrLayers()) {
t.setDimmingEnabled(layer, false);
}
}
/** Returns whether the hardware buffer passed in is marked as protected. */
public static boolean hasProtectedContent(HardwareBuffer hardwareBuffer) {
return (hardwareBuffer.getUsage() & HardwareBuffer.USAGE_PROTECTED_CONTENT)
== HardwareBuffer.USAGE_PROTECTED_CONTENT;
}
/** Returns the luminance in 0~1. */
public static float getBorderLuma(SurfaceControl surfaceControl, int w, int h) {
final ScreenCapture.ScreenshotHardwareBuffer buffer =
ScreenCapture.captureLayers(surfaceControl, new Rect(0, 0, w, h), 1);
if (buffer == null) {
return 0;
}
final HardwareBuffer hwBuffer = buffer.getHardwareBuffer();
final float luma = getBorderLuma(hwBuffer, buffer.getColorSpace());
if (hwBuffer != null) {
hwBuffer.close();
}
return luma;
}
/** Returns the luminance in 0~1. */
public static float getBorderLuma(HardwareBuffer hwBuffer, ColorSpace colorSpace) {
if (hwBuffer == null) {
return 0;
}
final int format = hwBuffer.getFormat();
// Only support RGB format in 4 bytes. And protected buffer is not readable.
if (format != HardwareBuffer.RGBA_8888 || hasProtectedContent(hwBuffer)) {
return 0;
}
final ImageReader ir = ImageReader.newInstance(hwBuffer.getWidth(), hwBuffer.getHeight(),
format, 1 /* maxImages */);
ir.getSurface().attachAndQueueBufferWithColorSpace(hwBuffer, colorSpace);
final Image image = ir.acquireLatestImage();
if (image == null || image.getPlaneCount() < 1) {
return 0;
}
final Image.Plane plane = image.getPlanes()[0];
final ByteBuffer buffer = plane.getBuffer();
final int width = image.getWidth();
final int height = image.getHeight();
final int pixelStride = plane.getPixelStride();
final int rowStride = plane.getRowStride();
final int sampling = 10;
final int[] histogram = new int[256];
// Grab the top and bottom borders.
int i = 0;
for (int x = 0, size = width - sampling; x < size; x += sampling) {
final int topLm = getPixelLuminance(buffer, x, 0, pixelStride, rowStride);
final int bottomLm = getPixelLuminance(buffer, x, height - 1, pixelStride, rowStride);
histogram[topLm]++;
histogram[bottomLm]++;
}
// Grab the left and right borders.
for (int y = 0, size = height - sampling; y < size; y += sampling) {
final int leftLm = getPixelLuminance(buffer, 0, y, pixelStride, rowStride);
final int rightLm = getPixelLuminance(buffer, width - 1, y, pixelStride, rowStride);
histogram[leftLm]++;
histogram[rightLm]++;
}
ir.close();
// Find the median from histogram.
final int halfNum = (width + height) / sampling;
int sum = 0;
int medianLuminance = 0;
for (i = 0; i < histogram.length; i++) {
sum += histogram[i];
if (sum >= halfNum) {
medianLuminance = i;
break;
}
}
return medianLuminance / 255f;
}
/** Returns the luminance of the pixel in 0~255. */
private static int getPixelLuminance(ByteBuffer buffer, int x, int y, int pixelStride,
int rowStride) {
final int color = buffer.getInt(y * rowStride + x * pixelStride);
// The buffer from ImageReader is always in native order (little-endian), so extract the
// color components in reversed order.
final int r = color & 0xff;
final int g = (color >> 8) & 0xff;
final int b = (color >> 16) & 0xff;
// Approximation of WCAG 2.0 relative luminance.
return ((r * 8) + (g * 22) + (b * 2)) >> 5;
}
/**
* For non-system server process, it must call this method to initialize the AttributeCache and
* start monitor package change, so the resources can be loaded correctly.
*/
public static void initAttributeCache(Context context, Handler handler) {
AttributeCache.init(context);
AttributeCache.instance().monitorPackageRemove(handler);
}
}
Reference in New Issue Copy Permalink