• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 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.launcher2;
18 
19 import java.util.Random;
20 
21 import android.content.Context;
22 import android.content.res.Resources;
23 import android.graphics.Bitmap;
24 import android.graphics.BlurMaskFilter;
25 import android.graphics.Canvas;
26 import android.graphics.ColorMatrix;
27 import android.graphics.ColorMatrixColorFilter;
28 import android.graphics.Paint;
29 import android.graphics.PaintFlagsDrawFilter;
30 import android.graphics.PorterDuff;
31 import android.graphics.Rect;
32 import android.graphics.TableMaskFilter;
33 import android.graphics.drawable.BitmapDrawable;
34 import android.graphics.drawable.Drawable;
35 import android.graphics.drawable.PaintDrawable;
36 import android.util.DisplayMetrics;
37 
38 import com.android.launcher.R;
39 
40 /**
41  * Various utilities shared amongst the Launcher's classes.
42  */
43 final class Utilities {
44     @SuppressWarnings("unused")
45     private static final String TAG = "Launcher.Utilities";
46 
47     private static int sIconWidth = -1;
48     private static int sIconHeight = -1;
49     private static int sIconTextureWidth = -1;
50     private static int sIconTextureHeight = -1;
51 
52     private static final Paint sBlurPaint = new Paint();
53     private static final Paint sGlowColorPressedPaint = new Paint();
54     private static final Paint sGlowColorFocusedPaint = new Paint();
55     private static final Paint sDisabledPaint = new Paint();
56     private static final Rect sOldBounds = new Rect();
57     private static final Canvas sCanvas = new Canvas();
58 
59     static {
sCanvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.DITHER_FLAG, Paint.FILTER_BITMAP_FLAG))60         sCanvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.DITHER_FLAG,
61                 Paint.FILTER_BITMAP_FLAG));
62     }
63     static int sColors[] = { 0xffff0000, 0xff00ff00, 0xff0000ff };
64     static int sColorIndex = 0;
65 
66     /**
67      * Returns a bitmap suitable for the all apps view. Used to convert pre-ICS
68      * icon bitmaps that are stored in the database (which were 74x74 pixels at hdpi size)
69      * to the proper size (48dp)
70      */
createIconBitmap(Bitmap icon, Context context)71     static Bitmap createIconBitmap(Bitmap icon, Context context) {
72         int textureWidth = sIconTextureWidth;
73         int textureHeight = sIconTextureHeight;
74         int sourceWidth = icon.getWidth();
75         int sourceHeight = icon.getHeight();
76         if (sourceWidth > textureWidth && sourceHeight > textureHeight) {
77             // Icon is bigger than it should be; clip it (solves the GB->ICS migration case)
78             return Bitmap.createBitmap(icon,
79                     (sourceWidth - textureWidth) / 2,
80                     (sourceHeight - textureHeight) / 2,
81                     textureWidth, textureHeight);
82         } else if (sourceWidth == textureWidth && sourceHeight == textureHeight) {
83             // Icon is the right size, no need to change it
84             return icon;
85         } else {
86             // Icon is too small, render to a larger bitmap
87             final Resources resources = context.getResources();
88             return createIconBitmap(new BitmapDrawable(resources, icon), context);
89         }
90     }
91 
92     /**
93      * Returns a bitmap suitable for the all apps view.
94      */
createIconBitmap(Drawable icon, Context context)95     static Bitmap createIconBitmap(Drawable icon, Context context) {
96         synchronized (sCanvas) { // we share the statics :-(
97             if (sIconWidth == -1) {
98                 initStatics(context);
99             }
100 
101             int width = sIconWidth;
102             int height = sIconHeight;
103 
104             if (icon instanceof PaintDrawable) {
105                 PaintDrawable painter = (PaintDrawable) icon;
106                 painter.setIntrinsicWidth(width);
107                 painter.setIntrinsicHeight(height);
108             } else if (icon instanceof BitmapDrawable) {
109                 // Ensure the bitmap has a density.
110                 BitmapDrawable bitmapDrawable = (BitmapDrawable) icon;
111                 Bitmap bitmap = bitmapDrawable.getBitmap();
112                 if (bitmap.getDensity() == Bitmap.DENSITY_NONE) {
113                     bitmapDrawable.setTargetDensity(context.getResources().getDisplayMetrics());
114                 }
115             }
116             int sourceWidth = icon.getIntrinsicWidth();
117             int sourceHeight = icon.getIntrinsicHeight();
118             if (sourceWidth > 0 && sourceHeight > 0) {
119                 // There are intrinsic sizes.
120                 if (width < sourceWidth || height < sourceHeight) {
121                     // It's too big, scale it down.
122                     final float ratio = (float) sourceWidth / sourceHeight;
123                     if (sourceWidth > sourceHeight) {
124                         height = (int) (width / ratio);
125                     } else if (sourceHeight > sourceWidth) {
126                         width = (int) (height * ratio);
127                     }
128                 } else if (sourceWidth < width && sourceHeight < height) {
129                     // Don't scale up the icon
130                     width = sourceWidth;
131                     height = sourceHeight;
132                 }
133             }
134 
135             // no intrinsic size --> use default size
136             int textureWidth = sIconTextureWidth;
137             int textureHeight = sIconTextureHeight;
138 
139             final Bitmap bitmap = Bitmap.createBitmap(textureWidth, textureHeight,
140                     Bitmap.Config.ARGB_8888);
141             final Canvas canvas = sCanvas;
142             canvas.setBitmap(bitmap);
143 
144             final int left = (textureWidth-width) / 2;
145             final int top = (textureHeight-height) / 2;
146 
147             @SuppressWarnings("all") // suppress dead code warning
148             final boolean debug = false;
149             if (debug) {
150                 // draw a big box for the icon for debugging
151                 canvas.drawColor(sColors[sColorIndex]);
152                 if (++sColorIndex >= sColors.length) sColorIndex = 0;
153                 Paint debugPaint = new Paint();
154                 debugPaint.setColor(0xffcccc00);
155                 canvas.drawRect(left, top, left+width, top+height, debugPaint);
156             }
157 
158             sOldBounds.set(icon.getBounds());
159             icon.setBounds(left, top, left+width, top+height);
160             icon.draw(canvas);
161             icon.setBounds(sOldBounds);
162             canvas.setBitmap(null);
163 
164             return bitmap;
165         }
166     }
167 
drawSelectedAllAppsBitmap(Canvas dest, int destWidth, int destHeight, boolean pressed, Bitmap src)168     static void drawSelectedAllAppsBitmap(Canvas dest, int destWidth, int destHeight,
169             boolean pressed, Bitmap src) {
170         synchronized (sCanvas) { // we share the statics :-(
171             if (sIconWidth == -1) {
172                 // We can't have gotten to here without src being initialized, which
173                 // comes from this file already.  So just assert.
174                 //initStatics(context);
175                 throw new RuntimeException("Assertion failed: Utilities not initialized");
176             }
177 
178             dest.drawColor(0, PorterDuff.Mode.CLEAR);
179 
180             int[] xy = new int[2];
181             Bitmap mask = src.extractAlpha(sBlurPaint, xy);
182 
183             float px = (destWidth - src.getWidth()) / 2;
184             float py = (destHeight - src.getHeight()) / 2;
185             dest.drawBitmap(mask, px + xy[0], py + xy[1],
186                     pressed ? sGlowColorPressedPaint : sGlowColorFocusedPaint);
187 
188             mask.recycle();
189         }
190     }
191 
192     /**
193      * Returns a Bitmap representing the thumbnail of the specified Bitmap.
194      * The size of the thumbnail is defined by the dimension
195      * android.R.dimen.launcher_application_icon_size.
196      *
197      * @param bitmap The bitmap to get a thumbnail of.
198      * @param context The application's context.
199      *
200      * @return A thumbnail for the specified bitmap or the bitmap itself if the
201      *         thumbnail could not be created.
202      */
resampleIconBitmap(Bitmap bitmap, Context context)203     static Bitmap resampleIconBitmap(Bitmap bitmap, Context context) {
204         synchronized (sCanvas) { // we share the statics :-(
205             if (sIconWidth == -1) {
206                 initStatics(context);
207             }
208 
209             if (bitmap.getWidth() == sIconWidth && bitmap.getHeight() == sIconHeight) {
210                 return bitmap;
211             } else {
212                 final Resources resources = context.getResources();
213                 return createIconBitmap(new BitmapDrawable(resources, bitmap), context);
214             }
215         }
216     }
217 
drawDisabledBitmap(Bitmap bitmap, Context context)218     static Bitmap drawDisabledBitmap(Bitmap bitmap, Context context) {
219         synchronized (sCanvas) { // we share the statics :-(
220             if (sIconWidth == -1) {
221                 initStatics(context);
222             }
223             final Bitmap disabled = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(),
224                     Bitmap.Config.ARGB_8888);
225             final Canvas canvas = sCanvas;
226             canvas.setBitmap(disabled);
227 
228             canvas.drawBitmap(bitmap, 0.0f, 0.0f, sDisabledPaint);
229 
230             canvas.setBitmap(null);
231 
232             return disabled;
233         }
234     }
235 
initStatics(Context context)236     private static void initStatics(Context context) {
237         final Resources resources = context.getResources();
238         final DisplayMetrics metrics = resources.getDisplayMetrics();
239         final float density = metrics.density;
240 
241         sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
242         sIconTextureWidth = sIconTextureHeight = sIconWidth;
243 
244         sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
245         sGlowColorPressedPaint.setColor(0xffffc300);
246         sGlowColorPressedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
247         sGlowColorFocusedPaint.setColor(0xffff8e00);
248         sGlowColorFocusedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
249 
250         ColorMatrix cm = new ColorMatrix();
251         cm.setSaturation(0.2f);
252         sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
253         sDisabledPaint.setAlpha(0x88);
254     }
255 
256     /** Only works for positive numbers. */
roundToPow2(int n)257     static int roundToPow2(int n) {
258         int orig = n;
259         n >>= 1;
260         int mask = 0x8000000;
261         while (mask != 0 && (n & mask) == 0) {
262             mask >>= 1;
263         }
264         while (mask != 0) {
265             n |= mask;
266             mask >>= 1;
267         }
268         n += 1;
269         if (n != orig) {
270             n <<= 1;
271         }
272         return n;
273     }
274 
generateRandomId()275     static int generateRandomId() {
276         return new Random(System.currentTimeMillis()).nextInt(1 << 24);
277     }
278 }
279