Icon: a clean, parcelable place for images.

Binder APIs which wish to consume Bitmaps *and* drawable
resources can now do so by using Icon, a kind of union type
that accommodates each of these. Icon also accepts byte
arrays holding compressed Bitmaps (PNG, JPEG, etc), which
saves clients the additional memory cost of decoding and
sending full uncompressed bitmaps through Binder interfaces.
Receiving clients can call loadDrawable{,Async} and then
getDrawable to start immediately using the image in an
ImageView or other Drawable-hosting container.

Bug: 19609468
Change-Id: Ic1343711c2ac0b15876b46f0b6008b0108a49470

4 files changed, 828 insertions, 0 deletions

diff --git a/graphics/java/android/graphics/drawable/Icon.java b/graphics/java/android/graphics/drawable/Icon.java
new file mode 100644
index 0000000..47a1f77
--- /dev/null
+++ b/graphics/java/android/graphics/drawable/Icon.java
@@ -0,0 +1,482 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.graphics.drawable;
+
+import android.annotation.DrawableRes;
+import android.content.ContentResolver;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Message;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.lang.IllegalArgumentException;
+import java.lang.Override;
+
+/**
+ * An umbrella container for several serializable graphics representations, including Bitmaps,
+ * compressed bitmap images (e.g. JPG or PNG), and drawable resources (including vectors).
+ *
+ * <a href="https://developer.android.com/training/displaying-bitmaps/index.html">Much ink</a>
+ * has been spilled on the best way to load images, and many clients may have different needs when
+ * it comes to threading and fetching. This class is therefore focused on encapsulation rather than
+ * behavior.
+ */
+
+public final class Icon implements Parcelable {
+    private static final String TAG = "Icon";
+
+    private static final int TYPE_BITMAP   = 1;
+    private static final int TYPE_RESOURCE = 2;
+    private static final int TYPE_DATA     = 3;
+    private static final int TYPE_URI      = 4;
+
+    private final int mType;
+
+    // To avoid adding unnecessary overhead, we have a few basic objects that get repurposed
+    // based on the value of mType.
+
+    // TYPE_BITMAP: Bitmap
+    // TYPE_RESOURCE: Resources
+    // TYPE_DATA: DataBytes
+    private Object          mObj1;
+
+    // TYPE_RESOURCE: package name
+    // TYPE_URI: uri string
+    private String          mString1;
+
+    // TYPE_RESOURCE: resId
+    // TYPE_DATA: data length
+    private int             mInt1;
+
+    // TYPE_DATA: data offset
+    private int             mInt2;
+
+    // Internal accessors for different mType variants
+    private Bitmap getBitmap() {
+        if (mType != TYPE_BITMAP) {
+            throw new IllegalStateException("called getBitmap() on " + this);
+        }
+        return (Bitmap) mObj1;
+    }
+
+    private int getDataLength() {
+        if (mType != TYPE_DATA) {
+            throw new IllegalStateException("called getDataLength() on " + this);
+        }
+        synchronized (this) {
+            return mInt1;
+        }
+    }
+
+    private int getDataOffset() {
+        if (mType != TYPE_DATA) {
+            throw new IllegalStateException("called getDataOffset() on " + this);
+        }
+        synchronized (this) {
+            return mInt2;
+        }
+    }
+
+    private byte[] getDataBytes() {
+        if (mType != TYPE_DATA) {
+            throw new IllegalStateException("called getDataBytes() on " + this);
+        }
+        synchronized (this) {
+            return (byte[]) mObj1;
+        }
+    }
+
+    private Resources getResources() {
+        if (mType != TYPE_RESOURCE) {
+            throw new IllegalStateException("called getResources() on " + this);
+        }
+        return (Resources) mObj1;
+    }
+
+    private String getResPackage() {
+        if (mType != TYPE_RESOURCE) {
+            throw new IllegalStateException("called getResPackage() on " + this);
+        }
+        return mString1;
+    }
+
+    private int getResId() {
+        if (mType != TYPE_RESOURCE) {
+            throw new IllegalStateException("called getResId() on " + this);
+        }
+        return mInt1;
+    }
+
+    private String getUriString() {
+        if (mType != TYPE_URI) {
+            throw new IllegalStateException("called getUriString() on " + this);
+        }
+        return mString1;
+    }
+
+    private Uri getUri() {
+        return Uri.parse(getUriString());
+    }
+
+    // Convert a int32 into a four-char string
+    private static final String typeToString(int x) {
+        switch (x) {
+            case TYPE_BITMAP: return "BITMAP";
+            case TYPE_DATA: return "DATA";
+            case TYPE_RESOURCE: return "RESOURCE";
+            case TYPE_URI: return "URI";
+            default: return "UNKNOWN";
+        }
+    }
+
+    /**
+     * Invokes {@link #loadDrawable(Context)} on the given {@link android.os.Handler Handler}
+     * and then sends <code>andThen</code> to the same Handler when finished.
+     *
+     * @param context {@link android.content.Context Context} in which to load the drawable; see
+     *                {@link #loadDrawable(Context)}
+     * @param andThen {@link android.os.Message} to send to its target once the drawable
+     *                is available. The {@link android.os.Message#obj obj}
+     *                property is populated with the Drawable.
+     */
+    public void loadDrawableAsync(Context context, Message andThen) {
+        if (andThen.getTarget() == null) {
+            throw new IllegalArgumentException("callback message must have a target handler");
+        }
+        new LoadDrawableTask(context, andThen).runAsync();
+    }
+
+    /**
+     * Invokes {@link #loadDrawable(Context)} on a background thread
+     * and then runs <code>andThen</code> on the UI thread when finished.
+     *
+     * @param context {@link android.content.Context Context} in which to load the drawable; see
+     *                {@link #loadDrawable(Context)}
+     * @param handler {@link android.os.Handler} on which to run <code>andThen</code>.
+     * @param listener a callback to run on the provided
+     *                 Handler once the drawable is available.
+     */
+    public void loadDrawableAsync(Context context, Handler handler,
+            final OnDrawableLoadedListener listener) {
+        new LoadDrawableTask(context, handler, listener).runAsync();
+    }
+
+    /**
+     * Returns a Drawable that can be used to draw the image inside this Icon, constructing it
+     * if necessary. Depending on the type of image, this may not be something you want to do on
+     * the UI thread, so consider using
+     * {@link #loadDrawableAsync(Context, Message) loadDrawableAsync} instead.
+     *
+     * @param context {@link android.content.Context Context} in which to load the drawable; used
+     *                to access {@link android.content.res.Resources Resources}, for example.
+     * @return A fresh instance of a drawable for this image, yours to keep.
+     */
+    public Drawable loadDrawable(Context context) {
+        switch (mType) {
+            case TYPE_BITMAP:
+                return new BitmapDrawable(context.getResources(), getBitmap());
+            case TYPE_RESOURCE:
+                if (getResources() == null) {
+                    if (getResPackage() == null || "android".equals(getResPackage())) {
+                        mObj1 = Resources.getSystem();
+                    } else {
+                        final PackageManager pm = context.getPackageManager();
+                        try {
+                            mObj1 = pm.getResourcesForApplication(getResPackage());
+                        } catch (PackageManager.NameNotFoundException e) {
+                            Log.e(TAG,
+                                    String.format("Unable to find package '%s'", getResPackage()),
+                                    e);
+                            break;
+                        }
+                    }
+                }
+                return getResources().getDrawable(getResId(), context.getTheme());
+            case TYPE_DATA:
+                return new BitmapDrawable(context.getResources(),
+                    BitmapFactory.decodeByteArray(getDataBytes(), getDataOffset(), getDataLength())
+                );
+            case TYPE_URI:
+                final Uri uri = getUri();
+                final String scheme = uri.getScheme();
+                InputStream is = null;
+                if (ContentResolver.SCHEME_CONTENT.equals(scheme)
+                        || ContentResolver.SCHEME_FILE.equals(scheme)) {
+                    try {
+                        is = context.getContentResolver().openInputStream(uri);
+                    } catch (Exception e) {
+                        Log.w(TAG, "Unable to load image from URI: " + uri, e);
+                    }
+                } else {
+                    try {
+                        is = new FileInputStream(new File(mString1));
+                    } catch (FileNotFoundException e) {
+                        Log.w(TAG, "Unable to load image from path: " + uri, e);
+                    }
+                }
+                if (is != null) {
+                    return new BitmapDrawable(context.getResources(),
+                            BitmapFactory.decodeStream(is));
+                }
+                break;
+        }
+        return null;
+    }
+
+    private Icon(int mType) {
+        this.mType = mType;
+    }
+
+    /**
+     * Create a Icon pointing to a drawable resource.
+     * @param res Resources for a package containing the resource in question
+     * @param resid ID of the drawable resource
+     */
+    public static Icon createWithResource(Resources res, @DrawableRes int resid) {
+        final Icon rep = new Icon(TYPE_RESOURCE);
+        rep.mObj1 = res;
+        rep.mInt1 = resid;
+        rep.mString1 = res.getResourcePackageName(resid);
+        return rep;
+    }
+
+    /**
+     * Create a Icon pointing to a bitmap in memory.
+     * @param bits A valid {@link android.graphics.Bitmap} object
+     */
+    public static Icon createWithBitmap(Bitmap bits) {
+        final Icon rep = new Icon(TYPE_BITMAP);
+        rep.mObj1 = bits;
+        return rep;
+    }
+
+    /**
+     * Create a Icon pointing to a compressed bitmap stored in a byte array.
+     * @param data Byte array storing compressed bitmap data of a type that
+     *             {@link android.graphics.BitmapFactory}
+     *             can decode (see {@link android.graphics.Bitmap.CompressFormat}).
+     * @param offset Offset into <code>data</code> at which the bitmap data starts
+     * @param length Length of the bitmap data
+     */
+    public static Icon createWithData(byte[] data, int offset, int length) {
+        final Icon rep = new Icon(TYPE_DATA);
+        rep.mObj1 = data;
+        rep.mInt1 = length;
+        rep.mInt2 = offset;
+        return rep;
+    }
+
+    /**
+     * Create a Icon pointing to a content specified by URI.
+     *
+     * @param uri A uri referring to local content:// or file:// image data.
+     */
+    public static Icon createWithContentUri(String uri) {
+        final Icon rep = new Icon(TYPE_URI);
+        rep.mString1 = uri;
+        return rep;
+    }
+
+    /**
+     * Create a Icon pointing to a content specified by URI.
+     *
+     * @param uri A uri referring to local content:// or file:// image data.
+     */
+    public static Icon createWithContentUri(Uri uri) {
+        final Icon rep = new Icon(TYPE_URI);
+        rep.mString1 = uri.toString();
+        return rep;
+    }
+
+    /**
+     * Create a Icon pointing to
+     *
+     * @param path A path to a file that contains compressed bitmap data of
+     *           a type that {@link android.graphics.BitmapFactory} can decode.
+     */
+    public static Icon createWithFilePath(String path) {
+        final Icon rep = new Icon(TYPE_URI);
+        rep.mString1 = path;
+        return rep;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("Icon(typ=").append(typeToString(mType));
+        switch (mType) {
+            case TYPE_BITMAP:
+                sb.append(" size=")
+                        .append(getBitmap().getWidth())
+                        .append("x")
+                        .append(getBitmap().getHeight());
+                break;
+            case TYPE_RESOURCE:
+                sb.append(" pkg=")
+                        .append(getResPackage())
+                        .append(" id=")
+                        .append(String.format("%08x", getResId()));
+                break;
+            case TYPE_DATA:
+                sb.append(" len=").append(getDataLength());
+                if (getDataOffset() != 0) {
+                    sb.append(" off=").append(getDataOffset());
+                }
+                break;
+            case TYPE_URI:
+                sb.append(" uri=").append(getUriString());
+                break;
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    /**
+     * Parcelable interface
+     */
+    public int describeContents() {
+        return (mType == TYPE_BITMAP || mType == TYPE_DATA)
+                ? Parcelable.CONTENTS_FILE_DESCRIPTOR : 0;
+    }
+
+    // ===== Parcelable interface ======
+
+    private Icon(Parcel in) {
+        this(in.readInt());
+        switch (mType) {
+            case TYPE_BITMAP:
+                final Bitmap bits = Bitmap.CREATOR.createFromParcel(in);
+                mObj1 = bits;
+                break;
+            case TYPE_RESOURCE:
+                final String pkg = in.readString();
+                final int resId = in.readInt();
+                mString1 = pkg;
+                mInt1 = resId;
+                break;
+            case TYPE_DATA:
+                final int len = in.readInt();
+                final byte[] a = in.readBlob();
+                if (len != a.length) {
+                    throw new RuntimeException("internal unparceling error: blob length ("
+                            + a.length + ") != expected length (" + len + ")");
+                }
+                mInt1 = len;
+                mObj1 = a;
+                break;
+            case TYPE_URI:
+                final String uri = in.readString();
+                mString1 = uri;
+                break;
+            default:
+                throw new RuntimeException("invalid "
+                        + this.getClass().getSimpleName() + " type in parcel: " + mType);
+        }
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        switch (mType) {
+            case TYPE_BITMAP:
+                final Bitmap bits = getBitmap();
+                dest.writeInt(TYPE_BITMAP);
+                getBitmap().writeToParcel(dest, flags);
+                break;
+            case TYPE_RESOURCE:
+                dest.writeInt(TYPE_RESOURCE);
+                dest.writeString(getResPackage());
+                dest.writeInt(getResId());
+                break;
+            case TYPE_DATA:
+                dest.writeInt(TYPE_DATA);
+                dest.writeInt(getDataLength());
+                dest.writeBlob(getDataBytes(), getDataOffset(), getDataLength());
+                break;
+            case TYPE_URI:
+                dest.writeInt(TYPE_URI);
+                dest.writeString(getUriString());
+                break;
+        }
+    }
+
+    public static final Parcelable.Creator<Icon> CREATOR
+            = new Parcelable.Creator<Icon>() {
+        public Icon createFromParcel(Parcel in) {
+            return new Icon(in);
+        }
+
+        public Icon[] newArray(int size) {
+            return new Icon[size];
+        }
+    };
+
+    /**
+     * Implement this interface to receive notification when
+     * {@link #loadDrawableAsync(Context, Handler, OnDrawableLoadedListener) loadDrawableAsync}
+     * is finished and your Drawable is ready.
+     */
+    public interface OnDrawableLoadedListener {
+        void onDrawableLoaded(Drawable d);
+    }
+
+    /**
+     * Wrapper around loadDrawable that does its work on a pooled thread and then
+     * fires back the given (targeted) Message.
+     */
+    private class LoadDrawableTask implements Runnable {
+        final Context mContext;
+        final Message mMessage;
+
+        public LoadDrawableTask(Context context, final Handler handler,
+                final OnDrawableLoadedListener listener) {
+            mContext = context;
+            mMessage = Message.obtain(handler, new Runnable() {
+                    @Override
+                    public void run() {
+                        listener.onDrawableLoaded((Drawable) mMessage.obj);
+                    }
+                });
+        }
+
+        public LoadDrawableTask(Context context, Message message) {
+            mContext = context;
+            mMessage = message;
+        }
+
+        @Override
+        public void run() {
+            mMessage.obj = loadDrawable(mContext);
+            mMessage.sendToTarget();
+        }
+
+        public void runAsync() {
+            AsyncTask.THREAD_POOL_EXECUTOR.execute(this);
+        }
+    }
+}
diff --git a/graphics/tests/graphicstests/AndroidManifest.xml b/graphics/tests/graphicstests/AndroidManifest.xml
index 5fb5959..e019e28 100644
--- a/graphics/tests/graphicstests/AndroidManifest.xml
+++ b/graphics/tests/graphicstests/AndroidManifest.xml
@@ -24,6 +24,7 @@
     <uses-permission android:name="android.permission.CHANGE_CONFIGURATION" />
     <uses-permission android:name="android.permission.WRITE_APN_SETTINGS" />
     <uses-permission android:name="android.permission.BROADCAST_STICKY" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
  
     <application>
diff --git a/graphics/tests/graphicstests/res/drawable-nodpi/landscape.png b/graphics/tests/graphicstests/res/drawable-nodpi/landscape.png
new file mode 100644
index 0000000..ddb3180
--- /dev/null
+++ b/graphics/tests/graphicstests/res/drawable-nodpi/landscape.png
diff --git a/graphics/tests/graphicstests/src/android/graphics/drawable/IconTest.java b/graphics/tests/graphicstests/src/android/graphics/drawable/IconTest.java
new file mode 100644
index 0000000..2b9bf50
--- /dev/null
+++ b/graphics/tests/graphicstests/src/android/graphics/drawable/IconTest.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.graphics.drawable;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Parcel;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.lang.Override;
+import java.util.Arrays;
+import java.util.ArrayList;
+
+import junit.framework.TestCase;
+
+import com.android.frameworks.graphicstests.R;
+
+public class IconTest extends AndroidTestCase {
+    public static final String TAG = IconTest.class.getSimpleName();
+    public static void L(String s, Object... parts) {
+        Log.d(TAG, (parts.length == 0) ? s : String.format(s, parts));
+    }
+
+    @SmallTest
+    public void testWithBitmap() throws Exception {
+        final Bitmap bm1 = Bitmap.createBitmap(100, 200, Bitmap.Config.ARGB_8888);
+        final Bitmap bm2 = Bitmap.createBitmap(100, 200, Bitmap.Config.RGB_565);
+        final Bitmap bm3 = ((BitmapDrawable) getContext().getDrawable(R.drawable.landscape))
+                .getBitmap();
+
+        final Canvas can1 = new Canvas(bm1);
+        can1.drawColor(0xFFFF0000);
+        final Canvas can2 = new Canvas(bm2);
+        can2.drawColor(0xFF00FF00);
+
+        final Icon im1 = Icon.createWithBitmap(bm1);
+        final Icon im2 = Icon.createWithBitmap(bm2);
+        final Icon im3 = Icon.createWithBitmap(bm3);
+
+        final Drawable draw1 = im1.loadDrawable(mContext);
+        final Drawable draw2 = im2.loadDrawable(mContext);
+        final Drawable draw3 = im3.loadDrawable(mContext);
+
+        final Bitmap test1 = Bitmap.createBitmap(draw1.getIntrinsicWidth(),
+                draw1.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        final Bitmap test2 = Bitmap.createBitmap(draw2.getIntrinsicWidth(),
+                draw2.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        final Bitmap test3 = Bitmap.createBitmap(draw3.getIntrinsicWidth(),
+                draw3.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+
+        draw1.setBounds(0, 0, draw1.getIntrinsicWidth(), draw1.getIntrinsicHeight());
+        draw1.draw(new Canvas(test1));
+
+        draw2.setBounds(0, 0, draw2.getIntrinsicWidth(), draw2.getIntrinsicHeight());
+        draw2.draw(new Canvas(test2));
+
+        draw3.setBounds(0, 0, draw3.getIntrinsicWidth(), draw3.getIntrinsicHeight());
+        draw3.draw(new Canvas(test3));
+
+        final File dir = getContext().getExternalFilesDir(null);
+        L("writing temp bitmaps to %s...", dir);
+
+        bm1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap1-original.png")));
+        test1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap1-test.png")));
+        if (!equalBitmaps(bm1, test1)) {
+            findBitmapDifferences(bm1, test1);
+            fail("bitmap1 differs, check " + dir);
+        }
+
+        bm2.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap2-original.png")));
+        test2.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap2-test.png")));
+        if (!equalBitmaps(bm2, test2)) {
+            findBitmapDifferences(bm2, test2);
+            fail("bitmap2 differs, check " + dir);
+        }
+
+        bm3.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap3-original.png")));
+        test3.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "bitmap3-test.png")));
+        if (!equalBitmaps(bm3, test3)) {
+            findBitmapDifferences(bm3, test3);
+            fail("bitmap3 differs, check " + dir);
+        }
+    }
+
+    @SmallTest
+    public void testWithBitmapResource() throws Exception {
+        final Bitmap res1 = ((BitmapDrawable) getContext().getDrawable(R.drawable.landscape))
+                .getBitmap();
+
+        final Icon im1 = Icon.createWithResource(getContext().getResources(),
+                R.drawable.landscape);
+        final Drawable draw1 = im1.loadDrawable(mContext);
+        final Bitmap test1 = Bitmap.createBitmap(draw1.getIntrinsicWidth(),
+                draw1.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        draw1.setBounds(0, 0, test1.getWidth(), test1.getHeight());
+        draw1.draw(new Canvas(test1));
+
+        final File dir = getContext().getExternalFilesDir(null);
+        res1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "res1-original.png")));
+        test1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "res1-test.png")));
+        if (!equalBitmaps(res1, test1)) {
+            findBitmapDifferences(res1, test1);
+            fail("res1 differs, check " + dir);
+        }
+    }
+
+    @SmallTest
+    public void testWithFile() throws Exception {
+        final Bitmap bit1 = ((BitmapDrawable) getContext().getDrawable(R.drawable.landscape))
+                .getBitmap();
+        final File dir = getContext().getExternalFilesDir(null);
+        final File file1 = new File(dir, "file1-original.png");
+        bit1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(file1));
+
+        final Icon im1 = Icon.createWithFilePath(file1.toString());
+        final Drawable draw1 = im1.loadDrawable(mContext);
+        final Bitmap test1 = Bitmap.createBitmap(draw1.getIntrinsicWidth(),
+                draw1.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        draw1.setBounds(0, 0, test1.getWidth(), test1.getHeight());
+        draw1.draw(new Canvas(test1));
+
+        test1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(new File(dir, "file1-test.png")));
+        if (!equalBitmaps(bit1, test1)) {
+            findBitmapDifferences(bit1, test1);
+            fail("testWithFile: file1 differs, check " + dir);
+        }
+    }
+
+    @SmallTest
+    public void testAsync() throws Exception {
+        final Bitmap bit1 = ((BitmapDrawable) getContext().getDrawable(R.drawable.landscape))
+                .getBitmap();
+        final File dir = getContext().getExternalFilesDir(null);
+        final File file1 = new File(dir, "async-original.png");
+        bit1.compress(Bitmap.CompressFormat.PNG, 100,
+                new FileOutputStream(file1));
+
+        final Icon im1 = Icon.createWithFilePath(file1.toString());
+        final HandlerThread thd = new HandlerThread("testAsync");
+        thd.start();
+        final Handler h = new Handler(thd.getLooper());
+        L(TAG, "asyncTest: dispatching load to thread: " + thd);
+        im1.loadDrawableAsync(mContext, h, new Icon.OnDrawableLoadedListener() {
+            @Override
+            public void onDrawableLoaded(Drawable draw1) {
+                L(TAG, "asyncTest: thread: loading drawable");
+                L(TAG, "asyncTest: thread: loaded: %dx%d", draw1.getIntrinsicWidth(),
+                    draw1.getIntrinsicHeight());
+                final Bitmap test1 = Bitmap.createBitmap(draw1.getIntrinsicWidth(),
+                        draw1.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+                draw1.setBounds(0, 0, test1.getWidth(), test1.getHeight());
+                draw1.draw(new Canvas(test1));
+
+                try {
+                    test1.compress(Bitmap.CompressFormat.PNG, 100,
+                            new FileOutputStream(new File(dir, "async-test.png")));
+                } catch (java.io.FileNotFoundException ex) {
+                    fail("couldn't create test file: " + ex);
+                }
+                if (!equalBitmaps(bit1, test1)) {
+                    findBitmapDifferences(bit1, test1);
+                    fail("testAsync: file1 differs, check " + dir);
+                }
+            }
+        });
+        L(TAG, "asyncTest: awaiting result");
+        Thread.sleep(500); // ;_;
+        assertTrue("async-test.png does not exist!", new File(dir, "async-test.png").exists());
+        L(TAG, "asyncTest: done");
+    }
+
+    @SmallTest
+    public void testParcel() throws Exception {
+        final Bitmap originalbits = ((BitmapDrawable) getContext().getDrawable(R.drawable.landscape))
+                .getBitmap();
+
+        final ByteArrayOutputStream ostream = new ByteArrayOutputStream(
+                originalbits.getWidth() * originalbits.getHeight() * 2); // guess 50% compression
+        originalbits.compress(Bitmap.CompressFormat.PNG, 100, ostream);
+        final byte[] pngdata = ostream.toByteArray();
+
+        L("starting testParcel; bitmap: %d bytes, PNG: %d bytes",
+                originalbits.getByteCount(),
+                pngdata.length);
+
+        final File dir = getContext().getExternalFilesDir(null);
+        final File originalfile = new File(dir, "parcel-original.png");
+        new FileOutputStream(originalfile).write(pngdata);
+
+        ArrayList<Icon> imgs = new ArrayList<>();
+        final Icon file1 = Icon.createWithFilePath(originalfile.getAbsolutePath());
+        imgs.add(file1);
+        final Icon bit1 = Icon.createWithBitmap(originalbits);
+        imgs.add(bit1);
+        final Icon data1 = Icon.createWithData(pngdata, 0, pngdata.length);
+        imgs.add(data1);
+        final Icon res1 = Icon.createWithResource(getContext().getResources(), R.drawable.landscape);
+        imgs.add(res1);
+
+        ArrayList<Icon> test = new ArrayList<>();
+        final Parcel parcel = Parcel.obtain();
+        int pos = 0;
+        parcel.writeInt(imgs.size());
+        for (Icon img : imgs) {
+            img.writeToParcel(parcel, 0);
+            L("used %d bytes parceling: %s", parcel.dataPosition() - pos, img);
+            pos = parcel.dataPosition();
+        }
+
+        parcel.setDataPosition(0); // rewind
+        final int N = parcel.readInt();
+        for (int i=0; i<N; i++) {
+            Icon img = Icon.CREATOR.createFromParcel(parcel);
+            L("test %d: read from parcel: %s", i, img);
+            final File testfile = new File(dir,
+                    String.format("parcel-test%02d.png", i));
+
+            final Drawable draw1 = img.loadDrawable(mContext);
+            if (draw1 == null) {
+                fail("null drawable from img: " + img);
+            }
+            final Bitmap test1 = Bitmap.createBitmap(draw1.getIntrinsicWidth(),
+                    draw1.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+            draw1.setBounds(0, 0, test1.getWidth(), test1.getHeight());
+            draw1.draw(new Canvas(test1));
+
+            try {
+                test1.compress(Bitmap.CompressFormat.PNG, 100,
+                        new FileOutputStream(testfile));
+            } catch (java.io.FileNotFoundException ex) {
+                fail("couldn't create test file " + testfile + ": " + ex);
+            }
+            if (!equalBitmaps(originalbits, test1)) {
+                findBitmapDifferences(originalbits, test1);
+                fail(testfile + " differs from original: " + originalfile);
+            }
+
+        }
+    }
+
+
+    // ======== utils ========
+
+    static final char[] GRADIENT = " .:;+=xX$#".toCharArray();
+    static float[] hsv = new float[3];
+    static char colorToChar(int color) {
+        int sum = ((color >> 16) & 0xff)
+                + ((color >> 8)  & 0xff)
+                + ((color)       & 0xff);
+        return GRADIENT[sum * (GRADIENT.length-1) / (3*0xff)];
+    }
+    static void printBits(int[] a, int w, int h) {
+        final StringBuilder sb = new StringBuilder();
+        for (int i=0; i<w; i++) {
+            for (int j=0; j<h; j++) {
+                sb.append(colorToChar(a[i+w*j]));
+            }
+            sb.append('\n');
+        }
+        L(sb.toString());
+    }
+    static void printBits(Bitmap a) {
+        final int w = a.getWidth();
+        final int h = a.getHeight();
+        int[] aPix = new int[w * h];
+        printBits(aPix, w, h);
+    }
+    boolean equalBitmaps(Bitmap a, Bitmap b) {
+        if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) return false;
+        
+        final int w = a.getWidth();
+        final int h = a.getHeight();
+        int[] aPix = new int[w * h];
+        int[] bPix = new int[w * h];
+
+        a.getPixels(aPix, 0, w, 0, 0, w, h);
+        b.getPixels(bPix, 0, w, 0, 0, w, h);
+
+        return Arrays.equals(aPix, bPix);
+    }
+
+    void findBitmapDifferences(Bitmap a, Bitmap b) {
+        if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) {
+            L("different sizes: %dx%d vs %dx%d",
+                        a.getWidth(), a.getHeight(), b.getWidth(), b.getHeight());
+            return;
+        }
+        
+        final int w = a.getWidth();
+        final int h = a.getHeight();
+        int[] aPix = new int[w * h];
+        int[] bPix = new int[w * h];
+
+        a.getPixels(aPix, 0, w, 0, 0, w, h);
+        b.getPixels(bPix, 0, w, 0, 0, w, h);
+
+        L("bitmap a (%dx%d)", w, h);
+        printBits(aPix, w, h);
+        L("bitmap b (%dx%d)", w, h);
+        printBits(bPix, w, h);
+
+        StringBuffer sb = new StringBuffer("Different pixels: ");
+        for (int i=0; i<w; i++) {
+            for (int j=0; j<h; j++) {
+                if (aPix[i+w*j] != bPix[i+w*j]) {
+                    sb.append(" ").append(i).append(",").append(j);
+                }
+            }
+        }
+        L(sb.toString());
+    }
+}