src/com/android/launcher3/WidgetPreviewLoader.java

   1 package com.android.launcher3;
   2
   3 import android.content.ComponentName;
   4 import android.content.ContentValues;
   5 import android.content.Context;
   6 import android.content.pm.PackageInfo;
   7 import android.content.pm.PackageManager.NameNotFoundException;
   8 import android.content.pm.ResolveInfo;
   9 import android.content.res.Resources;
  10 import android.database.Cursor;
  11 import android.database.SQLException;
  12 import android.database.sqlite.SQLiteDatabase;
  13 import android.database.sqlite.SQLiteOpenHelper;
  14 import android.graphics.Bitmap;
  15 import android.graphics.Bitmap.Config;
  16 import android.graphics.BitmapFactory;
  17 import android.graphics.Canvas;
  18 import android.graphics.ColorMatrix;
  19 import android.graphics.ColorMatrixColorFilter;
  20 import android.graphics.Paint;
  21 import android.graphics.PorterDuff;
  22 import android.graphics.Rect;
  23 import android.graphics.RectF;
  24 import android.graphics.drawable.BitmapDrawable;
  25 import android.graphics.drawable.Drawable;
  26 import android.os.AsyncTask;
  27 import android.os.Handler;
  28 import android.util.Log;
  29 import android.util.LongSparseArray;
  30
  31 import com.android.launcher3.compat.AppWidgetManagerCompat;
  32 import com.android.launcher3.compat.UserHandleCompat;
  33 import com.android.launcher3.compat.UserManagerCompat;
  34 import com.android.launcher3.util.ComponentKey;
  35 import com.android.launcher3.util.Thunk;
  36 import com.android.launcher3.widget.WidgetCell;
  37
  38 import java.util.ArrayList;
  39 import java.util.Collections;
  40 import java.util.HashMap;
  41 import java.util.HashSet;
  42 import java.util.Set;
  43 import java.util.WeakHashMap;
  44 import java.util.concurrent.Callable;
  45 import java.util.concurrent.ExecutionException;
  46
  47 public class WidgetPreviewLoader {
  48
  49     private static final String TAG = "WidgetPreviewLoader";
  50     private static final boolean DEBUG = false;
  51
  52     private static final float WIDGET_PREVIEW_ICON_PADDING_PERCENTAGE = 0.25f;
  53
  54     private final HashMap<String, long[]> mPackageVersions = new HashMap<>();
  55
  56     /**
  57      * Weak reference objects, do not prevent their referents from being made finalizable,
  58      * finalized, and then reclaimed.
  59      * Note: synchronized block used for this variable is expensive and the block should always
  60      * be posted to a background thread.
  61      */
  62     @Thunk final Set<Bitmap> mUnusedBitmaps =
  63             Collections.newSetFromMap(new WeakHashMap<Bitmap, Boolean>());
  64
  65     private final Context mContext;
  66     private final IconCache mIconCache;
  67     private final UserManagerCompat mUserManager;
  68     private final AppWidgetManagerCompat mManager;
  69     private final CacheDb mDb;
  70     private final int mProfileBadgeMargin;
  71
  72     private final MainThreadExecutor mMainThreadExecutor = new MainThreadExecutor();
  73     @Thunk final Handler mWorkerHandler;
  74
  75     public WidgetPreviewLoader(Context context, IconCache iconCache) {
  76         mContext = context;
  77         mIconCache = iconCache;
  78         mManager = AppWidgetManagerCompat.getInstance(context);
  79         mUserManager = UserManagerCompat.getInstance(context);
  80         mDb = new CacheDb(context);
  81         mWorkerHandler = new Handler(LauncherModel.getWorkerLooper());
  82         mProfileBadgeMargin = context.getResources()
  83                 .getDimensionPixelSize(R.dimen.profile_badge_margin);
  84     }
  85
  86     /**
  87      * Generates the widget preview on {@link AsyncTask#THREAD_POOL_EXECUTOR}. Must be
  88      * called on UI thread
  89      *
  90      * @param o either {@link LauncherAppWidgetProviderInfo} or {@link ResolveInfo}
  91      * @return a request id which can be used to cancel the request.
  92      */
  93     public PreviewLoadRequest getPreview(final Object o, int previewWidth,
  94             int previewHeight, WidgetCell caller) {
  95         String size = previewWidth + "x" + previewHeight;
  96         WidgetCacheKey key = getObjectKey(o, size);
  97
  98         PreviewLoadTask task = new PreviewLoadTask(key, o, previewWidth, previewHeight, caller);
  99         task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
 100         return new PreviewLoadRequest(task);
 101     }
 102
 103     /**
 104      * The DB holds the generated previews for various components. Previews can also have different
 105      * sizes (landscape vs portrait).
 106      */
 107     private static class CacheDb extends SQLiteOpenHelper {
 108         private static final int DB_VERSION = 3;
 109
 110         private static final String TABLE_NAME = "shortcut_and_widget_previews";
 111         private static final String COLUMN_COMPONENT = "componentName";
 112         private static final String COLUMN_USER = "profileId";
 113         private static final String COLUMN_SIZE = "size";
 114         private static final String COLUMN_PACKAGE = "packageName";
 115         private static final String COLUMN_LAST_UPDATED = "lastUpdated";
 116         private static final String COLUMN_VERSION = "version";
 117         private static final String COLUMN_PREVIEW_BITMAP = "preview_bitmap";
 118
 119         public CacheDb(Context context) {
 120             super(context, LauncherFiles.WIDGET_PREVIEWS_DB, null, DB_VERSION);
 121         }
 122
 123         @Override
 124         public void onCreate(SQLiteDatabase database) {
 125             database.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " (" +
 126                     COLUMN_COMPONENT + " TEXT NOT NULL, " +
 127                     COLUMN_USER + " INTEGER NOT NULL, " +
 128                     COLUMN_SIZE + " TEXT NOT NULL, " +
 129                     COLUMN_PACKAGE + " TEXT NOT NULL, " +
 130                     COLUMN_LAST_UPDATED + " INTEGER NOT NULL DEFAULT 0, " +
 131                     COLUMN_VERSION + " INTEGER NOT NULL DEFAULT 0, " +
 132                     COLUMN_PREVIEW_BITMAP + " BLOB, " +
 133                     "PRIMARY KEY (" + COLUMN_COMPONENT + ", " + COLUMN_USER + ", " + COLUMN_SIZE + ") " +
 134                     ");");
 135         }
 136
 137         @Override
 138         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 139             if (oldVersion != newVersion) {
 140                 clearDB(db);
 141             }
 142         }
 143
 144         @Override
 145         public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 146             if (oldVersion != newVersion) {
 147                 clearDB(db);
 148             }
 149         }
 150
 151         private void clearDB(SQLiteDatabase db) {
 152             db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
 153             onCreate(db);
 154         }
 155     }
 156
 157     private WidgetCacheKey getObjectKey(Object o, String size) {
 158         // should cache the string builder
 159         if (o instanceof LauncherAppWidgetProviderInfo) {
 160             LauncherAppWidgetProviderInfo info = (LauncherAppWidgetProviderInfo) o;
 161             return new WidgetCacheKey(info.provider, mManager.getUser(info), size);
 162         } else {
 163             ResolveInfo info = (ResolveInfo) o;
 164             return new WidgetCacheKey(
 165                     new ComponentName(info.activityInfo.packageName, info.activityInfo.name),
 166                     UserHandleCompat.myUserHandle(), size);
 167         }
 168     }
 169
 170     @Thunk void writeToDb(WidgetCacheKey key, long[] versions, Bitmap preview) {
 171         ContentValues values = new ContentValues();
 172         values.put(CacheDb.COLUMN_COMPONENT, key.componentName.flattenToShortString());
 173         values.put(CacheDb.COLUMN_USER, mUserManager.getSerialNumberForUser(key.user));
 174         values.put(CacheDb.COLUMN_SIZE, key.size);
 175         values.put(CacheDb.COLUMN_PACKAGE, key.componentName.getPackageName());
 176         values.put(CacheDb.COLUMN_VERSION, versions[0]);
 177         values.put(CacheDb.COLUMN_LAST_UPDATED, versions[1]);
 178         values.put(CacheDb.COLUMN_PREVIEW_BITMAP, Utilities.flattenBitmap(preview));
 179
 180         try {
 181             mDb.getWritableDatabase().insertWithOnConflict(CacheDb.TABLE_NAME, null, values,
 182                     SQLiteDatabase.CONFLICT_REPLACE);
 183         } catch (SQLException e) {
 184             Log.e(TAG, "Error saving image to DB", e);
 185         }
 186     }
 187
 188     public void removePackage(String packageName, UserHandleCompat user) {
 189         removePackage(packageName, user, mUserManager.getSerialNumberForUser(user));
 190     }
 191
 192     private void removePackage(String packageName, UserHandleCompat user, long userSerial) {
 193         synchronized(mPackageVersions) {
 194             mPackageVersions.remove(packageName);
 195         }
 196
 197         try {
 198             mDb.getWritableDatabase().delete(CacheDb.TABLE_NAME,
 199                     CacheDb.COLUMN_PACKAGE + " = ? AND " + CacheDb.COLUMN_USER + " = ?",
 200                     new String[] {packageName, Long.toString(userSerial)});
 201         } catch (SQLException e) {
 202             Log.e(TAG, "Unable to delete items from DB", e);
 203         }
 204     }
 205
 206     /**
 207      * Updates the persistent DB:
 208      *   1. Any preview generated for an old package version is removed
 209      *   2. Any preview for an absent package is removed
 210      * This ensures that we remove entries for packages which changed while the launcher was dead.
 211      */
 212     public void removeObsoletePreviews(ArrayList<Object> list) {
 213         Utilities.assertWorkerThread();
 214
 215         LongSparseArray<UserHandleCompat> userIdCache = new LongSparseArray<>();
 216         LongSparseArray<HashSet<String>> validPackages = new LongSparseArray<>();
 217
 218         for (Object obj : list) {
 219             final UserHandleCompat user;
 220             final String pkg;
 221             if (obj instanceof ResolveInfo) {
 222                 user = UserHandleCompat.myUserHandle();
 223                 pkg = ((ResolveInfo) obj).activityInfo.packageName;
 224             } else {
 225                 LauncherAppWidgetProviderInfo info = (LauncherAppWidgetProviderInfo) obj;
 226                 user = mManager.getUser(info);
 227                 pkg = info.provider.getPackageName();
 228             }
 229
 230             int userIdIndex = userIdCache.indexOfValue(user);
 231             final long userId;
 232             if (userIdIndex < 0) {
 233                 userId = mUserManager.getSerialNumberForUser(user);
 234                 userIdCache.put(userId, user);
 235             } else {
 236                 userId = userIdCache.keyAt(userIdIndex);
 237             }
 238
 239             HashSet<String> packages = validPackages.get(userId);
 240             if (packages == null) {
 241                 packages = new HashSet<>();
 242                 validPackages.put(userId, packages);
 243             }
 244             packages.add(pkg);
 245         }
 246
 247         LongSparseArray<HashSet<String>> packagesToDelete = new LongSparseArray<>();
 248         Cursor c = null;
 249         try {
 250             c = mDb.getReadableDatabase().query(CacheDb.TABLE_NAME,
 251                     new String[] {CacheDb.COLUMN_USER, CacheDb.COLUMN_PACKAGE,
 252                         CacheDb.COLUMN_LAST_UPDATED, CacheDb.COLUMN_VERSION},
 253                     null, null, null, null, null);
 254             while (c.moveToNext()) {
 255                 long userId = c.getLong(0);
 256                 String pkg = c.getString(1);
 257                 long lastUpdated = c.getLong(2);
 258                 long version = c.getLong(3);
 259
 260                 HashSet<String> packages = validPackages.get(userId);
 261                 if (packages != null && packages.contains(pkg)) {
 262                     long[] versions = getPackageVersion(pkg);
 263                     if (versions[0] == version && versions[1] == lastUpdated) {
 264                         // Every thing checks out
 265                         continue;
 266                     }
 267                 }
 268
 269                 // We need to delete this package.
 270                 packages = packagesToDelete.get(userId);
 271                 if (packages == null) {
 272                     packages = new HashSet<>();
 273                     packagesToDelete.put(userId, packages);
 274                 }
 275                 packages.add(pkg);
 276             }
 277
 278             for (int i = 0; i < packagesToDelete.size(); i++) {
 279                 long userId = packagesToDelete.keyAt(i);
 280                 UserHandleCompat user = mUserManager.getUserForSerialNumber(userId);
 281                 for (String pkg : packagesToDelete.valueAt(i)) {
 282                     removePackage(pkg, user, userId);
 283                 }
 284             }
 285         } catch (SQLException e) {
 286             Log.e(TAG, "Error updatating widget previews", e);
 287         } finally {
 288             if (c != null) {
 289                 c.close();
 290             }
 291         }
 292     }
 293
 294     /**
 295      * Reads the preview bitmap from the DB or null if the preview is not in the DB.
 296      */
 297     @Thunk Bitmap readFromDb(WidgetCacheKey key, Bitmap recycle, PreviewLoadTask loadTask) {
 298         Cursor cursor = null;
 299         try {
 300             cursor = mDb.getReadableDatabase().query(
 301                     CacheDb.TABLE_NAME,
 302                     new String[] { CacheDb.COLUMN_PREVIEW_BITMAP },
 303                     CacheDb.COLUMN_COMPONENT + " = ? AND " + CacheDb.COLUMN_USER + " = ? AND " + CacheDb.COLUMN_SIZE + " = ?",
 304                     new String[] {
 305                             key.componentName.flattenToString(),
 306                             Long.toString(mUserManager.getSerialNumberForUser(key.user)),
 307                             key.size
 308                     },
 309                     null, null, null);
 310             // If cancelled, skip getting the blob and decoding it into a bitmap
 311             if (loadTask.isCancelled()) {
 312                 return null;
 313             }
 314             if (cursor.moveToNext()) {
 315                 byte[] blob = cursor.getBlob(0);
 316                 BitmapFactory.Options opts = new BitmapFactory.Options();
 317                 opts.inBitmap = recycle;
 318                 try {
 319                     if (!loadTask.isCancelled()) {
 320                         return BitmapFactory.decodeByteArray(blob, 0, blob.length, opts);
 321                     }
 322                 } catch (Exception e) {
 323                     return null;
 324                 }
 325             }
 326         } catch (SQLException e) {
 327             Log.w(TAG, "Error loading preview from DB", e);
 328         } finally {
 329             if (cursor != null) {
 330                 cursor.close();
 331             }
 332         }
 333         return null;
 334     }
 335
 336     @Thunk Bitmap generatePreview(Launcher launcher, Object info, Bitmap recycle,
 337             int previewWidth, int previewHeight) {
 338         if (info instanceof LauncherAppWidgetProviderInfo) {
 339             return generateWidgetPreview(launcher, (LauncherAppWidgetProviderInfo) info,
 340                     previewWidth, recycle, null);
 341         } else {
 342             return generateShortcutPreview(launcher,
 343                     (ResolveInfo) info, previewWidth, previewHeight, recycle);
 344         }
 345     }
 346
 347     public Bitmap generateWidgetPreview(Launcher launcher, LauncherAppWidgetProviderInfo info,
 348             int maxPreviewWidth, Bitmap preview, int[] preScaledWidthOut) {
 349         // Load the preview image if possible
 350         if (maxPreviewWidth < 0) maxPreviewWidth = Integer.MAX_VALUE;
 351
 352         Drawable drawable = null;
 353         if (info.previewImage != 0) {
 354             drawable = mManager.loadPreview(info);
 355             if (drawable != null) {
 356                 drawable = mutateOnMainThread(drawable);
 357             } else {
 358                 Log.w(TAG, "Can't load widget preview drawable 0x" +
 359                         Integer.toHexString(info.previewImage) + " for provider: " + info.provider);
 360             }
 361         }
 362
 363         final boolean widgetPreviewExists = (drawable != null);
 364         final int spanX = info.spanX;
 365         final int spanY = info.spanY;
 366
 367         int previewWidth;
 368         int previewHeight;
 369         Bitmap tileBitmap = null;
 370
 371         if (widgetPreviewExists) {
 372             previewWidth = drawable.getIntrinsicWidth();
 373             previewHeight = drawable.getIntrinsicHeight();
 374         } else {
 375             // Generate a preview image if we couldn't load one
 376             tileBitmap = ((BitmapDrawable) mContext.getResources().getDrawable(
 377                     R.drawable.widget_tile)).getBitmap();
 378             previewWidth = tileBitmap.getWidth() * spanX;
 379             previewHeight = tileBitmap.getHeight() * spanY;
 380         }
 381
 382         // Scale to fit width only - let the widget preview be clipped in the
 383         // vertical dimension
 384         float scale = 1f;
 385         if (preScaledWidthOut != null) {
 386             preScaledWidthOut[0] = previewWidth;
 387         }
 388         if (previewWidth > maxPreviewWidth) {
 389             scale = (maxPreviewWidth - 2 * mProfileBadgeMargin) / (float) (previewWidth);
 390         }
 391         if (scale != 1f) {
 392             previewWidth = (int) (scale * previewWidth);
 393             previewHeight = (int) (scale * previewHeight);
 394         }
 395
 396         // If a bitmap is passed in, we use it; otherwise, we create a bitmap of the right size
 397         final Canvas c = new Canvas();
 398         if (preview == null) {
 399             preview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
 400             c.setBitmap(preview);
 401         } else {
 402             // Reusing bitmap. Clear it.
 403             c.setBitmap(preview);
 404             c.drawColor(0, PorterDuff.Mode.CLEAR);
 405         }
 406
 407         // Draw the scaled preview into the final bitmap
 408         int x = (preview.getWidth() - previewWidth) / 2;
 409         if (widgetPreviewExists) {
 410             drawable.setBounds(x, 0, x + previewWidth, previewHeight);
 411             drawable.draw(c);
 412         } else {
 413             final Paint p = new Paint();
 414             p.setFilterBitmap(true);
 415             int appIconSize = launcher.getDeviceProfile().iconSizePx;
 416
 417             // draw the spanX x spanY tiles
 418             final Rect src = new Rect(0, 0, tileBitmap.getWidth(), tileBitmap.getHeight());
 419
 420             float tileW = scale * tileBitmap.getWidth();
 421             float tileH = scale * tileBitmap.getHeight();
 422             final RectF dst = new RectF(0, 0, tileW, tileH);
 423
 424             float tx = x;
 425             for (int i = 0; i < spanX; i++, tx += tileW) {
 426                 float ty = 0;
 427                 for (int j = 0; j < spanY; j++, ty += tileH) {
 428                     dst.offsetTo(tx, ty);
 429                     c.drawBitmap(tileBitmap, src, dst, p);
 430                 }
 431             }
 432
 433             // Draw the icon in the top left corner
 434             // TODO: use top right for RTL
 435             int minOffset = (int) (appIconSize * WIDGET_PREVIEW_ICON_PADDING_PERCENTAGE);
 436             int smallestSide = Math.min(previewWidth, previewHeight);
 437             float iconScale = Math.min((float) smallestSide / (appIconSize + 2 * minOffset), scale);
 438
 439             try {
 440                 Drawable icon = mutateOnMainThread(mManager.loadIcon(info, mIconCache));
 441                 if (icon != null) {
 442                     int hoffset = (int) ((tileW - appIconSize * iconScale) / 2) + x;
 443                     int yoffset = (int) ((tileH - appIconSize * iconScale) / 2);
 444                     icon.setBounds(hoffset, yoffset,
 445                             hoffset + (int) (appIconSize * iconScale),
 446                             yoffset + (int) (appIconSize * iconScale));
 447                     icon.draw(c);
 448                 }
 449             } catch (Resources.NotFoundException e) { }
 450             c.setBitmap(null);
 451         }
 452         int imageHeight = Math.min(preview.getHeight(), previewHeight + mProfileBadgeMargin);
 453         return mManager.getBadgeBitmap(info, preview, imageHeight);
 454     }
 455
 456     private Bitmap generateShortcutPreview(
 457             Launcher launcher, ResolveInfo info, int maxWidth, int maxHeight, Bitmap preview) {
 458         final Canvas c = new Canvas();
 459         if (preview == null) {
 460             preview = Bitmap.createBitmap(maxWidth, maxHeight, Config.ARGB_8888);
 461             c.setBitmap(preview);
 462         } else if (preview.getWidth() != maxWidth || preview.getHeight() != maxHeight) {
 463             throw new RuntimeException("Improperly sized bitmap passed as argument");
 464         } else {
 465             // Reusing bitmap. Clear it.
 466             c.setBitmap(preview);
 467             c.drawColor(0, PorterDuff.Mode.CLEAR);
 468         }
 469
 470         Drawable icon = mutateOnMainThread(mIconCache.getFullResIcon(info.activityInfo));
 471         icon.setFilterBitmap(true);
 472
 473         // Draw a desaturated/scaled version of the icon in the background as a watermark
 474         ColorMatrix colorMatrix = new ColorMatrix();
 475         colorMatrix.setSaturation(0);
 476         icon.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
 477         icon.setAlpha((int) (255 * 0.06f));
 478
 479         Resources res = mContext.getResources();
 480         int paddingTop = res.getDimensionPixelOffset(R.dimen.shortcut_preview_padding_top);
 481         int paddingLeft = res.getDimensionPixelOffset(R.dimen.shortcut_preview_padding_left);
 482         int paddingRight = res.getDimensionPixelOffset(R.dimen.shortcut_preview_padding_right);
 483         int scaledIconWidth = (maxWidth - paddingLeft - paddingRight);
 484         icon.setBounds(paddingLeft, paddingTop,
 485                 paddingLeft + scaledIconWidth, paddingTop + scaledIconWidth);
 486         icon.draw(c);
 487
 488         // Draw the final icon at top left corner.
 489         // TODO: use top right for RTL
 490         int appIconSize = launcher.getDeviceProfile().iconSizePx;
 491
 492         icon.setAlpha(255);
 493         icon.setColorFilter(null);
 494         icon.setBounds(0, 0, appIconSize, appIconSize);
 495         icon.draw(c);
 496
 497         c.setBitmap(null);
 498         return preview;
 499     }
 500
 501     private Drawable mutateOnMainThread(final Drawable drawable) {
 502         try {
 503             return mMainThreadExecutor.submit(new Callable<Drawable>() {
 504                 @Override
 505                 public Drawable call() throws Exception {
 506                     return drawable.mutate();
 507                 }
 508             }).get();
 509         } catch (InterruptedException e) {
 510             Thread.currentThread().interrupt();
 511             throw new RuntimeException(e);
 512         } catch (ExecutionException e) {
 513             throw new RuntimeException(e);
 514         }
 515     }
 516
 517     /**
 518      * @return an array of containing versionCode and lastUpdatedTime for the package.
 519      */
 520     @Thunk long[] getPackageVersion(String packageName) {
 521         synchronized (mPackageVersions) {
 522             long[] versions = mPackageVersions.get(packageName);
 523             if (versions == null) {
 524                 versions = new long[2];
 525                 try {
 526                     PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName, 0);
 527                     versions[0] = info.versionCode;
 528                     versions[1] = info.lastUpdateTime;
 529                 } catch (NameNotFoundException e) {
 530                     Log.e(TAG, "PackageInfo not found", e);
 531                 }
 532                 mPackageVersions.put(packageName, versions);
 533             }
 534             return versions;
 535         }
 536     }
 537
 538     /**
 539      * A request Id which can be used by the client to cancel any request.
 540      */
 541     public class PreviewLoadRequest {
 542
 543         @Thunk final PreviewLoadTask mTask;
 544
 545         public PreviewLoadRequest(PreviewLoadTask task) {
 546             mTask = task;
 547         }
 548
 549         public void cleanup() {
 550             if (mTask != null) {
 551                 mTask.cancel(true);
 552             }
 553
 554             // This only handles the case where the PreviewLoadTask is cancelled after the task has
 555             // successfully completed (including having written to disk when necessary).  In the
 556             // other cases where it is cancelled while the task is running, it will be cleaned up
 557             // in the tasks's onCancelled() call, and if cancelled while the task is writing to
 558             // disk, it will be cancelled in the task's onPostExecute() call.
 559             if (mTask.mBitmapToRecycle != null) {
 560                 mWorkerHandler.post(new Runnable() {
 561                     @Override
 562                     public void run() {
 563                         synchronized (mUnusedBitmaps) {
 564                             mUnusedBitmaps.add(mTask.mBitmapToRecycle);
 565                         }
 566                         mTask.mBitmapToRecycle = null;
 567                     }
 568                 });
 569             }
 570         }
 571     }
 572
 573     public class PreviewLoadTask extends AsyncTask<Void, Void, Bitmap> {
 574         @Thunk final WidgetCacheKey mKey;
 575         private final Object mInfo;
 576         private final int mPreviewHeight;
 577         private final int mPreviewWidth;
 578         private final WidgetCell mCaller;
 579         @Thunk long[] mVersions;
 580         @Thunk Bitmap mBitmapToRecycle;
 581
 582         PreviewLoadTask(WidgetCacheKey key, Object info, int previewWidth,
 583                 int previewHeight, WidgetCell caller) {
 584             mKey = key;
 585             mInfo = info;
 586             mPreviewHeight = previewHeight;
 587             mPreviewWidth = previewWidth;
 588             mCaller = caller;
 589             if (DEBUG) {
 590                 Log.d(TAG, String.format("%s, %s, %d, %d",
 591                         mKey, mInfo, mPreviewHeight, mPreviewWidth));
 592             }
 593         }
 594
 595         @Override
 596         protected Bitmap doInBackground(Void... params) {
 597             Bitmap unusedBitmap = null;
 598
 599             // If already cancelled before this gets to run in the background, then return early
 600             if (isCancelled()) {
 601                 return null;
 602             }
 603             synchronized (mUnusedBitmaps) {
 604                 // Check if we can re-use a bitmap
 605                 for (Bitmap candidate : mUnusedBitmaps) {
 606                     if (candidate != null && candidate.isMutable() &&
 607                             candidate.getWidth() == mPreviewWidth &&
 608                             candidate.getHeight() == mPreviewHeight) {
 609                         unusedBitmap = candidate;
 610                         mUnusedBitmaps.remove(unusedBitmap);
 611                         break;
 612                     }
 613                 }
 614             }
 615
 616             // creating a bitmap is expensive. Do not do this inside synchronized block.
 617             if (unusedBitmap == null) {
 618                 unusedBitmap = Bitmap.createBitmap(mPreviewWidth, mPreviewHeight, Config.ARGB_8888);
 619             }
 620             // If cancelled now, don't bother reading the preview from the DB
 621             if (isCancelled()) {
 622                 return unusedBitmap;
 623             }
 624             Bitmap preview = readFromDb(mKey, unusedBitmap, this);
 625             // Only consider generating the preview if we have not cancelled the task already
 626             if (!isCancelled() && preview == null) {
 627                 // Fetch the version info before we generate the preview, so that, in-case the
 628                 // app was updated while we are generating the preview, we use the old version info,
 629                 // which would gets re-written next time.
 630                 mVersions = getPackageVersion(mKey.componentName.getPackageName());
 631
 632                 Launcher launcher = (Launcher) mCaller.getContext();
 633
 634                 // it's not in the db... we need to generate it
 635                 preview = generatePreview(launcher, mInfo, unusedBitmap, mPreviewWidth, mPreviewHeight);
 636             }
 637             return preview;
 638         }
 639
 640         @Override
 641         protected void onPostExecute(final Bitmap preview) {
 642             mCaller.applyPreview(preview);
 643
 644             // Write the generated preview to the DB in the worker thread
 645             if (mVersions != null) {
 646                 mWorkerHandler.post(new Runnable() {
 647                     @Override
 648                     public void run() {
 649                         if (!isCancelled()) {
 650                             // If we are still using this preview, then write it to the DB and then
 651                             // let the normal clear mechanism recycle the bitmap
 652                             writeToDb(mKey, mVersions, preview);
 653                             mBitmapToRecycle = preview;
 654                         } else {
 655                             // If we've already cancelled, then skip writing the bitmap to the DB
 656                             // and manually add the bitmap back to the recycled set
 657                             synchronized (mUnusedBitmaps) {
 658                                 mUnusedBitmaps.add(preview);
 659                             }
 660                         }
 661                     }
 662                 });
 663             } else {
 664                 // If we don't need to write to disk, then ensure the preview gets recycled by
 665                 // the normal clear mechanism
 666                 mBitmapToRecycle = preview;
 667             }
 668         }
 669
 670         @Override
 671         protected void onCancelled(final Bitmap preview) {
 672             // If we've cancelled while the task is running, then can return the bitmap to the
 673             // recycled set immediately. Otherwise, it will be recycled after the preview is written
 674             // to disk.
 675             if (preview != null) {
 676                 mWorkerHandler.post(new Runnable() {
 677                     @Override
 678                     public void run() {
 679                         synchronized (mUnusedBitmaps) {
 680                             mUnusedBitmaps.add(preview);
 681                         }
 682                     }
 683                 });
 684             }
 685         }
 686     }
 687
 688     private static final class WidgetCacheKey extends ComponentKey {
 689
 690         // TODO: remove dependency on size
 691         @Thunk final String size;
 692
 693         public WidgetCacheKey(ComponentName componentName, UserHandleCompat user, String size) {
 694             super(componentName, user);
 695             this.size = size;
 696         }
 697
 698         @Override
 699         public int hashCode() {
 700             return super.hashCode() ^ size.hashCode();
 701         }
 702
 703         @Override
 704         public boolean equals(Object o) {
 705             return super.equals(o) && ((WidgetCacheKey) o).size.equals(size);
 706         }
 707     }
 708 }