blob: daf587a7368125b13c90692463fad1d04d8ae710 [file] [log] [blame]
/*
* Copyright (C) 2008 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.launcher3;
import static com.android.launcher3.anim.Interpolators.ACCEL;
import android.animation.ObjectAnimator;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.Property;
import android.util.SparseArray;
import com.android.launcher3.icons.BitmapInfo;
public class FastBitmapDrawable extends Drawable {
private static final float PRESSED_SCALE = 1.1f;
private static final float DISABLED_DESATURATION = 1f;
private static final float DISABLED_BRIGHTNESS = 0.5f;
public static final int CLICK_FEEDBACK_DURATION = 200;
// Since we don't need 256^2 values for combinations of both the brightness and saturation, we
// reduce the value space to a smaller value V, which reduces the number of cached
// ColorMatrixColorFilters that we need to keep to V^2
private static final int REDUCED_FILTER_VALUE_SPACE = 48;
// A cache of ColorFilters for optimizing brightness and saturation animations
private static final SparseArray<ColorFilter> sCachedFilter = new SparseArray<>();
// Temporary matrices used for calculation
private static final ColorMatrix sTempBrightnessMatrix = new ColorMatrix();
private static final ColorMatrix sTempFilterMatrix = new ColorMatrix();
protected final Paint mPaint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.ANTI_ALIAS_FLAG);
protected Bitmap mBitmap;
protected final int mIconColor;
private boolean mIsPressed;
private boolean mIsDisabled;
// Animator and properties for the fast bitmap drawable's scale
private static final Property<FastBitmapDrawable, Float> SCALE
= new Property<FastBitmapDrawable, Float>(Float.TYPE, "scale") {
@Override
public Float get(FastBitmapDrawable fastBitmapDrawable) {
return fastBitmapDrawable.mScale;
}
@Override
public void set(FastBitmapDrawable fastBitmapDrawable, Float value) {
fastBitmapDrawable.mScale = value;
fastBitmapDrawable.invalidateSelf();
}
};
private ObjectAnimator mScaleAnimation;
private float mScale = 1;
// The saturation and brightness are values that are mapped to REDUCED_FILTER_VALUE_SPACE and
// as a result, can be used to compose the key for the cached ColorMatrixColorFilters
private int mDesaturation = 0;
private int mBrightness = 0;
private int mAlpha = 255;
private int mPrevUpdateKey = Integer.MAX_VALUE;
public FastBitmapDrawable(Bitmap b) {
this(b, Color.TRANSPARENT);
}
public FastBitmapDrawable(BitmapInfo info) {
this(info.icon, info.color);
}
public FastBitmapDrawable(ItemInfoWithIcon info) {
this(info.iconBitmap, info.iconColor);
}
protected FastBitmapDrawable(Bitmap b, int iconColor) {
mBitmap = b;
mIconColor = iconColor;
setFilterBitmap(true);
}
@Override
public final void draw(Canvas canvas) {
if (mScale != 1f) {
int count = canvas.save();
Rect bounds = getBounds();
canvas.scale(mScale, mScale, bounds.exactCenterX(), bounds.exactCenterY());
drawInternal(canvas, bounds);
canvas.restoreToCount(count);
} else {
drawInternal(canvas, getBounds());
}
}
protected void drawInternal(Canvas canvas, Rect bounds) {
canvas.drawBitmap(mBitmap, null, bounds, mPaint);
}
@Override
public void setColorFilter(ColorFilter cf) {
// No op
}
@Override
public int getOpacity() {
return PixelFormat.TRANSLUCENT;
}
@Override
public void setAlpha(int alpha) {
mAlpha = alpha;
mPaint.setAlpha(alpha);
}
@Override
public void setFilterBitmap(boolean filterBitmap) {
mPaint.setFilterBitmap(filterBitmap);
mPaint.setAntiAlias(filterBitmap);
}
public int getAlpha() {
return mAlpha;
}
public void setScale(float scale) {
if (mScaleAnimation != null) {
mScaleAnimation.cancel();
mScaleAnimation = null;
}
mScale = scale;
invalidateSelf();
}
public float getAnimatedScale() {
return mScaleAnimation == null ? 1 : mScale;
}
public float getScale() {
return mScale;
}
@Override
public int getIntrinsicWidth() {
return mBitmap.getWidth();
}
@Override
public int getIntrinsicHeight() {
return mBitmap.getHeight();
}
@Override
public int getMinimumWidth() {
return getBounds().width();
}
@Override
public int getMinimumHeight() {
return getBounds().height();
}
@Override
public boolean isStateful() {
return true;
}
@Override
public ColorFilter getColorFilter() {
return mPaint.getColorFilter();
}
@Override
protected boolean onStateChange(int[] state) {
boolean isPressed = false;
for (int s : state) {
if (s == android.R.attr.state_pressed) {
isPressed = true;
break;
}
}
if (mIsPressed != isPressed) {
mIsPressed = isPressed;
if (mScaleAnimation != null) {
mScaleAnimation.cancel();
mScaleAnimation = null;
}
if (mIsPressed) {
// Animate when going to pressed state
mScaleAnimation = ObjectAnimator.ofFloat(this, SCALE, PRESSED_SCALE);
mScaleAnimation.setDuration(CLICK_FEEDBACK_DURATION);
mScaleAnimation.setInterpolator(ACCEL);
mScaleAnimation.start();
} else {
mScale = 1f;
invalidateSelf();
}
return true;
}
return false;
}
private void invalidateDesaturationAndBrightness() {
setDesaturation(mIsDisabled ? DISABLED_DESATURATION : 0);
setBrightness(mIsDisabled ? DISABLED_BRIGHTNESS : 0);
}
public void setIsDisabled(boolean isDisabled) {
if (mIsDisabled != isDisabled) {
mIsDisabled = isDisabled;
invalidateDesaturationAndBrightness();
}
}
/**
* Sets the saturation of this icon, 0 [full color] -> 1 [desaturated]
*/
private void setDesaturation(float desaturation) {
int newDesaturation = (int) Math.floor(desaturation * REDUCED_FILTER_VALUE_SPACE);
if (mDesaturation != newDesaturation) {
mDesaturation = newDesaturation;
updateFilter();
}
}
public float getDesaturation() {
return (float) mDesaturation / REDUCED_FILTER_VALUE_SPACE;
}
/**
* Sets the brightness of this icon, 0 [no add. brightness] -> 1 [2bright2furious]
*/
private void setBrightness(float brightness) {
int newBrightness = (int) Math.floor(brightness * REDUCED_FILTER_VALUE_SPACE);
if (mBrightness != newBrightness) {
mBrightness = newBrightness;
updateFilter();
}
}
private float getBrightness() {
return (float) mBrightness / REDUCED_FILTER_VALUE_SPACE;
}
/**
* Updates the paint to reflect the current brightness and saturation.
*/
protected void updateFilter() {
boolean usePorterDuffFilter = false;
int key = -1;
if (mDesaturation > 0) {
key = (mDesaturation << 16) | mBrightness;
} else if (mBrightness > 0) {
// Compose a key with a fully saturated icon if we are just animating brightness
key = (1 << 16) | mBrightness;
// We found that in L, ColorFilters cause drawing artifacts with shadows baked into
// icons, so just use a PorterDuff filter when we aren't animating saturation
usePorterDuffFilter = true;
}
// Debounce multiple updates on the same frame
if (key == mPrevUpdateKey) {
return;
}
mPrevUpdateKey = key;
if (key != -1) {
ColorFilter filter = sCachedFilter.get(key);
if (filter == null) {
float brightnessF = getBrightness();
int brightnessI = (int) (255 * brightnessF);
if (usePorterDuffFilter) {
filter = new PorterDuffColorFilter(Color.argb(brightnessI, 255, 255, 255),
PorterDuff.Mode.SRC_ATOP);
} else {
float saturationF = 1f - getDesaturation();
sTempFilterMatrix.setSaturation(saturationF);
if (mBrightness > 0) {
// Brightness: C-new = C-old*(1-amount) + amount
float scale = 1f - brightnessF;
float[] mat = sTempBrightnessMatrix.getArray();
mat[0] = scale;
mat[6] = scale;
mat[12] = scale;
mat[4] = brightnessI;
mat[9] = brightnessI;
mat[14] = brightnessI;
sTempFilterMatrix.preConcat(sTempBrightnessMatrix);
}
filter = new ColorMatrixColorFilter(sTempFilterMatrix);
}
sCachedFilter.append(key, filter);
}
mPaint.setColorFilter(filter);
} else {
mPaint.setColorFilter(null);
}
invalidateSelf();
}
@Override
public ConstantState getConstantState() {
return new MyConstantState(mBitmap, mIconColor);
}
protected static class MyConstantState extends ConstantState {
protected final Bitmap mBitmap;
protected final int mIconColor;
public MyConstantState(Bitmap bitmap, int color) {
mBitmap = bitmap;
mIconColor = color;
}
@Override
public Drawable newDrawable() {
return new FastBitmapDrawable(mBitmap, mIconColor);
}
@Override
public int getChangingConfigurations() {
return 0;
}
}
}