src/com/android/launcher3/badge/BadgeRenderer.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.launcher3.badge;
  18
  19 import android.content.Context;
  20 import android.content.res.Resources;
  21 import android.graphics.Bitmap;
  22 import android.graphics.Canvas;
  23 import android.graphics.Color;
  24 import android.graphics.Paint;
  25 import android.graphics.Point;
  26 import android.graphics.Rect;
  27 import android.graphics.Shader;
  28 import android.support.annotation.Nullable;
  29 import android.util.SparseArray;
  30
  31 import com.android.launcher3.R;
  32 import com.android.launcher3.graphics.IconPalette;
  33 import com.android.launcher3.graphics.ShadowGenerator;
  34
  35 /**
  36  * Contains parameters necessary to draw a badge for an icon (e.g. the size of the badge).
  37  * @see BadgeInfo for the data to draw
  38  */
  39 public class BadgeRenderer {
  40
  41     private static final boolean DOTS_ONLY = true;
  42
  43     // The badge sizes are defined as percentages of the app icon size.
  44     private static final float SIZE_PERCENTAGE = 0.38f;
  45     // Used to expand the width of the badge for each additional digit.
  46     private static final float CHAR_SIZE_PERCENTAGE = 0.12f;
  47     private static final float TEXT_SIZE_PERCENTAGE = 0.26f;
  48     private static final float OFFSET_PERCENTAGE = 0.02f;
  49     private static final float STACK_OFFSET_PERCENTAGE_X = 0.05f;
  50     private static final float STACK_OFFSET_PERCENTAGE_Y = 0.06f;
  51     private static final float DOT_SCALE = 0.6f;
  52
  53     private final Context mContext;
  54     private final int mSize;
  55     private final int mCharSize;
  56     private final int mTextHeight;
  57     private final int mOffset;
  58     private final int mStackOffsetX;
  59     private final int mStackOffsetY;
  60     private final IconDrawer mLargeIconDrawer;
  61     private final IconDrawer mSmallIconDrawer;
  62     private final Paint mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
  63     private final Paint mBackgroundPaint = new Paint(Paint.ANTI_ALIAS_FLAG
  64             | Paint.FILTER_BITMAP_FLAG);
  65     private final SparseArray<Bitmap> mBackgroundsWithShadow;
  66
  67     public BadgeRenderer(Context context, int iconSizePx) {
  68         mContext = context;
  69         Resources res = context.getResources();
  70         mSize = (int) (SIZE_PERCENTAGE * iconSizePx);
  71         mCharSize = (int) (CHAR_SIZE_PERCENTAGE * iconSizePx);
  72         mOffset = (int) (OFFSET_PERCENTAGE * iconSizePx);
  73         mStackOffsetX = (int) (STACK_OFFSET_PERCENTAGE_X * iconSizePx);
  74         mStackOffsetY = (int) (STACK_OFFSET_PERCENTAGE_Y * iconSizePx);
  75         mTextPaint.setTextSize(iconSizePx * TEXT_SIZE_PERCENTAGE);
  76         mTextPaint.setTextAlign(Paint.Align.CENTER);
  77         mLargeIconDrawer = new IconDrawer(res.getDimensionPixelSize(R.dimen.badge_small_padding));
  78         mSmallIconDrawer = new IconDrawer(res.getDimensionPixelSize(R.dimen.badge_large_padding));
  79         // Measure the text height.
  80         Rect tempTextHeight = new Rect();
  81         mTextPaint.getTextBounds("0", 0, 1, tempTextHeight);
  82         mTextHeight = tempTextHeight.height();
  83
  84         mBackgroundsWithShadow = new SparseArray<>(3);
  85     }
  86
  87     /**
  88      * Draw a circle in the top right corner of the given bounds, and draw
  89      * {@link BadgeInfo#getNotificationCount()} on top of the circle.
  90      * @param palette The colors (based on the icon) to use for the badge.
  91      * @param badgeInfo Contains data to draw on the badge. Could be null if we are animating out.
  92      * @param iconBounds The bounds of the icon being badged.
  93      * @param badgeScale The progress of the animation, from 0 to 1.
  94      * @param spaceForOffset How much space is available to offset the badge up and to the right.
  95      */
  96     public void draw(Canvas canvas, IconPalette palette, @Nullable BadgeInfo badgeInfo,
  97             Rect iconBounds, float badgeScale, Point spaceForOffset) {
  98         mTextPaint.setColor(palette.textColor);
  99         IconDrawer iconDrawer = badgeInfo != null && badgeInfo.isIconLarge()
 100                 ? mLargeIconDrawer : mSmallIconDrawer;
 101         Shader icon = badgeInfo == null ? null : badgeInfo.getNotificationIconForBadge(
 102                 mContext, palette.backgroundColor, mSize, iconDrawer.mPadding);
 103         String notificationCount = badgeInfo == null ? "0"
 104                 : String.valueOf(badgeInfo.getNotificationCount());
 105         int numChars = notificationCount.length();
 106         int width = DOTS_ONLY ? mSize : mSize + mCharSize * (numChars - 1);
 107         // Lazily load the background with shadow.
 108         Bitmap backgroundWithShadow = mBackgroundsWithShadow.get(numChars);
 109         if (backgroundWithShadow == null) {
 110             backgroundWithShadow = ShadowGenerator.createPillWithShadow(Color.WHITE, width, mSize);
 111             mBackgroundsWithShadow.put(numChars, backgroundWithShadow);
 112         }
 113         canvas.save(Canvas.MATRIX_SAVE_FLAG);
 114         // We draw the badge relative to its center.
 115         int badgeCenterX = iconBounds.right - width / 2;
 116         int badgeCenterY = iconBounds.top + mSize / 2;
 117         boolean isText = !DOTS_ONLY && badgeInfo != null && badgeInfo.getNotificationCount() != 0;
 118         boolean isIcon = !DOTS_ONLY && icon != null;
 119         boolean isDot = !(isText || isIcon);
 120         if (isDot) {
 121             badgeScale *= DOT_SCALE;
 122         }
 123         int offsetX = Math.min(mOffset, spaceForOffset.x);
 124         int offsetY = Math.min(mOffset, spaceForOffset.y);
 125         canvas.translate(badgeCenterX + offsetX, badgeCenterY - offsetY);
 126         canvas.scale(badgeScale, badgeScale);
 127         // Prepare the background and shadow and possible stacking effect.
 128         mBackgroundPaint.setColorFilter(palette.backgroundColorMatrixFilter);
 129         int backgroundWithShadowSize = backgroundWithShadow.getHeight(); // Same as width.
 130         boolean shouldStack = !isDot && badgeInfo != null
 131                 && badgeInfo.getNotificationKeys().size() > 1;
 132         if (shouldStack) {
 133             int offsetDiffX = mStackOffsetX - mOffset;
 134             int offsetDiffY = mStackOffsetY - mOffset;
 135             canvas.translate(offsetDiffX, offsetDiffY);
 136             canvas.drawBitmap(backgroundWithShadow, -backgroundWithShadowSize / 2,
 137                     -backgroundWithShadowSize / 2, mBackgroundPaint);
 138             canvas.translate(-offsetDiffX, -offsetDiffY);
 139         }
 140
 141         if (isText) {
 142             canvas.drawBitmap(backgroundWithShadow, -backgroundWithShadowSize / 2,
 143                     -backgroundWithShadowSize / 2, mBackgroundPaint);
 144             canvas.drawText(notificationCount, 0, mTextHeight / 2, mTextPaint);
 145         } else if (isIcon) {
 146             canvas.drawBitmap(backgroundWithShadow, -backgroundWithShadowSize / 2,
 147                     -backgroundWithShadowSize / 2, mBackgroundPaint);
 148             iconDrawer.drawIcon(icon, canvas);
 149         } else if (isDot) {
 150             mBackgroundPaint.setColorFilter(palette.saturatedBackgroundColorMatrixFilter);
 151             canvas.drawBitmap(backgroundWithShadow, -backgroundWithShadowSize / 2,
 152                     -backgroundWithShadowSize / 2, mBackgroundPaint);
 153         }
 154         canvas.restore();
 155     }
 156
 157     /** Draws the notification icon with padding of a given size. */
 158     private class IconDrawer {
 159
 160         private final int mPadding;
 161         private final Bitmap mCircleClipBitmap;
 162         private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG |
 163                 Paint.FILTER_BITMAP_FLAG);
 164
 165         public IconDrawer(int padding) {
 166             mPadding = padding;
 167             mCircleClipBitmap = Bitmap.createBitmap(mSize, mSize, Bitmap.Config.ALPHA_8);
 168             Canvas canvas = new Canvas();
 169             canvas.setBitmap(mCircleClipBitmap);
 170             canvas.drawCircle(mSize / 2, mSize / 2, mSize / 2 - padding, mPaint);
 171         }
 172
 173         public void drawIcon(Shader icon, Canvas canvas) {
 174             mPaint.setShader(icon);
 175             canvas.drawBitmap(mCircleClipBitmap, -mSize / 2, -mSize / 2, mPaint);
 176             mPaint.setShader(null);
 177         }
 178     }
 179 }