src/com/android/launcher3/WidgetPreviewLoader.java

   1 package com.android.launcher3;
   2
   3 import android.appwidget.AppWidgetProviderInfo;
   4 import android.content.ComponentName;
   5 import android.content.ContentValues;
   6 import android.content.Context;
   7 import android.content.SharedPreferences;
   8 import android.content.pm.ResolveInfo;
   9 import android.content.res.Resources;
  10 import android.database.Cursor;
  11 import android.database.sqlite.SQLiteCantOpenDatabaseException;
  12 import android.database.sqlite.SQLiteDatabase;
  13 import android.database.sqlite.SQLiteDiskIOException;
  14 import android.database.sqlite.SQLiteOpenHelper;
  15 import android.graphics.Bitmap;
  16 import android.graphics.Bitmap.Config;
  17 import android.graphics.BitmapFactory;
  18 import android.graphics.BitmapShader;
  19 import android.graphics.Canvas;
  20 import android.graphics.ColorMatrix;
  21 import android.graphics.ColorMatrixColorFilter;
  22 import android.graphics.Paint;
  23 import android.graphics.PorterDuff;
  24 import android.graphics.Rect;
  25 import android.graphics.Shader;
  26 import android.graphics.drawable.BitmapDrawable;
  27 import android.graphics.drawable.Drawable;
  28 import android.os.AsyncTask;
  29 import android.util.Log;
  30
  31 import com.android.launcher3.compat.AppWidgetManagerCompat;
  32
  33 import java.io.ByteArrayOutputStream;
  34 import java.io.File;
  35 import java.io.IOException;
  36 import java.lang.ref.SoftReference;
  37 import java.lang.ref.WeakReference;
  38 import java.util.ArrayList;
  39 import java.util.Arrays;
  40 import java.util.HashMap;
  41 import java.util.HashSet;
  42 import java.util.List;
  43 import java.util.concurrent.Callable;
  44 import java.util.concurrent.ExecutionException;
  45
  46 public class WidgetPreviewLoader {
  47
  48     private static abstract class SoftReferenceThreadLocal<T> {
  49         private ThreadLocal<SoftReference<T>> mThreadLocal;
  50         public SoftReferenceThreadLocal() {
  51             mThreadLocal = new ThreadLocal<SoftReference<T>>();
  52         }
  53
  54         abstract T initialValue();
  55
  56         public void set(T t) {
  57             mThreadLocal.set(new SoftReference<T>(t));
  58         }
  59
  60         public T get() {
  61             SoftReference<T> reference = mThreadLocal.get();
  62             T obj;
  63             if (reference == null) {
  64                 obj = initialValue();
  65                 mThreadLocal.set(new SoftReference<T>(obj));
  66                 return obj;
  67             } else {
  68                 obj = reference.get();
  69                 if (obj == null) {
  70                     obj = initialValue();
  71                     mThreadLocal.set(new SoftReference<T>(obj));
  72                 }
  73                 return obj;
  74             }
  75         }
  76     }
  77
  78     private static class CanvasCache extends SoftReferenceThreadLocal<Canvas> {
  79         @Override
  80         protected Canvas initialValue() {
  81             return new Canvas();
  82         }
  83     }
  84
  85     private static class PaintCache extends SoftReferenceThreadLocal<Paint> {
  86         @Override
  87         protected Paint initialValue() {
  88             return null;
  89         }
  90     }
  91
  92     private static class BitmapCache extends SoftReferenceThreadLocal<Bitmap> {
  93         @Override
  94         protected Bitmap initialValue() {
  95             return null;
  96         }
  97     }
  98
  99     private static class RectCache extends SoftReferenceThreadLocal<Rect> {
 100         @Override
 101         protected Rect initialValue() {
 102             return new Rect();
 103         }
 104     }
 105
 106     private static class BitmapFactoryOptionsCache extends
 107             SoftReferenceThreadLocal<BitmapFactory.Options> {
 108         @Override
 109         protected BitmapFactory.Options initialValue() {
 110             return new BitmapFactory.Options();
 111         }
 112     }
 113
 114     private static final String TAG = "WidgetPreviewLoader";
 115     private static final String ANDROID_INCREMENTAL_VERSION_NAME_KEY = "android.incremental.version";
 116
 117     private static final float WIDGET_PREVIEW_ICON_PADDING_PERCENTAGE = 0.25f;
 118     private static final HashSet<String> sInvalidPackages = new HashSet<String>();
 119
 120     // Used for drawing shortcut previews
 121     private final BitmapCache mCachedShortcutPreviewBitmap = new BitmapCache();
 122     private final PaintCache mCachedShortcutPreviewPaint = new PaintCache();
 123     private final CanvasCache mCachedShortcutPreviewCanvas = new CanvasCache();
 124
 125     // Used for drawing widget previews
 126     private final CanvasCache mCachedAppWidgetPreviewCanvas = new CanvasCache();
 127     private final RectCache mCachedAppWidgetPreviewSrcRect = new RectCache();
 128     private final RectCache mCachedAppWidgetPreviewDestRect = new RectCache();
 129     private final PaintCache mCachedAppWidgetPreviewPaint = new PaintCache();
 130     private final PaintCache mDefaultAppWidgetPreviewPaint = new PaintCache();
 131     private final BitmapFactoryOptionsCache mCachedBitmapFactoryOptions = new BitmapFactoryOptionsCache();
 132
 133     private final HashMap<String, WeakReference<Bitmap>> mLoadedPreviews = new HashMap<>();
 134     private final ArrayList<SoftReference<Bitmap>> mUnusedBitmaps = new ArrayList<>();
 135
 136     private final Context mContext;
 137     private final int mAppIconSize;
 138     private final IconCache mIconCache;
 139     private final AppWidgetManagerCompat mManager;
 140
 141     private int mPreviewBitmapWidth;
 142     private int mPreviewBitmapHeight;
 143     private String mSize;
 144     private PagedViewCellLayout mWidgetSpacingLayout;
 145
 146     private String mCachedSelectQuery;
 147
 148
 149     private CacheDb mDb;
 150
 151     private final MainThreadExecutor mMainThreadExecutor = new MainThreadExecutor();
 152
 153     public WidgetPreviewLoader(Context context) {
 154         LauncherAppState app = LauncherAppState.getInstance();
 155         DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();
 156
 157         mContext = context;
 158         mAppIconSize = grid.iconSizePx;
 159         mIconCache = app.getIconCache();
 160         mManager = AppWidgetManagerCompat.getInstance(context);
 161
 162         mDb = app.getWidgetPreviewCacheDb();
 163
 164         SharedPreferences sp = context.getSharedPreferences(
 165                 LauncherAppState.getSharedPreferencesKey(), Context.MODE_PRIVATE);
 166         final String lastVersionName = sp.getString(ANDROID_INCREMENTAL_VERSION_NAME_KEY, null);
 167         final String versionName = android.os.Build.VERSION.INCREMENTAL;
 168         if (!versionName.equals(lastVersionName)) {
 169             // clear all the previews whenever the system version changes, to ensure that previews
 170             // are up-to-date for any apps that might have been updated with the system
 171             clearDb();
 172
 173             SharedPreferences.Editor editor = sp.edit();
 174             editor.putString(ANDROID_INCREMENTAL_VERSION_NAME_KEY, versionName);
 175             editor.commit();
 176         }
 177     }
 178
 179     public void recreateDb() {
 180         LauncherAppState app = LauncherAppState.getInstance();
 181         app.recreateWidgetPreviewDb();
 182         mDb = app.getWidgetPreviewCacheDb();
 183     }
 184
 185     public void setPreviewSize(int previewWidth, int previewHeight,
 186             PagedViewCellLayout widgetSpacingLayout) {
 187         mPreviewBitmapWidth = previewWidth;
 188         mPreviewBitmapHeight = previewHeight;
 189         mSize = previewWidth + "x" + previewHeight;
 190         mWidgetSpacingLayout = widgetSpacingLayout;
 191     }
 192
 193     public Bitmap getPreview(final Object o) {
 194         final String name = getObjectName(o);
 195         final String packageName = getObjectPackage(o);
 196         // check if the package is valid
 197         synchronized(sInvalidPackages) {
 198             boolean packageValid = !sInvalidPackages.contains(packageName);
 199             if (!packageValid) {
 200                 return null;
 201             }
 202         }
 203         synchronized(mLoadedPreviews) {
 204             // check if it exists in our existing cache
 205             if (mLoadedPreviews.containsKey(name)) {
 206                 WeakReference<Bitmap> bitmapReference = mLoadedPreviews.get(name);
 207                 Bitmap bitmap = bitmapReference.get();
 208                 if (bitmap != null) {
 209                     return bitmap;
 210                 }
 211             }
 212         }
 213
 214         Bitmap unusedBitmap = null;
 215         synchronized(mUnusedBitmaps) {
 216             // not in cache; we need to load it from the db
 217             while (unusedBitmap == null && mUnusedBitmaps.size() > 0) {
 218                 Bitmap candidate = mUnusedBitmaps.remove(0).get();
 219                 if (candidate != null && candidate.isMutable() &&
 220                         candidate.getWidth() == mPreviewBitmapWidth &&
 221                         candidate.getHeight() == mPreviewBitmapHeight) {
 222                     unusedBitmap = candidate;
 223                 }
 224             }
 225             if (unusedBitmap != null) {
 226                 final Canvas c = mCachedAppWidgetPreviewCanvas.get();
 227                 c.setBitmap(unusedBitmap);
 228                 c.drawColor(0, PorterDuff.Mode.CLEAR);
 229                 c.setBitmap(null);
 230             }
 231         }
 232
 233         if (unusedBitmap == null) {
 234             unusedBitmap = Bitmap.createBitmap(mPreviewBitmapWidth, mPreviewBitmapHeight,
 235                     Bitmap.Config.ARGB_8888);
 236         }
 237         Bitmap preview = readFromDb(name, unusedBitmap);
 238
 239         if (preview != null) {
 240             synchronized(mLoadedPreviews) {
 241                 mLoadedPreviews.put(name, new WeakReference<Bitmap>(preview));
 242             }
 243             return preview;
 244         } else {
 245             // it's not in the db... we need to generate it
 246             final Bitmap generatedPreview = generatePreview(o, unusedBitmap);
 247             preview = generatedPreview;
 248             if (preview != unusedBitmap) {
 249                 throw new RuntimeException("generatePreview is not recycling the bitmap " + o);
 250             }
 251
 252             synchronized(mLoadedPreviews) {
 253                 mLoadedPreviews.put(name, new WeakReference<Bitmap>(preview));
 254             }
 255
 256             // write to db on a thread pool... this can be done lazily and improves the performance
 257             // of the first time widget previews are loaded
 258             new AsyncTask<Void, Void, Void>() {
 259                 public Void doInBackground(Void ... args) {
 260                     writeToDb(o, generatedPreview);
 261                     return null;
 262                 }
 263             }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
 264
 265             return preview;
 266         }
 267     }
 268
 269     public void recycleBitmap(Object o, Bitmap bitmapToRecycle) {
 270         String name = getObjectName(o);
 271         synchronized (mLoadedPreviews) {
 272             if (mLoadedPreviews.containsKey(name)) {
 273                 Bitmap b = mLoadedPreviews.get(name).get();
 274                 if (b == bitmapToRecycle) {
 275                     mLoadedPreviews.remove(name);
 276                     if (bitmapToRecycle.isMutable()) {
 277                         synchronized (mUnusedBitmaps) {
 278                             mUnusedBitmaps.add(new SoftReference<Bitmap>(b));
 279                         }
 280                     }
 281                 } else {
 282                     throw new RuntimeException("Bitmap passed in doesn't match up");
 283                 }
 284             }
 285         }
 286     }
 287
 288     static class CacheDb extends SQLiteOpenHelper {
 289         final static int DB_VERSION = 2;
 290         final static String DB_NAME = "widgetpreviews.db";
 291         final static String TABLE_NAME = "shortcut_and_widget_previews";
 292         final static String COLUMN_NAME = "name";
 293         final static String COLUMN_SIZE = "size";
 294         final static String COLUMN_PREVIEW_BITMAP = "preview_bitmap";
 295         Context mContext;
 296
 297         public CacheDb(Context context) {
 298             super(context, new File(context.getCacheDir(), DB_NAME).getPath(), null, DB_VERSION);
 299             // Store the context for later use
 300             mContext = context;
 301         }
 302
 303         @Override
 304         public void onCreate(SQLiteDatabase database) {
 305             database.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " (" +
 306                     COLUMN_NAME + " TEXT NOT NULL, " +
 307                     COLUMN_SIZE + " TEXT NOT NULL, " +
 308                     COLUMN_PREVIEW_BITMAP + " BLOB NOT NULL, " +
 309                     "PRIMARY KEY (" + COLUMN_NAME + ", " + COLUMN_SIZE + ") " +
 310                     ");");
 311         }
 312
 313         @Override
 314         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 315             if (oldVersion != newVersion) {
 316                 // Delete all the records; they'll be repopulated as this is a cache
 317                 db.execSQL("DELETE FROM " + TABLE_NAME);
 318             }
 319         }
 320     }
 321
 322     private static final String WIDGET_PREFIX = "Widget:";
 323     private static final String SHORTCUT_PREFIX = "Shortcut:";
 324
 325     private static String getObjectName(Object o) {
 326         // should cache the string builder
 327         StringBuilder sb = new StringBuilder();
 328         String output;
 329         if (o instanceof AppWidgetProviderInfo) {
 330             sb.append(WIDGET_PREFIX);
 331             sb.append(((AppWidgetProviderInfo) o).toString());
 332             output = sb.toString();
 333             sb.setLength(0);
 334         } else {
 335             sb.append(SHORTCUT_PREFIX);
 336
 337             ResolveInfo info = (ResolveInfo) o;
 338             sb.append(new ComponentName(info.activityInfo.packageName,
 339                     info.activityInfo.name).flattenToString());
 340             output = sb.toString();
 341             sb.setLength(0);
 342         }
 343         return output;
 344     }
 345
 346     private String getObjectPackage(Object o) {
 347         if (o instanceof AppWidgetProviderInfo) {
 348             return ((AppWidgetProviderInfo) o).provider.getPackageName();
 349         } else {
 350             ResolveInfo info = (ResolveInfo) o;
 351             return info.activityInfo.packageName;
 352         }
 353     }
 354
 355     private void writeToDb(Object o, Bitmap preview) {
 356         String name = getObjectName(o);
 357         SQLiteDatabase db = mDb.getWritableDatabase();
 358         ContentValues values = new ContentValues();
 359
 360         values.put(CacheDb.COLUMN_NAME, name);
 361         ByteArrayOutputStream stream = new ByteArrayOutputStream();
 362         preview.compress(Bitmap.CompressFormat.PNG, 100, stream);
 363         values.put(CacheDb.COLUMN_PREVIEW_BITMAP, stream.toByteArray());
 364         values.put(CacheDb.COLUMN_SIZE, mSize);
 365         try {
 366             db.insert(CacheDb.TABLE_NAME, null, values);
 367         } catch (SQLiteDiskIOException e) {
 368             recreateDb();
 369         } catch (SQLiteCantOpenDatabaseException e) {
 370             dumpOpenFiles();
 371             throw e;
 372         }
 373     }
 374
 375     private void clearDb() {
 376         SQLiteDatabase db = mDb.getWritableDatabase();
 377         // Delete everything
 378         try {
 379             db.delete(CacheDb.TABLE_NAME, null, null);
 380         } catch (SQLiteDiskIOException e) {
 381         } catch (SQLiteCantOpenDatabaseException e) {
 382             dumpOpenFiles();
 383             throw e;
 384         }
 385     }
 386
 387     public static void removePackageFromDb(final CacheDb cacheDb, final String packageName) {
 388         synchronized(sInvalidPackages) {
 389             sInvalidPackages.add(packageName);
 390         }
 391         new AsyncTask<Void, Void, Void>() {
 392             public Void doInBackground(Void ... args) {
 393                 SQLiteDatabase db = cacheDb.getWritableDatabase();
 394                 try {
 395                     db.delete(CacheDb.TABLE_NAME,
 396                             CacheDb.COLUMN_NAME + " LIKE ? OR " +
 397                             CacheDb.COLUMN_NAME + " LIKE ?", // SELECT query
 398                             new String[] {
 399                                     WIDGET_PREFIX + packageName + "/%",
 400                                     SHORTCUT_PREFIX + packageName + "/%"
 401                             } // args to SELECT query
 402                     );
 403                 } catch (SQLiteDiskIOException e) {
 404                 } catch (SQLiteCantOpenDatabaseException e) {
 405                     dumpOpenFiles();
 406                     throw e;
 407                 }
 408                 synchronized(sInvalidPackages) {
 409                     sInvalidPackages.remove(packageName);
 410                 }
 411                 return null;
 412             }
 413         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
 414     }
 415
 416     private static void removeItemFromDb(final CacheDb cacheDb, final String objectName) {
 417         new AsyncTask<Void, Void, Void>() {
 418             public Void doInBackground(Void ... args) {
 419                 SQLiteDatabase db = cacheDb.getWritableDatabase();
 420                 try {
 421                     db.delete(CacheDb.TABLE_NAME,
 422                             CacheDb.COLUMN_NAME + " = ? ", // SELECT query
 423                             new String[] { objectName }); // args to SELECT query
 424                 } catch (SQLiteDiskIOException e) {
 425                 } catch (SQLiteCantOpenDatabaseException e) {
 426                     dumpOpenFiles();
 427                     throw e;
 428                 }
 429                 return null;
 430             }
 431         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
 432     }
 433
 434     private Bitmap readFromDb(String name, Bitmap b) {
 435         if (mCachedSelectQuery == null) {
 436             mCachedSelectQuery = CacheDb.COLUMN_NAME + " = ? AND " +
 437                     CacheDb.COLUMN_SIZE + " = ?";
 438         }
 439         SQLiteDatabase db = mDb.getReadableDatabase();
 440         Cursor result;
 441         try {
 442             result = db.query(CacheDb.TABLE_NAME,
 443                     new String[] { CacheDb.COLUMN_PREVIEW_BITMAP }, // cols to return
 444                     mCachedSelectQuery, // select query
 445                     new String[] { name, mSize }, // args to select query
 446                     null,
 447                     null,
 448                     null,
 449                     null);
 450         } catch (SQLiteDiskIOException e) {
 451             recreateDb();
 452             return null;
 453         } catch (SQLiteCantOpenDatabaseException e) {
 454             dumpOpenFiles();
 455             throw e;
 456         }
 457         if (result.getCount() > 0) {
 458             result.moveToFirst();
 459             byte[] blob = result.getBlob(0);
 460             result.close();
 461             final BitmapFactory.Options opts = mCachedBitmapFactoryOptions.get();
 462             opts.inBitmap = b;
 463             opts.inSampleSize = 1;
 464             try {
 465                 return BitmapFactory.decodeByteArray(blob, 0, blob.length, opts);
 466             } catch (IllegalArgumentException e) {
 467                 removeItemFromDb(mDb, name);
 468                 return null;
 469             }
 470         } else {
 471             result.close();
 472             return null;
 473         }
 474     }
 475
 476     private Bitmap generatePreview(Object info, Bitmap preview) {
 477         if (preview != null &&
 478                 (preview.getWidth() != mPreviewBitmapWidth ||
 479                 preview.getHeight() != mPreviewBitmapHeight)) {
 480             throw new RuntimeException("Improperly sized bitmap passed as argument");
 481         }
 482         if (info instanceof AppWidgetProviderInfo) {
 483             return generateWidgetPreview((AppWidgetProviderInfo) info, preview);
 484         } else {
 485             return generateShortcutPreview(
 486                     (ResolveInfo) info, mPreviewBitmapWidth, mPreviewBitmapHeight, preview);
 487         }
 488     }
 489
 490     public Bitmap generateWidgetPreview(AppWidgetProviderInfo info, Bitmap preview) {
 491         int[] cellSpans = Launcher.getSpanForWidget(mContext, info);
 492         int maxWidth = maxWidthForWidgetPreview(cellSpans[0]);
 493         int maxHeight = maxHeightForWidgetPreview(cellSpans[1]);
 494         return generateWidgetPreview(info, cellSpans[0], cellSpans[1],
 495                 maxWidth, maxHeight, preview, null);
 496     }
 497
 498     public int maxWidthForWidgetPreview(int spanX) {
 499         return Math.min(mPreviewBitmapWidth,
 500                 mWidgetSpacingLayout.estimateCellWidth(spanX));
 501     }
 502
 503     public int maxHeightForWidgetPreview(int spanY) {
 504         return Math.min(mPreviewBitmapHeight,
 505                 mWidgetSpacingLayout.estimateCellHeight(spanY));
 506     }
 507
 508     public Bitmap generateWidgetPreview(AppWidgetProviderInfo info, int cellHSpan, int cellVSpan,
 509             int maxPreviewWidth, int maxPreviewHeight, Bitmap preview, int[] preScaledWidthOut) {
 510         // Load the preview image if possible
 511         if (maxPreviewWidth < 0) maxPreviewWidth = Integer.MAX_VALUE;
 512         if (maxPreviewHeight < 0) maxPreviewHeight = Integer.MAX_VALUE;
 513
 514         Drawable drawable = null;
 515         if (info.previewImage != 0) {
 516             drawable = mManager.loadPreview(info);
 517             if (drawable != null) {
 518                 drawable = mutateOnMainThread(drawable);
 519             } else {
 520                 Log.w(TAG, "Can't load widget preview drawable 0x" +
 521                         Integer.toHexString(info.previewImage) + " for provider: " + info.provider);
 522             }
 523         }
 524
 525         int previewWidth;
 526         int previewHeight;
 527         Bitmap defaultPreview = null;
 528         boolean widgetPreviewExists = (drawable != null);
 529         if (widgetPreviewExists) {
 530             previewWidth = drawable.getIntrinsicWidth();
 531             previewHeight = drawable.getIntrinsicHeight();
 532         } else {
 533             // Generate a preview image if we couldn't load one
 534             if (cellHSpan < 1) cellHSpan = 1;
 535             if (cellVSpan < 1) cellVSpan = 1;
 536
 537             // This Drawable is not directly drawn, so there's no need to mutate it.
 538             BitmapDrawable previewDrawable = (BitmapDrawable) mContext.getResources()
 539                     .getDrawable(R.drawable.widget_tile);
 540             final int previewDrawableWidth = previewDrawable
 541                     .getIntrinsicWidth();
 542             final int previewDrawableHeight = previewDrawable
 543                     .getIntrinsicHeight();
 544             previewWidth = previewDrawableWidth * cellHSpan;
 545             previewHeight = previewDrawableHeight * cellVSpan;
 546
 547             defaultPreview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
 548             final Canvas c = mCachedAppWidgetPreviewCanvas.get();
 549             c.setBitmap(defaultPreview);
 550             Paint p = mDefaultAppWidgetPreviewPaint.get();
 551             if (p == null) {
 552                 p = new Paint();
 553                 p.setShader(new BitmapShader(previewDrawable.getBitmap(),
 554                         Shader.TileMode.REPEAT, Shader.TileMode.REPEAT));
 555                 mDefaultAppWidgetPreviewPaint.set(p);
 556             }
 557             final Rect dest = mCachedAppWidgetPreviewDestRect.get();
 558             dest.set(0, 0, previewWidth, previewHeight);
 559             c.drawRect(dest, p);
 560             c.setBitmap(null);
 561
 562             // Draw the icon in the top left corner
 563             int minOffset = (int) (mAppIconSize * WIDGET_PREVIEW_ICON_PADDING_PERCENTAGE);
 564             int smallestSide = Math.min(previewWidth, previewHeight);
 565             float iconScale = Math.min((float) smallestSide
 566                     / (mAppIconSize + 2 * minOffset), 1f);
 567
 568             try {
 569                 Drawable icon = mManager.loadIcon(info, mIconCache);
 570                 if (icon != null) {
 571                     int hoffset = (int) ((previewDrawableWidth - mAppIconSize * iconScale) / 2);
 572                     int yoffset = (int) ((previewDrawableHeight - mAppIconSize * iconScale) / 2);
 573                     icon = mutateOnMainThread(icon);
 574                     renderDrawableToBitmap(icon, defaultPreview, hoffset,
 575                             yoffset, (int) (mAppIconSize * iconScale),
 576                             (int) (mAppIconSize * iconScale));
 577                 }
 578             } catch (Resources.NotFoundException e) {
 579             }
 580         }
 581
 582         // Scale to fit width only - let the widget preview be clipped in the
 583         // vertical dimension
 584         float scale = 1f;
 585         if (preScaledWidthOut != null) {
 586             preScaledWidthOut[0] = previewWidth;
 587         }
 588         if (previewWidth > maxPreviewWidth) {
 589             scale = maxPreviewWidth / (float) previewWidth;
 590         }
 591         if (scale != 1f) {
 592             previewWidth = (int) (scale * previewWidth);
 593             previewHeight = (int) (scale * previewHeight);
 594         }
 595
 596         // If a bitmap is passed in, we use it; otherwise, we create a bitmap of the right size
 597         if (preview == null) {
 598             preview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
 599         }
 600
 601         // Draw the scaled preview into the final bitmap
 602         int x = (preview.getWidth() - previewWidth) / 2;
 603         if (widgetPreviewExists) {
 604             renderDrawableToBitmap(drawable, preview, x, 0, previewWidth,
 605                     previewHeight);
 606         } else {
 607             final Canvas c = mCachedAppWidgetPreviewCanvas.get();
 608             final Rect src = mCachedAppWidgetPreviewSrcRect.get();
 609             final Rect dest = mCachedAppWidgetPreviewDestRect.get();
 610             c.setBitmap(preview);
 611             src.set(0, 0, defaultPreview.getWidth(), defaultPreview.getHeight());
 612             dest.set(x, 0, x + previewWidth, previewHeight);
 613
 614             Paint p = mCachedAppWidgetPreviewPaint.get();
 615             if (p == null) {
 616                 p = new Paint();
 617                 p.setFilterBitmap(true);
 618                 mCachedAppWidgetPreviewPaint.set(p);
 619             }
 620             c.drawBitmap(defaultPreview, src, dest, p);
 621             c.setBitmap(null);
 622         }
 623         return mManager.getBadgeBitmap(info, preview);
 624     }
 625
 626     private Bitmap generateShortcutPreview(
 627             ResolveInfo info, int maxWidth, int maxHeight, Bitmap preview) {
 628         Bitmap tempBitmap = mCachedShortcutPreviewBitmap.get();
 629         final Canvas c = mCachedShortcutPreviewCanvas.get();
 630         if (tempBitmap == null ||
 631                 tempBitmap.getWidth() != maxWidth ||
 632                 tempBitmap.getHeight() != maxHeight) {
 633             tempBitmap = Bitmap.createBitmap(maxWidth, maxHeight, Config.ARGB_8888);
 634             mCachedShortcutPreviewBitmap.set(tempBitmap);
 635         } else {
 636             c.setBitmap(tempBitmap);
 637             c.drawColor(0, PorterDuff.Mode.CLEAR);
 638             c.setBitmap(null);
 639         }
 640         // Render the icon
 641         Drawable icon = mutateOnMainThread(mIconCache.getFullResIcon(info));
 642
 643         int paddingTop = mContext.
 644                 getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_top);
 645         int paddingLeft = mContext.
 646                 getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_left);
 647         int paddingRight = mContext.
 648                 getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_right);
 649
 650         int scaledIconWidth = (maxWidth - paddingLeft - paddingRight);
 651
 652         renderDrawableToBitmap(
 653                 icon, tempBitmap, paddingLeft, paddingTop, scaledIconWidth, scaledIconWidth);
 654
 655         if (preview != null &&
 656                 (preview.getWidth() != maxWidth || preview.getHeight() != maxHeight)) {
 657             throw new RuntimeException("Improperly sized bitmap passed as argument");
 658         } else if (preview == null) {
 659             preview = Bitmap.createBitmap(maxWidth, maxHeight, Config.ARGB_8888);
 660         }
 661
 662         c.setBitmap(preview);
 663         // Draw a desaturated/scaled version of the icon in the background as a watermark
 664         Paint p = mCachedShortcutPreviewPaint.get();
 665         if (p == null) {
 666             p = new Paint();
 667             ColorMatrix colorMatrix = new ColorMatrix();
 668             colorMatrix.setSaturation(0);
 669             p.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
 670             p.setAlpha((int) (255 * 0.06f));
 671             mCachedShortcutPreviewPaint.set(p);
 672         }
 673         c.drawBitmap(tempBitmap, 0, 0, p);
 674         c.setBitmap(null);
 675
 676         renderDrawableToBitmap(icon, preview, 0, 0, mAppIconSize, mAppIconSize);
 677
 678         return preview;
 679     }
 680
 681     private static void renderDrawableToBitmap(
 682             Drawable d, Bitmap bitmap, int x, int y, int w, int h) {
 683         if (bitmap != null) {
 684             Canvas c = new Canvas(bitmap);
 685             Rect oldBounds = d.copyBounds();
 686             d.setBounds(x, y, x + w, y + h);
 687             d.draw(c);
 688             d.setBounds(oldBounds); // Restore the bounds
 689             c.setBitmap(null);
 690         }
 691     }
 692
 693     private Drawable mutateOnMainThread(final Drawable drawable) {
 694         try {
 695             return mMainThreadExecutor.submit(new Callable<Drawable>() {
 696                 @Override
 697                 public Drawable call() throws Exception {
 698                     return drawable.mutate();
 699                 }
 700             }).get();
 701         } catch (InterruptedException e) {
 702             Thread.currentThread().interrupt();
 703             throw new RuntimeException(e);
 704         } catch (ExecutionException e) {
 705             throw new RuntimeException(e);
 706         }
 707     }
 708
 709     private static final int MAX_OPEN_FILES = 1024;
 710     private static final int SAMPLE_RATE = 23;
 711     /**
 712      * Dumps all files that are open in this process without allocating a file descriptor.
 713      */
 714     private static void dumpOpenFiles() {
 715         try {
 716             Log.i(TAG, "DUMP OF OPEN FILES (sample rate: 1 every " + SAMPLE_RATE + "):");
 717             final String TYPE_APK = "apk";
 718             final String TYPE_JAR = "jar";
 719             final String TYPE_PIPE = "pipe";
 720             final String TYPE_SOCKET = "socket";
 721             final String TYPE_DB = "db";
 722             final String TYPE_ANON_INODE = "anon_inode";
 723             final String TYPE_DEV = "dev";
 724             final String TYPE_NON_FS = "non-fs";
 725             final String TYPE_OTHER = "other";
 726             List<String> types = Arrays.asList(TYPE_APK, TYPE_JAR, TYPE_PIPE, TYPE_SOCKET, TYPE_DB,
 727                     TYPE_ANON_INODE, TYPE_DEV, TYPE_NON_FS, TYPE_OTHER);
 728             int[] count = new int[types.size()];
 729             int[] duplicates = new int[types.size()];
 730             HashSet<String> files = new HashSet<String>();
 731             int total = 0;
 732             for (int i = 0; i < MAX_OPEN_FILES; i++) {
 733                 // This is a gigantic hack but unfortunately the only way to resolve an fd
 734                 // to a file name. Note that we have to loop over all possible fds because
 735                 // reading the directory would require allocating a new fd. The kernel is
 736                 // currently implemented such that no fd is larger then the current rlimit,
 737                 // which is why it's safe to loop over them in such a way.
 738                 String fd = "/proc/self/fd/" + i;
 739                 try {
 740                     // getCanonicalPath() uses readlink behind the scene which doesn't require
 741                     // a file descriptor.
 742                     String resolved = new File(fd).getCanonicalPath();
 743                     int type = types.indexOf(TYPE_OTHER);
 744                     if (resolved.startsWith("/dev/")) {
 745                         type = types.indexOf(TYPE_DEV);
 746                     } else if (resolved.endsWith(".apk")) {
 747                         type = types.indexOf(TYPE_APK);
 748                     } else if (resolved.endsWith(".jar")) {
 749                         type = types.indexOf(TYPE_JAR);
 750                     } else if (resolved.contains("/fd/pipe:")) {
 751                         type = types.indexOf(TYPE_PIPE);
 752                     } else if (resolved.contains("/fd/socket:")) {
 753                         type = types.indexOf(TYPE_SOCKET);
 754                     } else if (resolved.contains("/fd/anon_inode:")) {
 755                         type = types.indexOf(TYPE_ANON_INODE);
 756                     } else if (resolved.endsWith(".db") || resolved.contains("/databases/")) {
 757                         type = types.indexOf(TYPE_DB);
 758                     } else if (resolved.startsWith("/proc/") && resolved.contains("/fd/")) {
 759                         // Those are the files that don't point anywhere on the file system.
 760                         // getCanonicalPath() wrongly interprets these as relative symlinks and
 761                         // resolves them within /proc/<pid>/fd/.
 762                         type = types.indexOf(TYPE_NON_FS);
 763                     }
 764                     count[type]++;
 765                     total++;
 766                     if (files.contains(resolved)) {
 767                         duplicates[type]++;
 768                     }
 769                     files.add(resolved);
 770                     if (total % SAMPLE_RATE == 0) {
 771                         Log.i(TAG, " fd " + i + ": " + resolved
 772                                 + " (" + types.get(type) + ")");
 773                     }
 774                 } catch (IOException e) {
 775                     // Ignoring exceptions for non-existing file descriptors.
 776                 }
 777             }
 778             for (int i = 0; i < types.size(); i++) {
 779                 Log.i(TAG, String.format("Open %10s files: %4d total, %4d duplicates",
 780                         types.get(i), count[i], duplicates[i]));
 781             }
 782         } catch (Throwable t) {
 783             // Catch everything. This is called from an exception handler that we shouldn't upset.
 784             Log.e(TAG, "Unable to log open files.", t);
 785         }
 786     }
 787 }