blob: f10b972590067309598735ec13236f5ff8565ce7 [file] [log] [blame]
/*
* Copyright (C) 2017 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.graphics;
import android.annotation.TargetApi;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BlurMaskFilter;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.util.AttributeSet;
import com.android.launcher3.R;
import com.android.launcher3.icons.BitmapRenderer;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
/**
* A drawable which adds shadow around a child drawable.
*/
@TargetApi(Build.VERSION_CODES.O)
public class ShadowDrawable extends Drawable {
private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
private final ShadowDrawableState mState;
@SuppressWarnings("unused")
public ShadowDrawable() {
this(new ShadowDrawableState());
}
private ShadowDrawable(ShadowDrawableState state) {
mState = state;
}
@Override
public void draw(Canvas canvas) {
Rect bounds = getBounds();
if (bounds.isEmpty()) {
return;
}
if (mState.mLastDrawnBitmap == null) {
regenerateBitmapCache();
}
canvas.drawBitmap(mState.mLastDrawnBitmap, null, bounds, mPaint);
}
@Override
public void setAlpha(int alpha) {
mPaint.setAlpha(alpha);
invalidateSelf();
}
@Override
public void setColorFilter(ColorFilter colorFilter) {
mPaint.setColorFilter(colorFilter);
invalidateSelf();
}
@Override
public ConstantState getConstantState() {
return mState;
}
@Override
public int getOpacity() {
return PixelFormat.TRANSLUCENT;
}
@Override
public int getIntrinsicHeight() {
return mState.mIntrinsicHeight;
}
@Override
public int getIntrinsicWidth() {
return mState.mIntrinsicWidth;
}
@Override
public boolean canApplyTheme() {
return mState.canApplyTheme();
}
@Override
public void applyTheme(Resources.Theme t) {
TypedArray ta = t.obtainStyledAttributes(new int[] {R.attr.isWorkspaceDarkText});
boolean isDark = ta.getBoolean(0, false);
ta.recycle();
if (mState.mIsDark != isDark) {
mState.mIsDark = isDark;
mState.mLastDrawnBitmap = null;
invalidateSelf();
}
}
private void regenerateBitmapCache() {
Bitmap bitmap = Bitmap.createBitmap(mState.mIntrinsicWidth, mState.mIntrinsicHeight,
Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
// Call mutate, so that the pixel allocation by the underlying vector drawable is cleared.
Drawable d = mState.mChildState.newDrawable().mutate();
d.setBounds(mState.mShadowSize, mState.mShadowSize,
mState.mIntrinsicWidth - mState.mShadowSize,
mState.mIntrinsicHeight - mState.mShadowSize);
d.setTint(mState.mIsDark ? mState.mDarkTintColor : Color.WHITE);
d.draw(canvas);
// Do not draw shadow on dark theme
if (!mState.mIsDark) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
paint.setMaskFilter(new BlurMaskFilter(mState.mShadowSize, BlurMaskFilter.Blur.NORMAL));
int[] offset = new int[2];
Bitmap shadow = bitmap.extractAlpha(paint, offset);
paint.setMaskFilter(null);
paint.setColor(mState.mShadowColor);
bitmap.eraseColor(Color.TRANSPARENT);
canvas.drawBitmap(shadow, offset[0], offset[1], paint);
d.draw(canvas);
}
if (BitmapRenderer.USE_HARDWARE_BITMAP) {
bitmap = bitmap.copy(Bitmap.Config.HARDWARE, false);
}
mState.mLastDrawnBitmap = bitmap;
}
@Override
public void inflate(Resources r, XmlPullParser parser, AttributeSet attrs,
Resources.Theme theme) throws XmlPullParserException, IOException {
super.inflate(r, parser, attrs, theme);
final TypedArray a = theme == null
? r.obtainAttributes(attrs, R.styleable.ShadowDrawable)
: theme.obtainStyledAttributes(attrs, R.styleable.ShadowDrawable, 0, 0);
try {
Drawable d = a.getDrawable(R.styleable.ShadowDrawable_android_src);
if (d == null) {
throw new XmlPullParserException("missing src attribute");
}
mState.mShadowColor = a.getColor(
R.styleable.ShadowDrawable_android_shadowColor, Color.BLACK);
mState.mShadowSize = a.getDimensionPixelSize(
R.styleable.ShadowDrawable_android_elevation, 0);
mState.mDarkTintColor = a.getColor(
R.styleable.ShadowDrawable_darkTintColor, Color.BLACK);
mState.mIntrinsicHeight = d.getIntrinsicHeight() + 2 * mState.mShadowSize;
mState.mIntrinsicWidth = d.getIntrinsicWidth() + 2 * mState.mShadowSize;
mState.mChangingConfigurations = d.getChangingConfigurations();
mState.mChildState = d.getConstantState();
} finally {
a.recycle();
}
}
private static class ShadowDrawableState extends ConstantState {
int mChangingConfigurations;
int mIntrinsicWidth;
int mIntrinsicHeight;
int mShadowColor;
int mShadowSize;
int mDarkTintColor;
boolean mIsDark;
Bitmap mLastDrawnBitmap;
ConstantState mChildState;
@Override
public Drawable newDrawable() {
return new ShadowDrawable(this);
}
@Override
public int getChangingConfigurations() {
return mChangingConfigurations;
}
@Override
public boolean canApplyTheme() {
return true;
}
}
}