Files
Flexera-Launcher/src/com/android/launcher3/FastBitmapDrawable.java
T
Tony Wickham 7092db0241 Add support for color extracted notification dots
Changing the badge_color in colors.xml to transparent
will cause them to be color extracted.

When an extracted color is used in the IconPalette, we
desaturate the background. Otherwise we respect the
exact color specified in colors.xml.

Change-Id: Ie82d0c5335fa5f24d4cc47766e4c1719c4916f8b
2017-06-08 21:08:47 +00:00

322 lines
10 KiB
Java

/*
* 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 android.animation.ObjectAnimator;
import android.animation.TimeInterpolator;
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.drawable.Drawable;
import android.util.Property;
import android.util.SparseArray;
import com.android.launcher3.graphics.IconPalette;
public class FastBitmapDrawable extends Drawable {
private static final int[] STATE_PRESSED = new int[] {android.R.attr.state_pressed};
private static final float PRESSED_BRIGHTNESS = 100f / 255f;
private static final float DISABLED_DESATURATION = 1f;
private static final float DISABLED_BRIGHTNESS = 0.5f;
public static final TimeInterpolator CLICK_FEEDBACK_INTERPOLATOR = new TimeInterpolator() {
@Override
public float getInterpolation(float input) {
if (input < 0.05f) {
return input / 0.05f;
} else if (input < 0.3f){
return 1;
} else {
return (1 - input) / 0.7f;
}
}
};
public static final int CLICK_FEEDBACK_DURATION = 2000;
// 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);
private final Bitmap mBitmap;
private boolean mIsPressed;
private boolean mIsDisabled;
private IconPalette mIconPalette;
private static final Property<FastBitmapDrawable, Float> BRIGHTNESS
= new Property<FastBitmapDrawable, Float>(Float.TYPE, "brightness") {
@Override
public Float get(FastBitmapDrawable fastBitmapDrawable) {
return fastBitmapDrawable.getBrightness();
}
@Override
public void set(FastBitmapDrawable fastBitmapDrawable, Float value) {
fastBitmapDrawable.setBrightness(value);
}
};
// 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;
// Animators for the fast bitmap drawable's brightness
private ObjectAnimator mBrightnessAnimator;
public FastBitmapDrawable(Bitmap b) {
mBitmap = b;
setFilterBitmap(true);
}
@Override
public void draw(Canvas canvas) {
drawInternal(canvas);
}
public void drawWithBrightness(Canvas canvas, float brightness) {
float oldBrightness = getBrightness();
setBrightness(brightness);
drawInternal(canvas);
setBrightness(oldBrightness);
}
protected void drawInternal(Canvas canvas) {
canvas.drawBitmap(mBitmap, null, getBounds(), mPaint);
}
public IconPalette getIconPalette() {
if (mIconPalette == null) {
mIconPalette = IconPalette.fromDominantColor(Utilities
.findDominantColorByHue(mBitmap, 20), true /* desaturateBackground */);
}
return mIconPalette;
}
@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;
}
@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();
}
public Bitmap getBitmap() {
return mBitmap;
}
@Override
public boolean isStateful() {
return true;
}
@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 (mBrightnessAnimator != null) {
mBrightnessAnimator.cancel();
}
if (mIsPressed) {
// Animate when going to pressed state
mBrightnessAnimator = ObjectAnimator.ofFloat(
this, BRIGHTNESS, getExpectedBrightness());
mBrightnessAnimator.setDuration(CLICK_FEEDBACK_DURATION);
mBrightnessAnimator.setInterpolator(CLICK_FEEDBACK_INTERPOLATOR);
mBrightnessAnimator.start();
} else {
setBrightness(getExpectedBrightness());
}
return true;
}
return false;
}
private void invalidateDesaturationAndBrightness() {
setDesaturation(mIsDisabled ? DISABLED_DESATURATION : 0);
setBrightness(getExpectedBrightness());
}
private float getExpectedBrightness() {
return mIsDisabled ? DISABLED_BRIGHTNESS :
(mIsPressed ? PRESSED_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.
*/
private 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();
}
}