blob: 0e9106201bcfd5e6e9ce23174c6e4d0d68cceb96 [file] [log] [blame]
Daniel Sandler325dc232013-06-05 22:57:57 -04001package com.android.launcher3;
Michael Jurka05713af2013-01-23 12:39:24 +01002
Michael Jurka05713af2013-01-23 12:39:24 +01003import android.content.ComponentName;
4import android.content.ContentValues;
5import android.content.Context;
Sunny Goyal5b0e6692015-03-19 14:31:19 -07006import android.content.pm.PackageInfo;
Sunny Goyal4ddc4012016-03-10 12:02:29 -08007import android.content.pm.PackageManager;
Sunny Goyal5b0e6692015-03-19 14:31:19 -07008import android.content.pm.PackageManager.NameNotFoundException;
Michael Jurka05713af2013-01-23 12:39:24 +01009import android.content.res.Resources;
10import android.database.Cursor;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070011import android.database.SQLException;
Michael Jurka05713af2013-01-23 12:39:24 +010012import android.database.sqlite.SQLiteDatabase;
Michael Jurka05713af2013-01-23 12:39:24 +010013import android.graphics.Bitmap;
14import android.graphics.Bitmap.Config;
15import android.graphics.BitmapFactory;
16import android.graphics.Canvas;
Sunny Goyal7d87cb12017-02-13 10:44:43 -080017import android.graphics.Color;
Michael Jurka05713af2013-01-23 12:39:24 +010018import android.graphics.Paint;
19import android.graphics.PorterDuff;
Sunny Goyal92bbfa12017-02-07 15:06:32 -080020import android.graphics.PorterDuffXfermode;
Sunny Goyal7d87cb12017-02-13 10:44:43 -080021import android.graphics.Rect;
Sunny Goyal4cad7532015-03-18 15:56:30 -070022import android.graphics.RectF;
Michael Jurka05713af2013-01-23 12:39:24 +010023import android.graphics.drawable.Drawable;
24import android.os.AsyncTask;
Sunny Goyalc65a0082017-03-08 14:49:55 -080025import android.os.CancellationSignal;
Winson Chung05304db2015-05-18 16:53:20 -070026import android.os.Handler;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080027import android.os.UserHandle;
Sunny Goyal7d87cb12017-02-13 10:44:43 -080028import android.support.v4.graphics.ColorUtils;
Michael Jurka05713af2013-01-23 12:39:24 +010029import android.util.Log;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070030import android.util.LongSparseArray;
Sunny Goyal383c5072015-06-12 21:18:53 -070031
Sunny Goyalffe83f12014-08-14 17:39:34 -070032import com.android.launcher3.compat.AppWidgetManagerCompat;
Sunny Goyal782f0c92017-01-19 10:27:54 -080033import com.android.launcher3.compat.ShortcutConfigActivityInfo;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070034import com.android.launcher3.compat.UserManagerCompat;
Sunny Goyal7d87cb12017-02-13 10:44:43 -080035import com.android.launcher3.graphics.LauncherIcons;
Sunny Goyal92bbfa12017-02-07 15:06:32 -080036import com.android.launcher3.graphics.ShadowGenerator;
Sunny Goyal4ddc4012016-03-10 12:02:29 -080037import com.android.launcher3.model.WidgetItem;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070038import com.android.launcher3.util.ComponentKey;
Sunny Goyal6388b2c2016-04-15 18:03:27 -070039import com.android.launcher3.util.Preconditions;
Sunny Goyal6f709362015-12-17 17:09:36 -080040import com.android.launcher3.util.SQLiteCacheHelper;
Adam Cohen091440a2015-03-18 14:16:05 -070041import com.android.launcher3.util.Thunk;
Hyunyoung Song3f471442015-04-08 19:01:34 -070042import com.android.launcher3.widget.WidgetCell;
Hyunyoung Song8821ca92015-05-04 16:28:20 -070043
44import java.util.ArrayList;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070045import java.util.Collections;
Michael Jurka05713af2013-01-23 12:39:24 +010046import java.util.HashMap;
47import java.util.HashSet;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070048import java.util.Set;
49import java.util.WeakHashMap;
Adrian Roos65d60e22014-04-15 21:07:49 +020050import java.util.concurrent.Callable;
51import java.util.concurrent.ExecutionException;
Michael Jurka05713af2013-01-23 12:39:24 +010052
Sunny Goyalffe83f12014-08-14 17:39:34 -070053public class WidgetPreviewLoader {
Michael Jurka05713af2013-01-23 12:39:24 +010054
Sunny Goyalffe83f12014-08-14 17:39:34 -070055 private static final String TAG = "WidgetPreviewLoader";
Hyunyoung Song3f471442015-04-08 19:01:34 -070056 private static final boolean DEBUG = false;
Sunny Goyalffe83f12014-08-14 17:39:34 -070057
Sunny Goyal5b0e6692015-03-19 14:31:19 -070058 private final HashMap<String, long[]> mPackageVersions = new HashMap<>();
Hyunyoung Song559d90d2015-04-28 15:06:45 -070059
60 /**
61 * Weak reference objects, do not prevent their referents from being made finalizable,
62 * finalized, and then reclaimed.
Hyunyoung Songe98f4a42015-06-16 10:45:24 -070063 * Note: synchronized block used for this variable is expensive and the block should always
64 * be posted to a background thread.
Hyunyoung Song559d90d2015-04-28 15:06:45 -070065 */
Sunny Goyalb4cbea42015-06-16 15:10:36 -070066 @Thunk final Set<Bitmap> mUnusedBitmaps =
Hyunyoung Song559d90d2015-04-28 15:06:45 -070067 Collections.newSetFromMap(new WeakHashMap<Bitmap, Boolean>());
Sunny Goyal4cad7532015-03-18 15:56:30 -070068
69 private final Context mContext;
Sunny Goyalffe83f12014-08-14 17:39:34 -070070 private final IconCache mIconCache;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070071 private final UserManagerCompat mUserManager;
Hyunyoung Song3e840f42016-03-01 11:57:44 -080072 private final AppWidgetManagerCompat mWidgetManager;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070073 private final CacheDb mDb;
Michael Jurka05713af2013-01-23 12:39:24 +010074
Adrian Roos65d60e22014-04-15 21:07:49 +020075 private final MainThreadExecutor mMainThreadExecutor = new MainThreadExecutor();
Sunny Goyal316490e2015-06-02 09:38:28 -070076 @Thunk final Handler mWorkerHandler;
Adrian Roos65d60e22014-04-15 21:07:49 +020077
Sunny Goyal383c5072015-06-12 21:18:53 -070078 public WidgetPreviewLoader(Context context, IconCache iconCache) {
Chris Wrenfd13c712013-09-27 15:45:19 -040079 mContext = context;
Sunny Goyal5b0e6692015-03-19 14:31:19 -070080 mIconCache = iconCache;
Hyunyoung Song3e840f42016-03-01 11:57:44 -080081 mWidgetManager = AppWidgetManagerCompat.getInstance(context);
Sunny Goyal5b0e6692015-03-19 14:31:19 -070082 mUserManager = UserManagerCompat.getInstance(context);
83 mDb = new CacheDb(context);
Winson Chung05304db2015-05-18 16:53:20 -070084 mWorkerHandler = new Handler(LauncherModel.getWorkerLooper());
Michael Jurka3f4e0702013-02-05 11:21:28 +010085 }
Sunny Goyalffe83f12014-08-14 17:39:34 -070086
Sunny Goyal5b0e6692015-03-19 14:31:19 -070087 /**
88 * Generates the widget preview on {@link AsyncTask#THREAD_POOL_EXECUTOR}. Must be
89 * called on UI thread
90 *
Sunny Goyal5b0e6692015-03-19 14:31:19 -070091 * @return a request id which can be used to cancel the request.
92 */
Sunny Goyalc65a0082017-03-08 14:49:55 -080093 public CancellationSignal getPreview(WidgetItem item, int previewWidth,
Adam Cohen2e6da152015-05-06 11:42:25 -070094 int previewHeight, WidgetCell caller) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -070095 String size = previewWidth + "x" + previewHeight;
Sunny Goyal4ddc4012016-03-10 12:02:29 -080096 WidgetCacheKey key = new WidgetCacheKey(item.componentName, item.user, size);
Michael Jurka3f4e0702013-02-05 11:21:28 +010097
Sunny Goyal4ddc4012016-03-10 12:02:29 -080098 PreviewLoadTask task = new PreviewLoadTask(key, item, previewWidth, previewHeight, caller);
Sunny Goyal8ac727b2015-09-23 15:38:09 -070099 task.executeOnExecutor(Utilities.THREAD_POOL_EXECUTOR);
Sunny Goyalc65a0082017-03-08 14:49:55 -0800100
101 CancellationSignal signal = new CancellationSignal();
102 signal.setOnCancelListener(task);
103 return signal;
Michael Jurka05713af2013-01-23 12:39:24 +0100104 }
105
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700106 /**
107 * The DB holds the generated previews for various components. Previews can also have different
108 * sizes (landscape vs portrait).
109 */
Sunny Goyal6f709362015-12-17 17:09:36 -0800110 private static class CacheDb extends SQLiteCacheHelper {
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800111 private static final int DB_VERSION = 6;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700112
113 private static final String TABLE_NAME = "shortcut_and_widget_previews";
114 private static final String COLUMN_COMPONENT = "componentName";
115 private static final String COLUMN_USER = "profileId";
116 private static final String COLUMN_SIZE = "size";
117 private static final String COLUMN_PACKAGE = "packageName";
118 private static final String COLUMN_LAST_UPDATED = "lastUpdated";
119 private static final String COLUMN_VERSION = "version";
120 private static final String COLUMN_PREVIEW_BITMAP = "preview_bitmap";
Michael Jurka05713af2013-01-23 12:39:24 +0100121
Michael Jurkad9cb4a12013-03-19 12:01:06 +0100122 public CacheDb(Context context) {
Sunny Goyal6f709362015-12-17 17:09:36 -0800123 super(context, LauncherFiles.WIDGET_PREVIEWS_DB, DB_VERSION, TABLE_NAME);
Michael Jurka05713af2013-01-23 12:39:24 +0100124 }
125
126 @Override
Sunny Goyal6f709362015-12-17 17:09:36 -0800127 public void onCreateTable(SQLiteDatabase database) {
Michael Jurka32b7a092013-02-07 20:06:49 +0100128 database.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " (" +
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700129 COLUMN_COMPONENT + " TEXT NOT NULL, " +
130 COLUMN_USER + " INTEGER NOT NULL, " +
Michael Jurka05713af2013-01-23 12:39:24 +0100131 COLUMN_SIZE + " TEXT NOT NULL, " +
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700132 COLUMN_PACKAGE + " TEXT NOT NULL, " +
133 COLUMN_LAST_UPDATED + " INTEGER NOT NULL DEFAULT 0, " +
134 COLUMN_VERSION + " INTEGER NOT NULL DEFAULT 0, " +
135 COLUMN_PREVIEW_BITMAP + " BLOB, " +
136 "PRIMARY KEY (" + COLUMN_COMPONENT + ", " + COLUMN_USER + ", " + COLUMN_SIZE + ") " +
Michael Jurka32b7a092013-02-07 20:06:49 +0100137 ");");
Michael Jurka05713af2013-01-23 12:39:24 +0100138 }
Michael Jurka05713af2013-01-23 12:39:24 +0100139 }
140
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700141 @Thunk void writeToDb(WidgetCacheKey key, long[] versions, Bitmap preview) {
Michael Jurka05713af2013-01-23 12:39:24 +0100142 ContentValues values = new ContentValues();
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700143 values.put(CacheDb.COLUMN_COMPONENT, key.componentName.flattenToShortString());
144 values.put(CacheDb.COLUMN_USER, mUserManager.getSerialNumberForUser(key.user));
145 values.put(CacheDb.COLUMN_SIZE, key.size);
146 values.put(CacheDb.COLUMN_PACKAGE, key.componentName.getPackageName());
147 values.put(CacheDb.COLUMN_VERSION, versions[0]);
148 values.put(CacheDb.COLUMN_LAST_UPDATED, versions[1]);
149 values.put(CacheDb.COLUMN_PREVIEW_BITMAP, Utilities.flattenBitmap(preview));
Sunny Goyal6f709362015-12-17 17:09:36 -0800150 mDb.insertOrReplace(values);
Michael Jurka05713af2013-01-23 12:39:24 +0100151 }
152
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800153 public void removePackage(String packageName, UserHandle user) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700154 removePackage(packageName, user, mUserManager.getSerialNumberForUser(user));
155 }
156
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800157 private void removePackage(String packageName, UserHandle user, long userSerial) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700158 synchronized(mPackageVersions) {
159 mPackageVersions.remove(packageName);
160 }
161
Sunny Goyal6f709362015-12-17 17:09:36 -0800162 mDb.delete(
163 CacheDb.COLUMN_PACKAGE + " = ? AND " + CacheDb.COLUMN_USER + " = ?",
164 new String[]{packageName, Long.toString(userSerial)});
Michael Jurka8ff02ca2013-11-01 14:19:27 +0100165 }
166
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700167 /**
168 * Updates the persistent DB:
169 * 1. Any preview generated for an old package version is removed
170 * 2. Any preview for an absent package is removed
171 * This ensures that we remove entries for packages which changed while the launcher was dead.
172 */
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800173 public void removeObsoletePreviews(ArrayList<? extends ComponentKey> list) {
Sunny Goyal6388b2c2016-04-15 18:03:27 -0700174 Preconditions.assertWorkerThread();
Hyunyoung Song8821ca92015-05-04 16:28:20 -0700175
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700176 LongSparseArray<HashSet<String>> validPackages = new LongSparseArray<>();
177
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800178 for (ComponentKey key : list) {
179 final long userId = mUserManager.getSerialNumberForUser(key.user);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700180 HashSet<String> packages = validPackages.get(userId);
181 if (packages == null) {
182 packages = new HashSet<>();
183 validPackages.put(userId, packages);
184 }
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800185 packages.add(key.componentName.getPackageName());
Michael Jurka05713af2013-01-23 12:39:24 +0100186 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700187
188 LongSparseArray<HashSet<String>> packagesToDelete = new LongSparseArray<>();
189 Cursor c = null;
190 try {
Sunny Goyal6f709362015-12-17 17:09:36 -0800191 c = mDb.query(
192 new String[]{CacheDb.COLUMN_USER, CacheDb.COLUMN_PACKAGE,
193 CacheDb.COLUMN_LAST_UPDATED, CacheDb.COLUMN_VERSION},
194 null, null);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700195 while (c.moveToNext()) {
196 long userId = c.getLong(0);
197 String pkg = c.getString(1);
198 long lastUpdated = c.getLong(2);
199 long version = c.getLong(3);
200
201 HashSet<String> packages = validPackages.get(userId);
202 if (packages != null && packages.contains(pkg)) {
203 long[] versions = getPackageVersion(pkg);
204 if (versions[0] == version && versions[1] == lastUpdated) {
205 // Every thing checks out
206 continue;
207 }
208 }
209
210 // We need to delete this package.
211 packages = packagesToDelete.get(userId);
212 if (packages == null) {
213 packages = new HashSet<>();
214 packagesToDelete.put(userId, packages);
215 }
216 packages.add(pkg);
217 }
218
219 for (int i = 0; i < packagesToDelete.size(); i++) {
220 long userId = packagesToDelete.keyAt(i);
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800221 UserHandle user = mUserManager.getUserForSerialNumber(userId);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700222 for (String pkg : packagesToDelete.valueAt(i)) {
223 removePackage(pkg, user, userId);
224 }
225 }
226 } catch (SQLException e) {
Sunny Goyal6f709362015-12-17 17:09:36 -0800227 Log.e(TAG, "Error updating widget previews", e);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700228 } finally {
229 if (c != null) {
230 c.close();
231 }
232 }
233 }
234
Winson Chung05304db2015-05-18 16:53:20 -0700235 /**
236 * Reads the preview bitmap from the DB or null if the preview is not in the DB.
237 */
Sunny Goyal316490e2015-06-02 09:38:28 -0700238 @Thunk Bitmap readFromDb(WidgetCacheKey key, Bitmap recycle, PreviewLoadTask loadTask) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700239 Cursor cursor = null;
240 try {
Sunny Goyal6f709362015-12-17 17:09:36 -0800241 cursor = mDb.query(
242 new String[]{CacheDb.COLUMN_PREVIEW_BITMAP},
243 CacheDb.COLUMN_COMPONENT + " = ? AND " + CacheDb.COLUMN_USER + " = ? AND "
244 + CacheDb.COLUMN_SIZE + " = ?",
245 new String[]{
Sunny Goyal3ef86912016-10-27 11:40:06 -0700246 key.componentName.flattenToShortString(),
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700247 Long.toString(mUserManager.getSerialNumberForUser(key.user)),
248 key.size
Sunny Goyal6f709362015-12-17 17:09:36 -0800249 });
Winson Chung05304db2015-05-18 16:53:20 -0700250 // If cancelled, skip getting the blob and decoding it into a bitmap
251 if (loadTask.isCancelled()) {
252 return null;
253 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700254 if (cursor.moveToNext()) {
255 byte[] blob = cursor.getBlob(0);
256 BitmapFactory.Options opts = new BitmapFactory.Options();
257 opts.inBitmap = recycle;
Michael Jurka6e27f642013-12-10 13:40:30 +0100258 try {
Winson Chung05304db2015-05-18 16:53:20 -0700259 if (!loadTask.isCancelled()) {
260 return BitmapFactory.decodeByteArray(blob, 0, blob.length, opts);
261 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700262 } catch (Exception e) {
263 return null;
Michael Jurka6e27f642013-12-10 13:40:30 +0100264 }
Michael Jurka05713af2013-01-23 12:39:24 +0100265 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700266 } catch (SQLException e) {
267 Log.w(TAG, "Error loading preview from DB", e);
268 } finally {
269 if (cursor != null) {
270 cursor.close();
271 }
272 }
273 return null;
Michael Jurka05713af2013-01-23 12:39:24 +0100274 }
275
Sunny Goyal27835952017-01-13 12:15:53 -0800276 private Bitmap generatePreview(BaseActivity launcher, WidgetItem item, Bitmap recycle,
Adam Cohen2e6da152015-05-06 11:42:25 -0700277 int previewWidth, int previewHeight) {
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800278 if (item.widgetInfo != null) {
279 return generateWidgetPreview(launcher, item.widgetInfo,
Adam Cohen2e6da152015-05-06 11:42:25 -0700280 previewWidth, recycle, null);
Michael Jurka05713af2013-01-23 12:39:24 +0100281 } else {
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800282 return generateShortcutPreview(launcher, item.activityInfo,
283 previewWidth, previewHeight, recycle);
Michael Jurka05713af2013-01-23 12:39:24 +0100284 }
285 }
286
Hyunyoung Song3e840f42016-03-01 11:57:44 -0800287 /**
288 * Generates the widget preview from either the {@link AppWidgetManagerCompat} or cache
289 * and add badge at the bottom right corner.
290 *
291 * @param launcher
292 * @param info information about the widget
293 * @param maxPreviewWidth width of the preview on either workspace or tray
294 * @param preview bitmap that can be recycled
295 * @param preScaledWidthOut return the width of the returned bitmap
296 * @return
297 */
Sunny Goyal27835952017-01-13 12:15:53 -0800298 public Bitmap generateWidgetPreview(BaseActivity launcher, LauncherAppWidgetProviderInfo info,
Sunny Goyal4cad7532015-03-18 15:56:30 -0700299 int maxPreviewWidth, Bitmap preview, int[] preScaledWidthOut) {
Michael Jurka05713af2013-01-23 12:39:24 +0100300 // Load the preview image if possible
Michael Jurka05713af2013-01-23 12:39:24 +0100301 if (maxPreviewWidth < 0) maxPreviewWidth = Integer.MAX_VALUE;
Michael Jurka05713af2013-01-23 12:39:24 +0100302
303 Drawable drawable = null;
Sunny Goyalffe83f12014-08-14 17:39:34 -0700304 if (info.previewImage != 0) {
Sunny Goyal2570d102016-10-27 11:38:45 -0700305 try {
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800306 drawable = info.loadPreviewImage(mContext, 0);
Sunny Goyal2570d102016-10-27 11:38:45 -0700307 } catch (OutOfMemoryError e) {
308 Log.w(TAG, "Error loading widget preview for: " + info.provider, e);
309 // During OutOfMemoryError, the previous heap stack is not affected. Catching
310 // an OOM error here should be safe & not affect other parts of launcher.
311 drawable = null;
312 }
Adrian Roosfa9ffc22014-05-12 15:59:59 +0200313 if (drawable != null) {
314 drawable = mutateOnMainThread(drawable);
315 } else {
Michael Jurka05713af2013-01-23 12:39:24 +0100316 Log.w(TAG, "Can't load widget preview drawable 0x" +
Sunny Goyalffe83f12014-08-14 17:39:34 -0700317 Integer.toHexString(info.previewImage) + " for provider: " + info.provider);
Michael Jurka05713af2013-01-23 12:39:24 +0100318 }
319 }
320
Sunny Goyal4cad7532015-03-18 15:56:30 -0700321 final boolean widgetPreviewExists = (drawable != null);
Sunny Goyal233ee962015-08-03 13:05:01 -0700322 final int spanX = info.spanX;
323 final int spanY = info.spanY;
Sunny Goyal4cad7532015-03-18 15:56:30 -0700324
Michael Jurka05713af2013-01-23 12:39:24 +0100325 int previewWidth;
326 int previewHeight;
Hyunyoung Song3e840f42016-03-01 11:57:44 -0800327
Michael Jurka05713af2013-01-23 12:39:24 +0100328 if (widgetPreviewExists) {
329 previewWidth = drawable.getIntrinsicWidth();
330 previewHeight = drawable.getIntrinsicHeight();
331 } else {
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800332 DeviceProfile dp = launcher.getDeviceProfile();
333 int tileSize = Math.min(dp.cellWidthPx, dp.cellHeightPx);
334 previewWidth = tileSize * spanX;
335 previewHeight = tileSize * spanY;
Michael Jurka05713af2013-01-23 12:39:24 +0100336 }
337
338 // Scale to fit width only - let the widget preview be clipped in the
339 // vertical dimension
340 float scale = 1f;
341 if (preScaledWidthOut != null) {
342 preScaledWidthOut[0] = previewWidth;
343 }
344 if (previewWidth > maxPreviewWidth) {
Sunny Goyala2441e82017-01-14 13:40:15 -0800345 scale = maxPreviewWidth / (float) (previewWidth);
Michael Jurka05713af2013-01-23 12:39:24 +0100346 }
347 if (scale != 1f) {
348 previewWidth = (int) (scale * previewWidth);
349 previewHeight = (int) (scale * previewHeight);
350 }
351
352 // If a bitmap is passed in, we use it; otherwise, we create a bitmap of the right size
Sunny Goyal4cad7532015-03-18 15:56:30 -0700353 final Canvas c = new Canvas();
Michael Jurka05713af2013-01-23 12:39:24 +0100354 if (preview == null) {
355 preview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
Sunny Goyal4cad7532015-03-18 15:56:30 -0700356 c.setBitmap(preview);
357 } else {
Sunny Goyala2441e82017-01-14 13:40:15 -0800358 // We use the preview bitmap height to determine where the badge will be drawn in the
359 // UI. If its larger than what we need, resize the preview bitmap so that there are
360 // no transparent pixels between the preview and the badge.
361 if (preview.getHeight() > previewHeight) {
362 preview.reconfigure(preview.getWidth(), previewHeight, preview.getConfig());
363 }
Sunny Goyal4cad7532015-03-18 15:56:30 -0700364 // Reusing bitmap. Clear it.
365 c.setBitmap(preview);
366 c.drawColor(0, PorterDuff.Mode.CLEAR);
Michael Jurka05713af2013-01-23 12:39:24 +0100367 }
368
369 // Draw the scaled preview into the final bitmap
Hyunyoung Songb9f932e2015-07-30 15:04:59 -0700370 int x = (preview.getWidth() - previewWidth) / 2;
Michael Jurka05713af2013-01-23 12:39:24 +0100371 if (widgetPreviewExists) {
Sunny Goyal4cad7532015-03-18 15:56:30 -0700372 drawable.setBounds(x, 0, x + previewWidth, previewHeight);
373 drawable.draw(c);
Michael Jurka05713af2013-01-23 12:39:24 +0100374 } else {
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800375 final Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800376 RectF boxRect = drawBoxWithShadow(c, p, previewWidth, previewHeight);
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800377
378 // Draw horizontal and vertical lines to represent individual columns.
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800379 p.setStyle(Paint.Style.STROKE);
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800380 p.setStrokeWidth(mContext.getResources()
381 .getDimension(R.dimen.widget_preview_cell_divider_width));
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800382 p.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
383
384 float t = boxRect.left;
385 float tileSize = boxRect.width() / spanX;
386 for (int i = 1; i < spanX; i++) {
387 t += tileSize;
388 c.drawLine(t, 0, t, previewHeight, p);
Michael Jurka05713af2013-01-23 12:39:24 +0100389 }
Sunny Goyal4cad7532015-03-18 15:56:30 -0700390
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800391 t = boxRect.top;
392 tileSize = boxRect.height() / spanY;
393 for (int i = 1; i < spanY; i++) {
394 t += tileSize;
395 c.drawLine(0, t, previewWidth, t, p);
396 }
Sunny Goyal4cad7532015-03-18 15:56:30 -0700397
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800398 // Draw icon in the center.
Sunny Goyal4cad7532015-03-18 15:56:30 -0700399 try {
Sunny Goyala52ecb02016-12-16 15:04:51 -0800400 Drawable icon = info.getIcon(launcher, mIconCache);
Sunny Goyal4cad7532015-03-18 15:56:30 -0700401 if (icon != null) {
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800402 int appIconSize = launcher.getDeviceProfile().iconSizePx;
403 int iconSize = (int) Math.min(appIconSize * scale,
404 Math.min(boxRect.width(), boxRect.height()));
405
Sunny Goyal1ba7e362015-10-26 10:42:12 -0700406 icon = mutateOnMainThread(icon);
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800407 int hoffset = (previewWidth - iconSize) / 2;
408 int yoffset = (previewHeight - iconSize) / 2;
409 icon.setBounds(hoffset, yoffset, hoffset + iconSize, yoffset + iconSize);
Sunny Goyal4cad7532015-03-18 15:56:30 -0700410 icon.draw(c);
411 }
Sunny Goyal92bbfa12017-02-07 15:06:32 -0800412 } catch (Resources.NotFoundException e) { }
Michael Jurka05713af2013-01-23 12:39:24 +0100413 c.setBitmap(null);
414 }
Sunny Goyala2441e82017-01-14 13:40:15 -0800415 return preview;
Michael Jurka05713af2013-01-23 12:39:24 +0100416 }
417
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800418 private RectF drawBoxWithShadow(Canvas c, Paint p, int width, int height) {
419 Resources res = mContext.getResources();
420 float shadowBlur = res.getDimension(R.dimen.widget_preview_shadow_blur);
421 float keyShadowDistance = res.getDimension(R.dimen.widget_preview_key_shadow_distance);
422 float corner = res.getDimension(R.dimen.widget_preview_corner_radius);
423
424 RectF bounds = new RectF(shadowBlur, shadowBlur,
425 width - shadowBlur, height - shadowBlur - keyShadowDistance);
426 p.setColor(Color.WHITE);
427
428 // Key shadow
429 p.setShadowLayer(shadowBlur, 0, keyShadowDistance,
430 ShadowGenerator.KEY_SHADOW_ALPHA << 24);
431 c.drawRoundRect(bounds, corner, corner, p);
432
433 // Ambient shadow
434 p.setShadowLayer(shadowBlur, 0, 0,
435 ColorUtils.setAlphaComponent(Color.BLACK, ShadowGenerator.AMBIENT_SHADOW_ALPHA));
436 c.drawRoundRect(bounds, corner, corner, p);
437
438 p.clearShadowLayer();
439 return bounds;
440 }
441
Sunny Goyal782f0c92017-01-19 10:27:54 -0800442 private Bitmap generateShortcutPreview(BaseActivity launcher, ShortcutConfigActivityInfo info,
443 int maxWidth, int maxHeight, Bitmap preview) {
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800444 int iconSize = launcher.getDeviceProfile().iconSizePx;
445 int padding = launcher.getResources()
446 .getDimensionPixelSize(R.dimen.widget_preview_shortcut_padding);
447
448 int size = iconSize + 2 * padding;
449 if (maxHeight < size || maxWidth < size) {
450 throw new RuntimeException("Max size is too small for preview");
451 }
Sunny Goyal4cad7532015-03-18 15:56:30 -0700452 final Canvas c = new Canvas();
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800453 if (preview == null || preview.getWidth() < size || preview.getHeight() < size) {
454 preview = Bitmap.createBitmap(size, size, Config.ARGB_8888);
Sunny Goyal4cad7532015-03-18 15:56:30 -0700455 c.setBitmap(preview);
Sunny Goyal4cad7532015-03-18 15:56:30 -0700456 } else {
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800457 if (preview.getWidth() > size || preview.getHeight() > size) {
458 preview.reconfigure(size, size, preview.getConfig());
459 }
460
Sunny Goyal4cad7532015-03-18 15:56:30 -0700461 // Reusing bitmap. Clear it.
462 c.setBitmap(preview);
463 c.drawColor(0, PorterDuff.Mode.CLEAR);
Michael Jurka05713af2013-01-23 12:39:24 +0100464 }
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800465 Paint p = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
466 RectF boxRect = drawBoxWithShadow(c, p, size, size);
Michael Jurka05713af2013-01-23 12:39:24 +0100467
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800468 Bitmap icon = LauncherIcons.createScaledBitmapWithoutShadow(
469 mutateOnMainThread(info.getFullResIcon(mIconCache)), mContext);
470 Rect src = new Rect(0, 0, icon.getWidth(), icon.getHeight());
Sunny Goyal4cad7532015-03-18 15:56:30 -0700471
Sunny Goyal7d87cb12017-02-13 10:44:43 -0800472 boxRect.set(0, 0, iconSize, iconSize);
473 boxRect.offset(padding, padding);
474 c.drawBitmap(icon, src, boxRect, p);
Michael Jurka05713af2013-01-23 12:39:24 +0100475 c.setBitmap(null);
Michael Jurka05713af2013-01-23 12:39:24 +0100476 return preview;
477 }
478
Adrian Roos65d60e22014-04-15 21:07:49 +0200479 private Drawable mutateOnMainThread(final Drawable drawable) {
480 try {
481 return mMainThreadExecutor.submit(new Callable<Drawable>() {
482 @Override
483 public Drawable call() throws Exception {
484 return drawable.mutate();
485 }
486 }).get();
487 } catch (InterruptedException e) {
488 Thread.currentThread().interrupt();
489 throw new RuntimeException(e);
490 } catch (ExecutionException e) {
491 throw new RuntimeException(e);
492 }
493 }
Adrian Roos1f375ab2014-04-28 18:26:38 +0200494
Adrian Roos1f375ab2014-04-28 18:26:38 +0200495 /**
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700496 * @return an array of containing versionCode and lastUpdatedTime for the package.
Adrian Roos1f375ab2014-04-28 18:26:38 +0200497 */
Sunny Goyal316490e2015-06-02 09:38:28 -0700498 @Thunk long[] getPackageVersion(String packageName) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700499 synchronized (mPackageVersions) {
500 long[] versions = mPackageVersions.get(packageName);
501 if (versions == null) {
502 versions = new long[2];
Adrian Roos1f375ab2014-04-28 18:26:38 +0200503 try {
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800504 PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName,
505 PackageManager.GET_UNINSTALLED_PACKAGES);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700506 versions[0] = info.versionCode;
507 versions[1] = info.lastUpdateTime;
508 } catch (NameNotFoundException e) {
509 Log.e(TAG, "PackageInfo not found", e);
510 }
511 mPackageVersions.put(packageName, versions);
512 }
513 return versions;
514 }
515 }
516
Sunny Goyalc65a0082017-03-08 14:49:55 -0800517 public class PreviewLoadTask extends AsyncTask<Void, Void, Bitmap>
518 implements CancellationSignal.OnCancelListener {
Sunny Goyal316490e2015-06-02 09:38:28 -0700519 @Thunk final WidgetCacheKey mKey;
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800520 private final WidgetItem mInfo;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700521 private final int mPreviewHeight;
522 private final int mPreviewWidth;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700523 private final WidgetCell mCaller;
Sunny Goyala2441e82017-01-14 13:40:15 -0800524 private final BaseActivity mActivity;
Sunny Goyal316490e2015-06-02 09:38:28 -0700525 @Thunk long[] mVersions;
526 @Thunk Bitmap mBitmapToRecycle;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700527
Sunny Goyal4ddc4012016-03-10 12:02:29 -0800528 PreviewLoadTask(WidgetCacheKey key, WidgetItem info, int previewWidth,
Hyunyoung Song3f471442015-04-08 19:01:34 -0700529 int previewHeight, WidgetCell caller) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700530 mKey = key;
531 mInfo = info;
532 mPreviewHeight = previewHeight;
533 mPreviewWidth = previewWidth;
534 mCaller = caller;
Sunny Goyala2441e82017-01-14 13:40:15 -0800535 mActivity = BaseActivity.fromContext(mCaller.getContext());
Hyunyoung Song3f471442015-04-08 19:01:34 -0700536 if (DEBUG) {
537 Log.d(TAG, String.format("%s, %s, %d, %d",
538 mKey, mInfo, mPreviewHeight, mPreviewWidth));
539 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700540 }
541
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700542 @Override
543 protected Bitmap doInBackground(Void... params) {
544 Bitmap unusedBitmap = null;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700545
Hyunyoung Songf00d02b2015-06-05 13:30:19 -0700546 // If already cancelled before this gets to run in the background, then return early
547 if (isCancelled()) {
548 return null;
549 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700550 synchronized (mUnusedBitmaps) {
Hyunyoung Songf00d02b2015-06-05 13:30:19 -0700551 // Check if we can re-use a bitmap
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700552 for (Bitmap candidate : mUnusedBitmaps) {
553 if (candidate != null && candidate.isMutable() &&
554 candidate.getWidth() == mPreviewWidth &&
555 candidate.getHeight() == mPreviewHeight) {
556 unusedBitmap = candidate;
Hyunyoung Songf00d02b2015-06-05 13:30:19 -0700557 mUnusedBitmaps.remove(unusedBitmap);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700558 break;
559 }
560 }
Hyunyoung Songf00d02b2015-06-05 13:30:19 -0700561 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700562
Hyunyoung Songf00d02b2015-06-05 13:30:19 -0700563 // creating a bitmap is expensive. Do not do this inside synchronized block.
564 if (unusedBitmap == null) {
565 unusedBitmap = Bitmap.createBitmap(mPreviewWidth, mPreviewHeight, Config.ARGB_8888);
Adrian Roos1f375ab2014-04-28 18:26:38 +0200566 }
Winson Chung05304db2015-05-18 16:53:20 -0700567 // If cancelled now, don't bother reading the preview from the DB
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700568 if (isCancelled()) {
Winson Chung05304db2015-05-18 16:53:20 -0700569 return unusedBitmap;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700570 }
Winson Chung05304db2015-05-18 16:53:20 -0700571 Bitmap preview = readFromDb(mKey, unusedBitmap, this);
572 // Only consider generating the preview if we have not cancelled the task already
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700573 if (!isCancelled() && preview == null) {
574 // Fetch the version info before we generate the preview, so that, in-case the
575 // app was updated while we are generating the preview, we use the old version info,
576 // which would gets re-written next time.
Sunny Goyal65513ba2017-01-20 11:54:25 -0800577 boolean persistable = mInfo.activityInfo == null
578 || mInfo.activityInfo.isPersistable();
579 mVersions = persistable ? getPackageVersion(mKey.componentName.getPackageName())
580 : null;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700581
582 // it's not in the db... we need to generate it
Sunny Goyala2441e82017-01-14 13:40:15 -0800583 preview = generatePreview(mActivity, mInfo, unusedBitmap, mPreviewWidth, mPreviewHeight);
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700584 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700585 return preview;
586 }
587
588 @Override
Winson Chung05304db2015-05-18 16:53:20 -0700589 protected void onPostExecute(final Bitmap preview) {
590 mCaller.applyPreview(preview);
591
592 // Write the generated preview to the DB in the worker thread
593 if (mVersions != null) {
594 mWorkerHandler.post(new Runnable() {
595 @Override
596 public void run() {
597 if (!isCancelled()) {
598 // If we are still using this preview, then write it to the DB and then
599 // let the normal clear mechanism recycle the bitmap
600 writeToDb(mKey, mVersions, preview);
601 mBitmapToRecycle = preview;
602 } else {
603 // If we've already cancelled, then skip writing the bitmap to the DB
604 // and manually add the bitmap back to the recycled set
605 synchronized (mUnusedBitmaps) {
606 mUnusedBitmaps.add(preview);
607 }
608 }
609 }
610 });
611 } else {
612 // If we don't need to write to disk, then ensure the preview gets recycled by
613 // the normal clear mechanism
614 mBitmapToRecycle = preview;
615 }
616 }
617
618 @Override
Hyunyoung Songe98f4a42015-06-16 10:45:24 -0700619 protected void onCancelled(final Bitmap preview) {
Winson Chung05304db2015-05-18 16:53:20 -0700620 // If we've cancelled while the task is running, then can return the bitmap to the
621 // recycled set immediately. Otherwise, it will be recycled after the preview is written
622 // to disk.
623 if (preview != null) {
Hyunyoung Songe98f4a42015-06-16 10:45:24 -0700624 mWorkerHandler.post(new Runnable() {
625 @Override
626 public void run() {
627 synchronized (mUnusedBitmaps) {
628 mUnusedBitmaps.add(preview);
629 }
630 }
631 });
Winson Chung05304db2015-05-18 16:53:20 -0700632 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700633 }
Sunny Goyalc65a0082017-03-08 14:49:55 -0800634
635 @Override
636 public void onCancel() {
637 cancel(true);
638
639 // This only handles the case where the PreviewLoadTask is cancelled after the task has
640 // successfully completed (including having written to disk when necessary). In the
641 // other cases where it is cancelled while the task is running, it will be cleaned up
642 // in the tasks's onCancelled() call, and if cancelled while the task is writing to
643 // disk, it will be cancelled in the task's onPostExecute() call.
644 if (mBitmapToRecycle != null) {
645 mWorkerHandler.post(new Runnable() {
646 @Override
647 public void run() {
648 synchronized (mUnusedBitmaps) {
649 mUnusedBitmaps.add(mBitmapToRecycle);
650 }
651 mBitmapToRecycle = null;
652 }
653 });
654 }
655 }
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700656 }
657
658 private static final class WidgetCacheKey extends ComponentKey {
659
Sunny Goyal316490e2015-06-02 09:38:28 -0700660 @Thunk final String size;
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700661
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800662 public WidgetCacheKey(ComponentName componentName, UserHandle user, String size) {
Sunny Goyal5b0e6692015-03-19 14:31:19 -0700663 super(componentName, user);
664 this.size = size;
665 }
666
667 @Override
668 public int hashCode() {
669 return super.hashCode() ^ size.hashCode();
670 }
671
672 @Override
673 public boolean equals(Object o) {
674 return super.equals(o) && ((WidgetCacheKey) o).size.equals(size);
Adrian Roos1f375ab2014-04-28 18:26:38 +0200675 }
676 }
Michael Jurka05713af2013-01-23 12:39:24 +0100677}