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