Cache widget previews in a DB
- Smoother All Apps scroll performance
Change-Id: Id2d31a45e71c63d05a46f580667ad94403730616
diff --git a/src/com/android/launcher2/WidgetPreviewLoader.java b/src/com/android/launcher2/WidgetPreviewLoader.java
new file mode 100644
index 0000000..2d10967
--- /dev/null
+++ b/src/com/android/launcher2/WidgetPreviewLoader.java
@@ -0,0 +1,606 @@
+package com.android.launcher2;
+
+import android.appwidget.AppWidgetProviderInfo;
+import android.content.ComponentName;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.Shader;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.AsyncTask;
+import android.util.Log;
+
+import com.android.launcher.R;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+abstract class SoftReferenceThreadLocal<T> {
+ private ThreadLocal<SoftReference<T>> mThreadLocal;
+ public SoftReferenceThreadLocal() {
+ mThreadLocal = new ThreadLocal<SoftReference<T>>();
+ }
+
+ abstract T initialValue();
+
+ public void set(T t) {
+ mThreadLocal.set(new SoftReference<T>(t));
+ }
+
+ public T get() {
+ SoftReference<T> reference = mThreadLocal.get();
+ T obj;
+ if (reference == null) {
+ obj = initialValue();
+ mThreadLocal.set(new SoftReference<T>(obj));
+ return obj;
+ } else {
+ obj = reference.get();
+ if (obj == null) {
+ obj = initialValue();
+ mThreadLocal.set(new SoftReference<T>(obj));
+ }
+ return obj;
+ }
+ }
+}
+
+class CanvasCache extends SoftReferenceThreadLocal<Canvas> {
+ @Override
+ protected Canvas initialValue() {
+ return new Canvas();
+ }
+}
+
+class PaintCache extends SoftReferenceThreadLocal<Paint> {
+ @Override
+ protected Paint initialValue() {
+ return null;
+ }
+}
+
+class BitmapCache extends SoftReferenceThreadLocal<Bitmap> {
+ @Override
+ protected Bitmap initialValue() {
+ return null;
+ }
+}
+
+class RectCache extends SoftReferenceThreadLocal<Rect> {
+ @Override
+ protected Rect initialValue() {
+ return new Rect();
+ }
+}
+
+class BitmapFactoryOptionsCache extends SoftReferenceThreadLocal<BitmapFactory.Options> {
+ @Override
+ protected BitmapFactory.Options initialValue() {
+ return new BitmapFactory.Options();
+ }
+}
+
+public class WidgetPreviewLoader {
+ static final String TAG = "WidgetPreviewLoader";
+
+ private int mPreviewBitmapMaxWidth;
+ private int mPreviewBitmapMaxHeight;
+ private String mSize;
+ private Context mContext;
+ private Launcher mLauncher;
+ private PackageManager mPackageManager;
+ private PagedViewCellLayout mWidgetSpacingLayout;
+
+ // Used for drawing shortcut previews
+ private BitmapCache mCachedShortcutPreviewBitmap = new BitmapCache();
+ private PaintCache mCachedShortcutPreviewPaint = new PaintCache();
+ private CanvasCache mCachedShortcutPreviewCanvas = new CanvasCache();
+
+ // Used for drawing widget previews
+ private CanvasCache mCachedAppWidgetPreviewCanvas = new CanvasCache();
+ private RectCache mCachedAppWidgetPreviewSrcRect = new RectCache();
+ private RectCache mCachedAppWidgetPreviewDestRect = new RectCache();
+ private PaintCache mCachedAppWidgetPreviewPaint = new PaintCache();
+ private String mCachedSelectQuery;
+ private BitmapFactoryOptionsCache mCachedBitmapFactoryOptions = new BitmapFactoryOptionsCache();
+
+ private int mAppIconSize;
+ private IconCache mIconCache;
+
+ private final float sWidgetPreviewIconPaddingPercentage = 0.25f;
+
+ private WidgetPreviewCacheDb mDb;
+
+ private static HashMap<String, WeakReference<Bitmap>> sLoadedPreviews;
+ private static ArrayList<SoftReference<Bitmap>> sUnusedBitmaps;
+ private static HashSet<String> sInvalidPackages;
+
+ static {
+ sLoadedPreviews = new HashMap<String, WeakReference<Bitmap>>();
+ sUnusedBitmaps = new ArrayList<SoftReference<Bitmap>>();
+ sInvalidPackages = new HashSet<String>();
+ }
+
+ public WidgetPreviewLoader(int previewWidth, int previewHeight,
+ Launcher launcher, PagedViewCellLayout widgetSpacingLayout) {
+ mPreviewBitmapMaxWidth = previewWidth;
+ mPreviewBitmapMaxHeight = previewHeight;
+ mSize = previewWidth + "x" + previewHeight;
+ mContext = mLauncher = launcher;
+ mPackageManager = mContext.getPackageManager();
+ mAppIconSize = mContext.getResources().getDimensionPixelSize(R.dimen.app_icon_size);
+ mIconCache = ((LauncherApplication) launcher.getApplicationContext()).getIconCache();
+ mWidgetSpacingLayout = widgetSpacingLayout;
+ mDb = new WidgetPreviewCacheDb(mContext);
+ }
+
+ public Bitmap getPreview(final Object o) {
+ String name = getObjectName(o);
+ // check if the package is valid
+ boolean packageValid = true;
+ synchronized(sInvalidPackages) {
+ packageValid = !sInvalidPackages.contains(getObjectPackage(o));
+ }
+ if (!packageValid) {
+ return null;
+ }
+ if (packageValid) {
+ synchronized(sLoadedPreviews) {
+ // check if it exists in our existing cache
+ if (sLoadedPreviews.containsKey(name) && sLoadedPreviews.get(name).get() != null) {
+ return sLoadedPreviews.get(name).get();
+ }
+ }
+ }
+
+ Bitmap unusedBitmap = null;
+ synchronized(sUnusedBitmaps) {
+ // not in cache; we need to load it from the db
+ while ((unusedBitmap == null || !unusedBitmap.isMutable())
+ && sUnusedBitmaps.size() > 0) {
+ unusedBitmap = sUnusedBitmaps.remove(0).get();
+ }
+ if (unusedBitmap != null) {
+ final Canvas c = mCachedAppWidgetPreviewCanvas.get();
+ c.setBitmap(unusedBitmap);
+ c.drawColor(0, PorterDuff.Mode.CLEAR);
+ c.setBitmap(null);
+ }
+ }
+
+ if (unusedBitmap == null) {
+ unusedBitmap = Bitmap.createBitmap(mPreviewBitmapMaxWidth, mPreviewBitmapMaxHeight,
+ Bitmap.Config.ARGB_8888);
+ }
+
+ Bitmap preview = null;
+
+ if (packageValid) {
+ preview = readFromDb(name, unusedBitmap);
+ }
+
+ if (preview != null) {
+ synchronized(sLoadedPreviews) {
+ sLoadedPreviews.put(name, new WeakReference<Bitmap>(preview));
+ }
+ return preview;
+ } else {
+ // it's not in the db... we need to generate it
+ final Bitmap generatedPreview = generatePreview(o, unusedBitmap);
+ preview = generatedPreview;
+ if (preview != unusedBitmap) {
+ throw new RuntimeException("generatePreview is not recycling the bitmap " + o);
+ }
+
+ synchronized(sLoadedPreviews) {
+ sLoadedPreviews.put(name, new WeakReference<Bitmap>(preview));
+ }
+
+ // write to db on a thread pool... this can be done lazily and improves the performance
+ // of the first time widget previews are loaded
+ new AsyncTask<Void, Void, Void>() {
+ public Void doInBackground(Void ... args) {
+ writeToDb(o, generatedPreview);
+ return null;
+ }
+ }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
+
+ return preview;
+ }
+ }
+
+ public static void releaseBitmap(Object o, Bitmap bitmapToFree) {
+ // enable this code when doDecode doesn't force Bitmaps to become immutable
+ String name = getObjectName(o);
+ synchronized(sLoadedPreviews) {
+ synchronized(sUnusedBitmaps) {
+ Bitmap b = sLoadedPreviews.get(name).get();
+ if (b == bitmapToFree) {
+ sLoadedPreviews.remove(name);
+ if (bitmapToFree.isMutable()) {
+ sUnusedBitmaps.add(new SoftReference<Bitmap>(b));
+ }
+ } else {
+ throw new RuntimeException("Bitmap passed in doesn't match up");
+ }
+ }
+ }
+ }
+
+ static class WidgetPreviewCacheDb extends SQLiteOpenHelper {
+ final static int DB_VERSION = 1;
+ final static String DB_NAME = "widgetpreviews.db";
+ final static String TABLE_NAME = "shortcut_and_widget_previews";
+ final static String COLUMN_NAME = "name";
+ final static String COLUMN_SIZE = "size";
+ final static String COLUMN_PREVIEW_BITMAP = "preview_bitmap";
+ Context mContext;
+
+ public WidgetPreviewCacheDb(Context context) {
+ super(context, new File(context.getCacheDir(), DB_NAME).getPath(), null, DB_VERSION);
+ // Store the context for later use
+ mContext = context;
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase database) {
+ database.execSQL("CREATE TABLE " + TABLE_NAME + " (" +
+ COLUMN_NAME + " TEXT NOT NULL, " +
+ COLUMN_SIZE + " TEXT NOT NULL, " +
+ COLUMN_PREVIEW_BITMAP + " BLOB NOT NULL, " +
+ "PRIMARY KEY (" + COLUMN_NAME + ", " + COLUMN_SIZE + ") " +
+ ");");
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ // We are still only on version 1
+ }
+ }
+
+ private static final String WIDGET_PREFIX = "Widget:";
+ private static final String SHORTCUT_PREFIX = "Shortcut:";
+
+ private static String getObjectName(Object o) {
+ // should cache the string builder
+ StringBuilder sb = new StringBuilder();
+ String output;
+ if (o instanceof AppWidgetProviderInfo) {
+ sb.append(WIDGET_PREFIX);
+ sb.append(((AppWidgetProviderInfo) o).provider.flattenToString());
+ output = sb.toString();
+ sb.setLength(0);
+ } else {
+ sb.append(SHORTCUT_PREFIX);
+
+ ResolveInfo info = (ResolveInfo) o;
+ sb.append(new ComponentName(info.activityInfo.packageName,
+ info.activityInfo.name).flattenToString());
+ output = sb.toString();
+ sb.setLength(0);
+ }
+ return output;
+ }
+
+ private String getObjectPackage(Object o) {
+ if (o instanceof AppWidgetProviderInfo) {
+ return ((AppWidgetProviderInfo) o).provider.getPackageName();
+ } else {
+ ResolveInfo info = (ResolveInfo) o;
+ return info.activityInfo.packageName;
+ }
+ }
+
+ private void writeToDb(Object o, Bitmap preview) {
+ String name = getObjectName(o);
+ SQLiteDatabase db = mDb.getWritableDatabase();
+ ContentValues values = new ContentValues();
+
+ values.put(WidgetPreviewCacheDb.COLUMN_NAME, name);
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ preview.compress(Bitmap.CompressFormat.PNG, 100, stream);
+ values.put(WidgetPreviewCacheDb.COLUMN_PREVIEW_BITMAP, stream.toByteArray());
+ values.put(WidgetPreviewCacheDb.COLUMN_SIZE, mSize);
+ db.insert(WidgetPreviewCacheDb.TABLE_NAME, null, values);
+ }
+
+ public static void removeFromDb(final Context mContext, final String packageName) {
+ synchronized(sInvalidPackages) {
+ sInvalidPackages.add(packageName);
+ }
+ new AsyncTask<Void, Void, Void>() {
+ public Void doInBackground(Void ... args) {
+ SQLiteDatabase db = new WidgetPreviewCacheDb(mContext).getWritableDatabase();
+ db.delete(WidgetPreviewCacheDb.TABLE_NAME,
+ WidgetPreviewCacheDb.COLUMN_NAME + " LIKE ? OR " +
+ WidgetPreviewCacheDb.COLUMN_NAME + " LIKE ?", // SELECT query
+ new String[] {
+ WIDGET_PREFIX + packageName + "/%",
+ SHORTCUT_PREFIX + packageName + "/%"} // args to SELECT query
+ );
+ db.close();
+ synchronized(sInvalidPackages) {
+ sInvalidPackages.remove(packageName);
+ }
+ return null;
+ }
+ }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
+ }
+
+ private Bitmap readFromDb(String name, Bitmap b) {
+ if (mCachedSelectQuery == null) {
+ mCachedSelectQuery = WidgetPreviewCacheDb.COLUMN_NAME + " = ? AND " +
+ WidgetPreviewCacheDb.COLUMN_SIZE + " = ?";
+ }
+ SQLiteDatabase db = mDb.getReadableDatabase();
+ Cursor result = db.query(WidgetPreviewCacheDb.TABLE_NAME,
+ new String[] { WidgetPreviewCacheDb.COLUMN_PREVIEW_BITMAP }, // cols to return
+ mCachedSelectQuery, // select query
+ new String[] { name, mSize }, // args to select query
+ null,
+ null,
+ null,
+ null);
+ if (result.getCount() > 0) {
+ result.moveToFirst();
+ byte[] blob = result.getBlob(0);
+ result.close();
+ final BitmapFactory.Options opts = mCachedBitmapFactoryOptions.get();
+ opts.inBitmap = b;
+ opts.inSampleSize = 1;
+ Bitmap out = BitmapFactory.decodeByteArray(blob, 0, blob.length, opts);
+ return out;
+ } else {
+ result.close();
+ return null;
+ }
+ }
+
+ public Bitmap generatePreview(Object info, Bitmap preview) {
+ if (preview != null &&
+ (preview.getWidth() != mPreviewBitmapMaxWidth ||
+ preview.getHeight() != mPreviewBitmapMaxHeight)) {
+ throw new RuntimeException("Improperly sized bitmap passed as argument");
+ }
+ if (info instanceof AppWidgetProviderInfo) {
+ return generateWidgetPreview((AppWidgetProviderInfo) info, preview);
+ } else {
+ return generateShortcutPreview(
+ (ResolveInfo) info, mPreviewBitmapMaxWidth, mPreviewBitmapMaxHeight, preview);
+ }
+ }
+
+ public Bitmap generateWidgetPreview(AppWidgetProviderInfo info, Bitmap preview) {
+ // should just read what's in the DB, and return it
+ // what's the method that's used?
+ // going to have to track down more or less how the DB stuff works
+ // when you long click on something, we're going to have to load the bigger preview at that
+ // time (worry about it later)
+ int[] cellSpans = Launcher.getSpanForWidget(mLauncher, info);
+ int maxWidth = maxWidthForWidgetPreview(cellSpans[0]);
+ int maxHeight = maxHeightForWidgetPreview(cellSpans[1]);
+ return generateWidgetPreview(info.provider, info.previewImage, info.icon,
+ cellSpans[0], cellSpans[1], maxWidth, maxHeight, preview, null);
+ }
+
+ public int maxWidthForWidgetPreview(int spanX) {
+ return Math.min(mPreviewBitmapMaxWidth,
+ mWidgetSpacingLayout.estimateCellWidth(spanX));
+ }
+
+ public int maxHeightForWidgetPreview(int spanY) {
+ return Math.min(mPreviewBitmapMaxHeight,
+ mWidgetSpacingLayout.estimateCellHeight(spanY));
+ }
+
+ public Bitmap generateWidgetPreview(ComponentName provider, int previewImage,
+ int iconId, int cellHSpan, int cellVSpan, int maxPreviewWidth, int maxPreviewHeight,
+ Bitmap preview, int[] preScaledWidthOut) {
+ // Load the preview image if possible
+ String packageName = provider.getPackageName();
+ if (maxPreviewWidth < 0) maxPreviewWidth = Integer.MAX_VALUE;
+ if (maxPreviewHeight < 0) maxPreviewHeight = Integer.MAX_VALUE;
+
+ Drawable drawable = null;
+ if (previewImage != 0) {
+ drawable = mPackageManager.getDrawable(packageName, previewImage, null);
+ if (drawable == null) {
+ Log.w(TAG, "Can't load widget preview drawable 0x" +
+ Integer.toHexString(previewImage) + " for provider: " + provider);
+ }
+ }
+
+ int previewWidth;
+ int previewHeight;
+ Bitmap defaultPreview = null;
+ boolean widgetPreviewExists = (drawable != null);
+ if (widgetPreviewExists) {
+ previewWidth = drawable.getIntrinsicWidth();
+ previewHeight = drawable.getIntrinsicHeight();
+ } else {
+ // Generate a preview image if we couldn't load one
+ if (cellHSpan < 1) cellHSpan = 1;
+ if (cellVSpan < 1) cellVSpan = 1;
+
+ BitmapDrawable previewDrawable = (BitmapDrawable) mContext.getResources()
+ .getDrawable(R.drawable.widget_preview_tile);
+ final int previewDrawableWidth = previewDrawable
+ .getIntrinsicWidth();
+ final int previewDrawableHeight = previewDrawable
+ .getIntrinsicHeight();
+ previewWidth = previewDrawableWidth * cellHSpan; // subtract 2 dips
+ previewHeight = previewDrawableHeight * cellVSpan;
+
+ defaultPreview = Bitmap.createBitmap(previewWidth, previewHeight,
+ Config.ARGB_8888);
+ final Canvas c = mCachedAppWidgetPreviewCanvas.get();
+ c.setBitmap(defaultPreview);
+ previewDrawable.setBounds(0, 0, previewWidth, previewHeight);
+ previewDrawable.setTileModeXY(Shader.TileMode.REPEAT,
+ Shader.TileMode.REPEAT);
+ previewDrawable.draw(c);
+ c.setBitmap(null);
+
+ // Draw the icon in the top left corner
+ int minOffset = (int) (mAppIconSize * sWidgetPreviewIconPaddingPercentage);
+ int smallestSide = Math.min(previewWidth, previewHeight);
+ float iconScale = Math.min((float) smallestSide
+ / (mAppIconSize + 2 * minOffset), 1f);
+
+ try {
+ Drawable icon = null;
+ int hoffset =
+ (int) ((previewDrawableWidth - mAppIconSize * iconScale) / 2);
+ int yoffset =
+ (int) ((previewDrawableHeight - mAppIconSize * iconScale) / 2);
+ if (iconId > 0)
+ icon = mIconCache.getFullResIcon(packageName, iconId);
+ if (icon != null) {
+ renderDrawableToBitmap(icon, defaultPreview, hoffset,
+ yoffset, (int) (mAppIconSize * iconScale),
+ (int) (mAppIconSize * iconScale));
+ }
+ } catch (Resources.NotFoundException e) {
+ }
+ }
+
+ // Scale to fit width only - let the widget preview be clipped in the
+ // vertical dimension
+ float scale = 1f;
+ if (preScaledWidthOut != null) {
+ preScaledWidthOut[0] = previewWidth;
+ }
+ if (previewWidth > maxPreviewWidth) {
+ scale = maxPreviewWidth / (float) previewWidth;
+ }
+ if (scale != 1f) {
+ previewWidth = (int) (scale * previewWidth);
+ previewHeight = (int) (scale * previewHeight);
+ }
+
+ // If a bitmap is passed in, we use it; otherwise, we create a bitmap of the right size
+ if (preview == null) {
+ preview = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
+ }
+
+ // Draw the scaled preview into the final bitmap
+ int x = (preview.getWidth() - previewWidth) / 2;
+ if (widgetPreviewExists) {
+ renderDrawableToBitmap(drawable, preview, x, 0, previewWidth,
+ previewHeight);
+ } else {
+ final Canvas c = mCachedAppWidgetPreviewCanvas.get();
+ final Rect src = mCachedAppWidgetPreviewSrcRect.get();
+ final Rect dest = mCachedAppWidgetPreviewDestRect.get();
+ c.setBitmap(preview);
+ src.set(0, 0, defaultPreview.getWidth(), defaultPreview.getHeight());
+ dest.set(x, 0, previewWidth, previewHeight);
+
+ Paint p = mCachedAppWidgetPreviewPaint.get();
+ if (p == null) {
+ p = new Paint();
+ p.setFilterBitmap(true);
+ mCachedAppWidgetPreviewPaint.set(p);
+ }
+ c.drawBitmap(defaultPreview, src, dest, p);
+ c.setBitmap(null);
+ }
+ return preview;
+ }
+
+ private Bitmap generateShortcutPreview(
+ ResolveInfo info, int maxWidth, int maxHeight, Bitmap preview) {
+ Bitmap tempBitmap = mCachedShortcutPreviewBitmap.get();
+ final Canvas c = mCachedShortcutPreviewCanvas.get();
+ if (tempBitmap == null ||
+ tempBitmap.getWidth() != maxWidth ||
+ tempBitmap.getHeight() != maxHeight) {
+ tempBitmap = Bitmap.createBitmap(maxWidth, maxHeight, Config.ARGB_8888);
+ mCachedShortcutPreviewBitmap.set(tempBitmap);
+ } else {
+ c.setBitmap(tempBitmap);
+ c.drawColor(0, PorterDuff.Mode.CLEAR);
+ c.setBitmap(null);
+ }
+ // Render the icon
+ Drawable icon = mIconCache.getFullResIcon(info);
+
+ int paddingTop = mContext.
+ getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_top);
+ int paddingLeft = mContext.
+ getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_left);
+ int paddingRight = mContext.
+ getResources().getDimensionPixelOffset(R.dimen.shortcut_preview_padding_right);
+
+ int scaledIconWidth = (maxWidth - paddingLeft - paddingRight);
+
+ renderDrawableToBitmap(
+ icon, tempBitmap, paddingLeft, paddingTop, scaledIconWidth, scaledIconWidth);
+
+ if (preview != null &&
+ (preview.getWidth() != maxWidth || preview.getHeight() != maxHeight)) {
+ throw new RuntimeException("Improperly sized bitmap passed as argument");
+ } else if (preview == null) {
+ preview = Bitmap.createBitmap(maxWidth, maxHeight, Config.ARGB_8888);
+ }
+
+ c.setBitmap(preview);
+ // Draw a desaturated/scaled version of the icon in the background as a watermark
+ Paint p = mCachedShortcutPreviewPaint.get();
+ if (p == null) {
+ p = new Paint();
+ ColorMatrix colorMatrix = new ColorMatrix();
+ colorMatrix.setSaturation(0);
+ p.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
+ p.setAlpha((int) (255 * 0.06f));
+ mCachedShortcutPreviewPaint.set(p);
+ }
+ c.drawBitmap(tempBitmap, 0, 0, p);
+ c.setBitmap(null);
+
+ renderDrawableToBitmap(icon, preview, 0, 0, mAppIconSize, mAppIconSize);
+
+ return preview;
+ }
+
+
+ public static void renderDrawableToBitmap(
+ Drawable d, Bitmap bitmap, int x, int y, int w, int h) {
+ renderDrawableToBitmap(d, bitmap, x, y, w, h, 1f);
+ }
+
+ private static void renderDrawableToBitmap(
+ Drawable d, Bitmap bitmap, int x, int y, int w, int h,
+ float scale) {
+ if (bitmap != null) {
+ Canvas c = new Canvas(bitmap);
+ c.scale(scale, scale);
+ Rect oldBounds = d.copyBounds();
+ d.setBounds(x, y, x + w, y + h);
+ d.draw(c);
+ d.setBounds(oldBounds); // Restore the bounds
+ c.setBitmap(null);
+ }
+ }
+
+}