version:
fix: update:更换为酷信
This commit is contained in:
372
src/com/uiuipad/os/FastBitmapDrawable.java
Normal file
372
src/com/uiuipad/os/FastBitmapDrawable.java
Normal file
@@ -0,0 +1,372 @@
|
||||
/*
|
||||
* 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.uiuipad.os;
|
||||
|
||||
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.uiuipad.os.icons.BitmapInfo;
|
||||
import com.uiuipad.os.anim.Interpolators;
|
||||
|
||||
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) {
|
||||
this(b, iconColor, false);
|
||||
}
|
||||
|
||||
protected FastBitmapDrawable(Bitmap b, int iconColor, boolean isDisabled) {
|
||||
mBitmap = b;
|
||||
mIconColor = iconColor;
|
||||
setFilterBitmap(true);
|
||||
setIsDisabled(isDisabled);
|
||||
}
|
||||
|
||||
@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(Interpolators.ACCEL);
|
||||
mScaleAnimation.start();
|
||||
} else {
|
||||
if (isVisible()) {
|
||||
mScaleAnimation = ObjectAnimator.ofFloat(this, SCALE, 1f);
|
||||
mScaleAnimation.setDuration(CLICK_FEEDBACK_DURATION);
|
||||
mScaleAnimation.setInterpolator(Interpolators.DEACCEL);
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean isDisabled() {
|
||||
return mIsDisabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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, mIsDisabled);
|
||||
}
|
||||
|
||||
protected static class MyConstantState extends ConstantState {
|
||||
protected final Bitmap mBitmap;
|
||||
protected final int mIconColor;
|
||||
protected final boolean mIsDisabled;
|
||||
|
||||
public MyConstantState(Bitmap bitmap, int color, boolean isDisabled) {
|
||||
mBitmap = bitmap;
|
||||
mIconColor = color;
|
||||
mIsDisabled = isDisabled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Drawable newDrawable() {
|
||||
return new FastBitmapDrawable(mBitmap, mIconColor, mIsDisabled);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getChangingConfigurations() {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user