Java tutorial
/* * Copyright (C) 2014 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.support.v17.leanback.app; import java.lang.ref.WeakReference; import android.support.annotation.ColorInt; import android.graphics.PixelFormat; import android.graphics.PorterDuff; import android.graphics.PorterDuffColorFilter; import android.support.v17.leanback.R; import android.animation.Animator; import android.animation.ValueAnimator; import android.app.Activity; import android.content.Context; 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.ColorFilter; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable; import android.graphics.drawable.LayerDrawable; import android.os.Handler; import android.support.v17.leanback.widget.BackgroundHelper; import android.support.v4.view.animation.FastOutLinearInInterpolator; import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.view.Window; import android.view.WindowManager; import android.view.animation.Interpolator; import android.view.animation.AnimationUtils; import android.support.v4.app.FragmentActivity; import android.support.v4.content.ContextCompat; /** * Supports background image continuity between multiple Activities. * * <p>An Activity should instantiate a BackgroundManager and {@link #attach} * to the Activity's window. When the Activity is started, the background is * initialized to the current background values stored in a continuity service. * The background continuity service is updated as the background is updated. * * <p>At some point, for example when it is stopped, the Activity may release * its background state. * * <p>When an Activity is resumed, if the BackgroundManager has not been * released, the continuity service is updated from the BackgroundManager state. * If the BackgroundManager was released, the BackgroundManager inherits the * current state from the continuity service. * * <p>When the last Activity is destroyed, the background state is reset. * * <p>Backgrounds consist of several layers, from back to front: * <ul> * <li>the background Drawable of the theme</li> * <li>a solid color (set via {@link #setColor})</li> * <li>two Drawables, previous and current (set via {@link #setBitmap} or * {@link #setDrawable}), which may be in transition</li> * </ul> * * <p>BackgroundManager holds references to potentially large bitmap Drawables. * Call {@link #release} to release these references when the Activity is not * visible. */ // TODO: support for multiple app processes requires a proper android service // instead of the shared memory "service" implemented here. Such a service could // support continuity between fragments of different applications if desired. public final class BackgroundManager { interface FragmentStateQueriable { public boolean isResumed(); } private static final String TAG = "BackgroundManager"; private static final boolean DEBUG = false; private static final int FULL_ALPHA = 255; private static final int DIM_ALPHA_ON_SOLID = (int) (0.8f * FULL_ALPHA); private static final int CHANGE_BG_DELAY_MS = 500; private static final int FADE_DURATION = 500; /** * Using a separate window for backgrounds can improve graphics performance by * leveraging hardware display layers. * TODO: support a leanback configuration option. */ private static final boolean USE_SEPARATE_WINDOW = false; private static final String WINDOW_NAME = "BackgroundManager"; private static final String FRAGMENT_TAG = BackgroundManager.class.getCanonicalName(); private Context mContext; private Handler mHandler; private Window mWindow; private WindowManager mWindowManager; private View mBgView; private BackgroundContinuityService mService; private int mThemeDrawableResourceId; private FragmentStateQueriable mFragmentState; private int mHeightPx; private int mWidthPx; private Drawable mBackgroundDrawable; private int mBackgroundColor; private boolean mAttached; private long mLastSetTime; private final Interpolator mAccelerateInterpolator; private final Interpolator mDecelerateInterpolator; private final ValueAnimator mAnimator; private final ValueAnimator mDimAnimator; private static class BitmapDrawable extends Drawable { static class ConstantState extends Drawable.ConstantState { Bitmap mBitmap; Matrix mMatrix; Paint mPaint; @Override public Drawable newDrawable() { return new BitmapDrawable(null, mBitmap, mMatrix); } @Override public int getChangingConfigurations() { return 0; } } private ConstantState mState = new ConstantState(); BitmapDrawable(Resources resources, Bitmap bitmap) { this(resources, bitmap, null); } BitmapDrawable(Resources resources, Bitmap bitmap, Matrix matrix) { mState.mBitmap = bitmap; mState.mMatrix = matrix != null ? matrix : new Matrix(); mState.mPaint = new Paint(); mState.mPaint.setFilterBitmap(true); } Bitmap getBitmap() { return mState.mBitmap; } @Override public void draw(Canvas canvas) { if (mState.mBitmap == null) { return; } if (mState.mPaint.getAlpha() < FULL_ALPHA && mState.mPaint.getColorFilter() != null) { throw new IllegalStateException("Can't draw with translucent alpha and color filter"); } canvas.drawBitmap(mState.mBitmap, mState.mMatrix, mState.mPaint); } @Override public int getOpacity() { return android.graphics.PixelFormat.TRANSLUCENT; } @Override public void setAlpha(int alpha) { if (mState.mPaint.getAlpha() != alpha) { mState.mPaint.setAlpha(alpha); invalidateSelf(); } } /** * Does not invalidateSelf to avoid recursion issues. * Caller must ensure appropriate invalidation. */ @Override public void setColorFilter(ColorFilter cf) { mState.mPaint.setColorFilter(cf); } public ColorFilter getColorFilter() { return mState.mPaint.getColorFilter(); } @Override public ConstantState getConstantState() { return mState; } } private static class DrawableWrapper { private int mAlpha = FULL_ALPHA; private Drawable mDrawable; private ColorFilter mColorFilter; public DrawableWrapper(Drawable drawable) { mDrawable = drawable; updateAlpha(); updateColorFilter(); } public DrawableWrapper(DrawableWrapper wrapper, Drawable drawable) { mDrawable = drawable; mAlpha = wrapper.getAlpha(); updateAlpha(); mColorFilter = wrapper.getColorFilter(); updateColorFilter(); } public Drawable getDrawable() { return mDrawable; } public void setAlpha(int alpha) { mAlpha = alpha; updateAlpha(); } public int getAlpha() { return mAlpha; } private void updateAlpha() { mDrawable.setAlpha(mAlpha); } public ColorFilter getColorFilter() { return mColorFilter; } public void setColorFilter(ColorFilter colorFilter) { mColorFilter = colorFilter; updateColorFilter(); } private void updateColorFilter() { mDrawable.setColorFilter(mColorFilter); } public void setColor(int color) { ((ColorDrawable) mDrawable).setColor(color); } } static class TranslucentLayerDrawable extends LayerDrawable { private DrawableWrapper[] mWrapper; private Paint mPaint = new Paint(); public TranslucentLayerDrawable(Drawable[] drawables) { super(drawables); int count = drawables.length; mWrapper = new DrawableWrapper[count]; for (int i = 0; i < count; i++) { mWrapper[i] = new DrawableWrapper(drawables[i]); } } @Override public void setAlpha(int alpha) { if (mPaint.getAlpha() != alpha) { int previousAlpha = mPaint.getAlpha(); mPaint.setAlpha(alpha); invalidateSelf(); onAlphaChanged(previousAlpha, alpha); } } // Queried by system transitions public int getAlpha() { return mPaint.getAlpha(); } protected void onAlphaChanged(int oldAlpha, int newAlpha) { } @Override public Drawable mutate() { Drawable drawable = super.mutate(); int count = getNumberOfLayers(); for (int i = 0; i < count; i++) { if (mWrapper[i] != null) { mWrapper[i] = new DrawableWrapper(mWrapper[i], getDrawable(i)); } } invalidateSelf(); return drawable; } @Override public int getOpacity() { return PixelFormat.TRANSLUCENT; } @Override public boolean setDrawableByLayerId(int id, Drawable drawable) { return updateDrawable(id, drawable) != null; } public DrawableWrapper updateDrawable(int id, Drawable drawable) { super.setDrawableByLayerId(id, drawable); for (int i = 0; i < getNumberOfLayers(); i++) { if (getId(i) == id) { mWrapper[i] = new DrawableWrapper(drawable); // Must come after mWrapper was updated so it can be seen by updateColorFilter invalidateSelf(); return mWrapper[i]; } } return null; } public void clearDrawable(int id, Context context) { for (int i = 0; i < getNumberOfLayers(); i++) { if (getId(i) == id) { mWrapper[i] = null; super.setDrawableByLayerId(id, createEmptyDrawable(context)); break; } } } public DrawableWrapper findWrapperById(int id) { for (int i = 0; i < getNumberOfLayers(); i++) { if (getId(i) == id) { return mWrapper[i]; } } return null; } @Override public void draw(Canvas canvas) { if (mPaint.getAlpha() < FULL_ALPHA) { canvas.saveLayer(0, 0, canvas.getWidth(), canvas.getHeight(), mPaint, Canvas.ALL_SAVE_FLAG); } super.draw(canvas); if (mPaint.getAlpha() < FULL_ALPHA) { canvas.restore(); } } } /** * Optimizes drawing when the dim drawable is an alpha-only color and imagein is opaque. * When the layer drawable is translucent (activity transition) then we can avoid the slow * saveLayer/restore draw path. */ private class OptimizedTranslucentLayerDrawable extends TranslucentLayerDrawable { private PorterDuffColorFilter mColorFilter; private boolean mUpdatingColorFilter; public OptimizedTranslucentLayerDrawable(Drawable[] drawables) { super(drawables); } @Override protected void onAlphaChanged(int oldAlpha, int newAlpha) { if (newAlpha == FULL_ALPHA && oldAlpha < FULL_ALPHA) { if (DEBUG) Log.v(TAG, "transition complete"); postChangeRunnable(); } } @Override public void invalidateSelf() { super.invalidateSelf(); updateColorFilter(); } @Override public void invalidateDrawable(Drawable who) { if (!mUpdatingColorFilter) { invalidateSelf(); } } private void updateColorFilter() { DrawableWrapper dimWrapper = findWrapperById(R.id.background_dim); DrawableWrapper imageInWrapper = findWrapperById(R.id.background_imagein); DrawableWrapper imageOutWrapper = findWrapperById(R.id.background_imageout); mColorFilter = null; if (imageInWrapper != null && imageInWrapper.getAlpha() == FULL_ALPHA && dimWrapper.getDrawable() instanceof ColorDrawable) { int dimColor = ((ColorDrawable) dimWrapper.getDrawable()).getColor(); if (Color.red(dimColor) == 0 && Color.green(dimColor) == 0 && Color.blue(dimColor) == 0) { int dimAlpha = 255 - Color.alpha(dimColor); int color = Color.argb(getAlpha(), dimAlpha, dimAlpha, dimAlpha); mColorFilter = new PorterDuffColorFilter(color, PorterDuff.Mode.MULTIPLY); } } mUpdatingColorFilter = true; if (imageInWrapper != null) { imageInWrapper.setColorFilter(mColorFilter); } if (imageOutWrapper != null) { imageOutWrapper.setColorFilter(null); } mUpdatingColorFilter = false; } @Override public void draw(Canvas canvas) { DrawableWrapper imageInWrapper = findWrapperById(R.id.background_imagein); if (imageInWrapper != null && imageInWrapper.getDrawable() != null && imageInWrapper.getColorFilter() != null) { imageInWrapper.getDrawable().draw(canvas); } else { super.draw(canvas); } } } private TranslucentLayerDrawable createOptimizedTranslucentLayerDrawable(LayerDrawable layerDrawable) { int numChildren = layerDrawable.getNumberOfLayers(); Drawable[] drawables = new Drawable[numChildren]; for (int i = 0; i < numChildren; i++) { drawables[i] = layerDrawable.getDrawable(i); } TranslucentLayerDrawable result = new OptimizedTranslucentLayerDrawable(drawables); for (int i = 0; i < numChildren; i++) { result.setId(i, layerDrawable.getId(i)); } return result; } private TranslucentLayerDrawable mLayerDrawable; private Drawable mDimDrawable; private ChangeBackgroundRunnable mChangeRunnable; private boolean mChangeRunnablePending; private final Animator.AnimatorListener mAnimationListener = new Animator.AnimatorListener() { final Runnable mRunnable = new Runnable() { @Override public void run() { postChangeRunnable(); } }; @Override public void onAnimationStart(Animator animation) { } @Override public void onAnimationRepeat(Animator animation) { } @Override public void onAnimationEnd(Animator animation) { if (mLayerDrawable != null) { mLayerDrawable.clearDrawable(R.id.background_imageout, mContext); } mHandler.post(mRunnable); } @Override public void onAnimationCancel(Animator animation) { } }; private final ValueAnimator.AnimatorUpdateListener mAnimationUpdateListener = new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator animation) { int fadeInAlpha = (Integer) animation.getAnimatedValue(); DrawableWrapper imageInWrapper = getImageInWrapper(); if (imageInWrapper != null) { imageInWrapper.setAlpha(fadeInAlpha); } else { DrawableWrapper imageOutWrapper = getImageOutWrapper(); if (imageOutWrapper != null) { imageOutWrapper.setAlpha(255 - fadeInAlpha); } } } }; private final ValueAnimator.AnimatorUpdateListener mDimUpdateListener = new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator animation) { DrawableWrapper dimWrapper = getDimWrapper(); if (dimWrapper != null) { dimWrapper.setAlpha((Integer) animation.getAnimatedValue()); } } }; /** * Shared memory continuity service. */ private static class BackgroundContinuityService { private static final String TAG = "BackgroundContinuityService"; private static boolean DEBUG = BackgroundManager.DEBUG; private static BackgroundContinuityService sService = new BackgroundContinuityService(); private int mColor; private Drawable mDrawable; private int mCount; /** Single cache of theme drawable */ private int mLastThemeDrawableId; private WeakReference<Drawable.ConstantState> mLastThemeDrawableState; private BackgroundContinuityService() { reset(); } private void reset() { mColor = Color.TRANSPARENT; mDrawable = null; } public static BackgroundContinuityService getInstance() { final int count = sService.mCount++; if (DEBUG) Log.v(TAG, "Returning instance with new count " + count); return sService; } public void unref() { if (mCount <= 0) throw new IllegalStateException("Can't unref, count " + mCount); if (--mCount == 0) { if (DEBUG) Log.v(TAG, "mCount is zero, resetting"); reset(); } } public int getColor() { return mColor; } public Drawable getDrawable() { return mDrawable; } public void setColor(int color) { mColor = color; } public void setDrawable(Drawable drawable) { mDrawable = drawable; } public Drawable getThemeDrawable(Context context, int themeDrawableId) { Drawable drawable = null; if (mLastThemeDrawableState != null && mLastThemeDrawableId == themeDrawableId) { Drawable.ConstantState drawableState = mLastThemeDrawableState.get(); if (DEBUG) Log.v(TAG, "got cached theme drawable state " + drawableState); if (drawableState != null) { drawable = drawableState.newDrawable(); } } if (drawable == null) { drawable = ContextCompat.getDrawable(context, themeDrawableId); if (DEBUG) Log.v(TAG, "loaded theme drawable " + drawable); mLastThemeDrawableState = new WeakReference<Drawable.ConstantState>(drawable.getConstantState()); mLastThemeDrawableId = themeDrawableId; } // No mutate required because this drawable is never manipulated. return drawable; } } private Drawable getThemeDrawable() { Drawable drawable = null; if (mThemeDrawableResourceId != -1) { drawable = mService.getThemeDrawable(mContext, mThemeDrawableResourceId); } if (drawable == null) { drawable = createEmptyDrawable(mContext); } return drawable; } /** * Returns the BackgroundManager associated with the given Activity. * <p> * The BackgroundManager will be created on-demand for each individual * Activity. Subsequent calls will return the same BackgroundManager created * for this Activity. */ public static BackgroundManager getInstance(Activity activity) { if (activity instanceof FragmentActivity) { return getSupportInstance((FragmentActivity) activity); } BackgroundFragment fragment = (BackgroundFragment) activity.getFragmentManager() .findFragmentByTag(FRAGMENT_TAG); if (fragment != null) { BackgroundManager manager = fragment.getBackgroundManager(); if (manager != null) { return manager; } // manager is null: this is a fragment restored by FragmentManager, // fall through to create a BackgroundManager attach to it. } return new BackgroundManager(activity, false); } private static BackgroundManager getSupportInstance(FragmentActivity activity) { BackgroundSupportFragment fragment = (BackgroundSupportFragment) activity.getSupportFragmentManager() .findFragmentByTag(FRAGMENT_TAG); if (fragment != null) { BackgroundManager manager = fragment.getBackgroundManager(); if (manager != null) { return manager; } // manager is null: this is a fragment restored by FragmentManager, // fall through to create a BackgroundManager attach to it. } return new BackgroundManager(activity, true); } private BackgroundManager(Activity activity, boolean isSupportFragmentActivity) { mContext = activity; mService = BackgroundContinuityService.getInstance(); mHeightPx = mContext.getResources().getDisplayMetrics().heightPixels; mWidthPx = mContext.getResources().getDisplayMetrics().widthPixels; mHandler = new Handler(); Interpolator defaultInterpolator = new FastOutLinearInInterpolator(); mAccelerateInterpolator = AnimationUtils.loadInterpolator(mContext, android.R.anim.accelerate_interpolator); mDecelerateInterpolator = AnimationUtils.loadInterpolator(mContext, android.R.anim.decelerate_interpolator); mAnimator = ValueAnimator.ofInt(0, FULL_ALPHA); mAnimator.addListener(mAnimationListener); mAnimator.addUpdateListener(mAnimationUpdateListener); mAnimator.setInterpolator(defaultInterpolator); mDimAnimator = new ValueAnimator(); mDimAnimator.addUpdateListener(mDimUpdateListener); TypedArray ta = activity.getTheme().obtainStyledAttributes(new int[] { android.R.attr.windowBackground }); mThemeDrawableResourceId = ta.getResourceId(0, -1); if (mThemeDrawableResourceId < 0) { if (DEBUG) Log.v(TAG, "BackgroundManager no window background resource!"); } ta.recycle(); if (isSupportFragmentActivity) { createSupportFragment((FragmentActivity) activity); } else { createFragment(activity); } } private void createFragment(Activity activity) { // Use a fragment to ensure the background manager gets detached properly. BackgroundFragment fragment = (BackgroundFragment) activity.getFragmentManager() .findFragmentByTag(FRAGMENT_TAG); if (fragment == null) { fragment = new BackgroundFragment(); activity.getFragmentManager().beginTransaction().add(fragment, FRAGMENT_TAG).commit(); } else { if (fragment.getBackgroundManager() != null) { throw new IllegalStateException("Created duplicated BackgroundManager for same " + "activity, please use getInstance() instead"); } } fragment.setBackgroundManager(this); mFragmentState = fragment; } private void createSupportFragment(FragmentActivity activity) { // Use a fragment to ensure the background manager gets detached properly. BackgroundSupportFragment fragment = (BackgroundSupportFragment) activity.getSupportFragmentManager() .findFragmentByTag(FRAGMENT_TAG); if (fragment == null) { fragment = new BackgroundSupportFragment(); activity.getSupportFragmentManager().beginTransaction().add(fragment, FRAGMENT_TAG).commit(); } else { if (fragment.getBackgroundManager() != null) { throw new IllegalStateException("Created duplicated BackgroundManager for same " + "activity, please use getInstance() instead"); } } fragment.setBackgroundManager(this); mFragmentState = fragment; } private DrawableWrapper getImageInWrapper() { return mLayerDrawable == null ? null : mLayerDrawable.findWrapperById(R.id.background_imagein); } private DrawableWrapper getImageOutWrapper() { return mLayerDrawable == null ? null : mLayerDrawable.findWrapperById(R.id.background_imageout); } private DrawableWrapper getDimWrapper() { return mLayerDrawable == null ? null : mLayerDrawable.findWrapperById(R.id.background_dim); } private DrawableWrapper getColorWrapper() { return mLayerDrawable == null ? null : mLayerDrawable.findWrapperById(R.id.background_color); } /** * Synchronizes state when the owning Activity is started. * At that point the view becomes visible. */ void onActivityStart() { if (mService == null) { return; } if (mLayerDrawable == null) { if (DEBUG) Log.v(TAG, "onActivityStart " + this + " released state, syncing with service"); syncWithService(); } else { if (DEBUG) Log.v(TAG, "onActivityStart " + this + " updating service color " + mBackgroundColor + " drawable " + mBackgroundDrawable); mService.setColor(mBackgroundColor); mService.setDrawable(mBackgroundDrawable); } } void onResume() { if (DEBUG) Log.v(TAG, "onResume " + this); postChangeRunnable(); } private void syncWithService() { int color = mService.getColor(); Drawable drawable = mService.getDrawable(); if (DEBUG) Log.v(TAG, "syncWithService color " + Integer.toHexString(color) + " drawable " + drawable); mBackgroundColor = color; mBackgroundDrawable = drawable == null ? null : drawable.getConstantState().newDrawable().mutate(); updateImmediate(); } private void lazyInit() { if (mLayerDrawable != null) { return; } LayerDrawable layerDrawable = (LayerDrawable) ContextCompat.getDrawable(mContext, R.drawable.lb_background) .mutate(); mLayerDrawable = createOptimizedTranslucentLayerDrawable(layerDrawable); BackgroundHelper.setBackgroundPreservingAlpha(mBgView, mLayerDrawable); mLayerDrawable.clearDrawable(R.id.background_imageout, mContext); mLayerDrawable.updateDrawable(R.id.background_theme, getThemeDrawable()); updateDimWrapper(); } private void updateDimWrapper() { if (mDimDrawable == null) { mDimDrawable = getDefaultDimLayer(); } Drawable dimDrawable = mDimDrawable.getConstantState().newDrawable(mContext.getResources()).mutate(); if (mLayerDrawable != null) { mLayerDrawable.updateDrawable(R.id.background_dim, dimDrawable); } } /** * Makes the background visible on the given Window. The background manager must be attached * when the background is set. */ public void attach(Window window) { if (USE_SEPARATE_WINDOW) { attachBehindWindow(window); } else { attachToView(window.getDecorView()); } } /** * Sets the resource id for the drawable to be shown when there is no background set. * Overrides the window background drawable from the theme. This should * be called before attaching. */ public void setThemeDrawableResourceId(int resourceId) { mThemeDrawableResourceId = resourceId; } private void attachBehindWindow(Window window) { if (DEBUG) Log.v(TAG, "attachBehindWindow " + window); mWindow = window; mWindowManager = window.getWindowManager(); WindowManager.LayoutParams params = new WindowManager.LayoutParams( // Media window sits behind the main application window WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA, // Avoid default to software format RGBA WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED, android.graphics.PixelFormat.TRANSLUCENT); params.setTitle(WINDOW_NAME); params.width = ViewGroup.LayoutParams.MATCH_PARENT; params.height = ViewGroup.LayoutParams.MATCH_PARENT; View backgroundView = LayoutInflater.from(mContext).inflate(R.layout.lb_background_window, null); mWindowManager.addView(backgroundView, params); attachToView(backgroundView); } private void attachToView(View sceneRoot) { mBgView = sceneRoot; mAttached = true; syncWithService(); } /** * Returns true if the background manager is currently attached; false otherwise. */ public boolean isAttached() { return mAttached; } /** * Release references to Drawables and put the BackgroundManager into the * detached state. Called when the associated Activity is destroyed. * @hide */ void detach() { if (DEBUG) Log.v(TAG, "detach " + this); release(); if (mWindowManager != null && mBgView != null) { mWindowManager.removeViewImmediate(mBgView); } mWindowManager = null; mWindow = null; mBgView = null; mAttached = false; if (mService != null) { mService.unref(); mService = null; } } /** * Release references to Drawables. Typically called to reduce memory * overhead when not visible. * <p> * When an Activity is started, if the BackgroundManager has not been * released, the continuity service is updated from the BackgroundManager * state. If the BackgroundManager was released, the BackgroundManager * inherits the current state from the continuity service. */ public void release() { if (DEBUG) Log.v(TAG, "release " + this); if (mLayerDrawable != null) { mLayerDrawable.clearDrawable(R.id.background_imagein, mContext); mLayerDrawable.clearDrawable(R.id.background_imageout, mContext); mLayerDrawable.clearDrawable(R.id.background_theme, mContext); mLayerDrawable = null; } if (mChangeRunnable != null) { mHandler.removeCallbacks(mChangeRunnable); mChangeRunnable = null; } releaseBackgroundBitmap(); } private void releaseBackgroundBitmap() { mBackgroundDrawable = null; } private void setBackgroundDrawable(Drawable drawable) { mBackgroundDrawable = drawable; mService.setDrawable(mBackgroundDrawable); } /** * Sets the drawable used as a dim layer. */ public void setDimLayer(Drawable drawable) { mDimDrawable = drawable; updateDimWrapper(); } /** * Returns the drawable used as a dim layer. */ public Drawable getDimLayer() { return mDimDrawable; } /** * Returns the default drawable used as a dim layer. */ public Drawable getDefaultDimLayer() { return ContextCompat.getDrawable(mContext, R.color.lb_background_protection); } private void postChangeRunnable() { if (mChangeRunnable == null || !mChangeRunnablePending) { return; } // Postpone a pending change runnable until: no existing change animation in progress && // activity is resumed (in the foreground) && layerdrawable fully opaque. // If the layerdrawable is translucent then an activity transition is in progress // and we want to use the optimized drawing path for performance reasons (see // OptimizedTranslucentLayerDrawable). if (mAnimator.isStarted()) { if (DEBUG) Log.v(TAG, "animation in progress"); } else if (!mFragmentState.isResumed()) { if (DEBUG) Log.v(TAG, "not resumed"); } else if (mLayerDrawable.getAlpha() < FULL_ALPHA) { if (DEBUG) Log.v(TAG, "in transition, alpha " + mLayerDrawable.getAlpha()); } else { long delayMs = getRunnableDelay(); if (DEBUG) Log.v(TAG, "posting runnable delayMs " + delayMs); mLastSetTime = System.currentTimeMillis(); mHandler.postDelayed(mChangeRunnable, delayMs); mChangeRunnablePending = false; } } private void updateImmediate() { lazyInit(); DrawableWrapper colorWrapper = getColorWrapper(); if (colorWrapper != null) { colorWrapper.setColor(mBackgroundColor); } DrawableWrapper dimWrapper = getDimWrapper(); if (dimWrapper != null) { dimWrapper.setAlpha(mBackgroundColor == Color.TRANSPARENT ? 0 : DIM_ALPHA_ON_SOLID); } showWallpaper(mBackgroundColor == Color.TRANSPARENT); if (mBackgroundDrawable == null) { mLayerDrawable.clearDrawable(R.id.background_imagein, mContext); } else { if (DEBUG) Log.v(TAG, "Background drawable is available"); mLayerDrawable.updateDrawable(R.id.background_imagein, mBackgroundDrawable); if (dimWrapper != null) { dimWrapper.setAlpha(FULL_ALPHA); } } } /** * Sets the background to the given color. The timing for when this becomes * visible in the app is undefined and may take place after a small delay. */ public void setColor(@ColorInt int color) { if (DEBUG) Log.v(TAG, "setColor " + Integer.toHexString(color)); mBackgroundColor = color; mService.setColor(mBackgroundColor); DrawableWrapper colorWrapper = getColorWrapper(); if (colorWrapper != null) { colorWrapper.setColor(mBackgroundColor); } } /** * Sets the given drawable into the background. The provided Drawable will be * used unmodified as the background, without any scaling or cropping * applied to it. The timing for when this becomes visible in the app is * undefined and may take place after a small delay. */ public void setDrawable(Drawable drawable) { if (DEBUG) Log.v(TAG, "setBackgroundDrawable " + drawable); setDrawableInternal(drawable); } private void setDrawableInternal(Drawable drawable) { if (!mAttached) { throw new IllegalStateException("Must attach before setting background drawable"); } if (mChangeRunnable != null) { if (sameDrawable(drawable, mChangeRunnable.mDrawable)) { if (DEBUG) Log.v(TAG, "new drawable same as pending"); return; } mHandler.removeCallbacks(mChangeRunnable); mChangeRunnable = null; } // If layer drawable is null then the activity hasn't started yet. // If the layer drawable alpha is zero then the activity transition hasn't started yet. // In these cases we can update the background immediately and let activity transition // fade it in. if (mLayerDrawable == null || mLayerDrawable.getAlpha() == 0) { if (DEBUG) Log.v(TAG, "setDrawableInternal null or alpha is zero"); setBackgroundDrawable(drawable); updateImmediate(); return; } mChangeRunnable = new ChangeBackgroundRunnable(drawable); mChangeRunnablePending = true; postChangeRunnable(); } private long getRunnableDelay() { return Math.max(0, mLastSetTime + CHANGE_BG_DELAY_MS - System.currentTimeMillis()); } /** * Sets the given bitmap into the background. When using setBitmap to set the * background, the provided bitmap will be scaled and cropped to correctly * fit within the dimensions of the view. The timing for when this becomes * visible in the app is undefined and may take place after a small delay. */ public void setBitmap(Bitmap bitmap) { if (DEBUG) { Log.v(TAG, "setBitmap " + bitmap); } if (bitmap == null) { setDrawableInternal(null); return; } if (bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) { if (DEBUG) { Log.v(TAG, "invalid bitmap width or height"); } return; } Matrix matrix = null; if ((bitmap.getWidth() != mWidthPx || bitmap.getHeight() != mHeightPx)) { int dwidth = bitmap.getWidth(); int dheight = bitmap.getHeight(); float scale; // Scale proportionately to fit width and height. if (dwidth * mHeightPx > mWidthPx * dheight) { scale = (float) mHeightPx / (float) dheight; } else { scale = (float) mWidthPx / (float) dwidth; } int subX = Math.min((int) (mWidthPx / scale), dwidth); int dx = Math.max(0, (dwidth - subX) / 2); matrix = new Matrix(); matrix.setScale(scale, scale); matrix.preTranslate(-dx, 0); if (DEBUG) Log.v(TAG, "original image size " + bitmap.getWidth() + "x" + bitmap.getHeight() + " scale " + scale + " dx " + dx); } BitmapDrawable bitmapDrawable = new BitmapDrawable(mContext.getResources(), bitmap, matrix); setDrawableInternal(bitmapDrawable); } private void applyBackgroundChanges() { if (!mAttached) { return; } if (DEBUG) Log.v(TAG, "applyBackgroundChanges drawable " + mBackgroundDrawable); int dimAlpha = -1; if (getImageOutWrapper() != null) { dimAlpha = mBackgroundColor == Color.TRANSPARENT ? 0 : DIM_ALPHA_ON_SOLID; } DrawableWrapper imageInWrapper = getImageInWrapper(); if (imageInWrapper == null && mBackgroundDrawable != null) { if (DEBUG) Log.v(TAG, "creating new imagein drawable"); imageInWrapper = mLayerDrawable.updateDrawable(R.id.background_imagein, mBackgroundDrawable); if (DEBUG) Log.v(TAG, "imageInWrapper animation starting"); imageInWrapper.setAlpha(0); dimAlpha = FULL_ALPHA; } mAnimator.setDuration(FADE_DURATION); mAnimator.start(); DrawableWrapper dimWrapper = getDimWrapper(); if (dimWrapper != null && dimAlpha >= 0) { if (DEBUG) Log.v(TAG, "dimwrapper animation starting to " + dimAlpha); mDimAnimator.cancel(); mDimAnimator.setIntValues(dimWrapper.getAlpha(), dimAlpha); mDimAnimator.setDuration(FADE_DURATION); mDimAnimator .setInterpolator(dimAlpha == FULL_ALPHA ? mDecelerateInterpolator : mAccelerateInterpolator); mDimAnimator.start(); } } /** * Returns the current background color. */ @ColorInt public final int getColor() { return mBackgroundColor; } /** * Returns the current background {@link Drawable}. */ public Drawable getDrawable() { return mBackgroundDrawable; } private boolean sameDrawable(Drawable first, Drawable second) { if (first == null || second == null) { return false; } if (first == second) { return true; } if (first instanceof BitmapDrawable && second instanceof BitmapDrawable) { if (((BitmapDrawable) first).getBitmap().sameAs(((BitmapDrawable) second).getBitmap())) { return true; } } return false; } /** * Task which changes the background. */ class ChangeBackgroundRunnable implements Runnable { private Drawable mDrawable; ChangeBackgroundRunnable(Drawable drawable) { mDrawable = drawable; } @Override public void run() { runTask(); mChangeRunnable = null; } private void runTask() { if (mLayerDrawable == null) { if (DEBUG) Log.v(TAG, "runTask while released - should not happen"); return; } if (sameDrawable(mDrawable, mBackgroundDrawable)) { if (DEBUG) Log.v(TAG, "new drawable same as current"); return; } releaseBackgroundBitmap(); DrawableWrapper imageInWrapper = getImageInWrapper(); if (imageInWrapper != null) { if (DEBUG) Log.v(TAG, "moving image in to image out"); // Order is important! Setting a drawable "removes" the // previous one from the view mLayerDrawable.clearDrawable(R.id.background_imagein, mContext); mLayerDrawable.updateDrawable(R.id.background_imageout, imageInWrapper.getDrawable()); } setBackgroundDrawable(mDrawable); applyBackgroundChanges(); } } private static Drawable createEmptyDrawable(Context context) { Bitmap bitmap = null; return new BitmapDrawable(context.getResources(), bitmap); } private void showWallpaper(boolean show) { if (mWindow == null) { return; } WindowManager.LayoutParams layoutParams = mWindow.getAttributes(); if (show) { if ((layoutParams.flags & WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER) != 0) { return; } if (DEBUG) Log.v(TAG, "showing wallpaper"); layoutParams.flags |= WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER; } else { if ((layoutParams.flags & WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER) == 0) { return; } if (DEBUG) Log.v(TAG, "hiding wallpaper"); layoutParams.flags &= ~WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER; } mWindow.setAttributes(layoutParams); } }