Themes: Port to CM12 [4/6]

Auto-generate previews.

Id: Ia8f12bc852fb708e52ccc98641eea278756b198f

Add MODIFIES_STATUS_BAR and MODIFIES_NAVIGATION_BAR

Id: If1f81b122cfb5075835c70dff0bcfa6dea5d8de8

Use image with largest size for boot ani preview.

Id: I3f2c16aa6ceb18387925e2cf2812d8c3ddf0d3d7

Use same components used in the original chooser.

Icon previews will be generated using the same login used in the
theme chooser v1.

Id: Iafcd9f3d78fc86a66fe3635d27ee9fb7d47ae531

Remove (Default) from Holo's title.

Holo may not be the default theme and therefore we should not add
this to the title.  The clients can handle determining which theme
is the default on a device and act accordingly.

Id: I162b3af97b05205c3ddf1e6ce130d05d9e0fe81f

Add query for retrieving previews of currently applied components.

Id: Ic3cffb4b762a047af40c72846e6e6bcf9a273619

Delete previews from provider when theme removed

Id: Ica221885b929f7671f048d367648f7c6f82e4529

Alias status bar background as navbar_background

Id: I3a32ea59e8fa94689d20fe92fbbc544b9da6e32b

Fix provider not updating previews due to missing action.

Id: Icd9f38ab499cfc617862be7638f06a9273dbdc22

Retrieve correct wallpaper size and store as jpeg

Id: I346516a5860819f15a6b689e6da1a6bdf4f2540f

Add style preview.

What was originally called STYLE_PREVIEW is now STYLE_THUMBNAIL and
STYLE_PREVIEW is now a larger sized image of various controls.

Id: Iecf9785e992efa98360c84af2054d3a2a113f094

Use ThemeUtils methods for getting wallpaper paths.

Id: I7fb269abe38560d638a2bad74fcfb7ed6a9a4c43

Add newly added navbar background in ThemesContract. [1/2]

Id: I6fc92388a58b69c7a52053103cf85bb348f6144a

Keep track of when a theme was installed

Id: I9cdf637d63a4ed3d14b978a7d6c019aed0afe8e0

Update provider with ComposedIconInfo changes in f/b

Id: I6ad0db5f55ed0dfb42c30cb5946f5c10af5b5a0f

Use getThemedResourcesForApplication for icons

Since we no longer pass bitmaps around in ComposedIconInfo we need
to make sure the icons are actually attached to the resources in
order to retrieve the drawables for the composed icons.

Id: I7c92ee9d4114399024743c01d0df7fcc0284c150

Themes: Let ThemeService handle all theme processing [3/3]

Id: Ied877eb5f1e96774d2e415970034d0b892765134

Add theme to db when installed and defer processing

This allows the theme to show up in the theme provider even though
the theme resources still need to be compiled.  Once they are compiled
the themes provider will update the database with the previews.

Id: I2505cb875ee36975745a46469b2e55afe4fd1e68

Catch excpetions that occur when generating icon previews

Id: I22e270911af12b6bd3cd69c84205d8455f74cf79
REF: THEMES-387

Catch all exceptions for styles and systemui previews

Id: I4e3ee24e049d6dedba331175e21a143872de1f8e

Presentable themes should contian icons, wallpaper and overlays

The thems provider considered any theme with 2 or more components as
a presentable theme which may not be represented well in the Theme Chooser.
This patch makes it mandatory that a theme have icons, wallpaper and
overlays in order to be considered a presentable theme.

Id: If9918bd50125a4cd74b7926c5617c882eb89d5c2
REF: CHOOSER-2

Get working on CM12

Id: If585b1c9ee10b049f473ba2ca4ee313e09b6e715

Add column for target api

This column will allow us to easily track what version of CM a
theme was built for in case of incompatibility issues.  The
system theme will have a value of 0 indicating that it works on
whatever the current api level is on the device.  This prevents us
from updating the row for the system font whenever the api level
increases.

Id: Ic43b63f2f801243914124043c4f4113a6b75b914

CM11 -> CM12 Upgrade [2/3]

Renamed the "holo" theme to "system"

Id: I82f2cde2e26e0b13c95ebb0fc61253c805c0a16e

Fix String.format in upgradeToVersion11()

Id: I13917d0c7ab34ff25a6326aebc0d707780bd6769

Change-Id: Ic98ec257e56a82d7faef37c0d2a2cfe360d6e35c

1 files changed, 222 insertions, 0 deletions

diff --git a/src/org/cyanogenmod/themes/provider/util/BitmapUtils.java b/src/org/cyanogenmod/themes/provider/util/BitmapUtils.java
new file mode 100644
index 0000000..002970b
--- /dev/null
+++ b/src/org/cyanogenmod/themes/provider/util/BitmapUtils.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2014 The CyanogenMod 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 org.cyanogenmod.themes.provider.util;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.BitmapRegionDecoder;
+import android.graphics.Rect;
+import android.net.Uri;
+import android.util.Log;
+import android.util.TypedValue;
+
+import java.io.Closeable;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class BitmapUtils {
+    private static final String TAG = "BitmapUtils";
+
+    /**
+     * Returns the bitmap from the given uri loaded using the given options.
+     * Returns null on failure.
+     */
+    public static Bitmap loadBitmap(Context context, InputStream is, BitmapFactory.Options o) {
+        try {
+            return BitmapFactory.decodeStream(is, null, o);
+        } finally {
+            closeSilently(is);
+        }
+    }
+
+    public static Bitmap decodeFile(String path, int reqWidth, int reqHeight) {
+        FileInputStream fis = null;
+        try {
+            fis = new FileInputStream(path);
+            return decodeStream(fis, reqWidth, reqHeight);
+        } catch (FileNotFoundException e) {
+            Log.e(TAG, "Unable to open resource in path" + path, e);
+        } finally {
+            closeSilently(fis);
+        }
+        return null;
+    }
+
+    public static Bitmap decodeStream(InputStream is, int reqWidth, int reqHeight) {
+        BitmapFactory.Options opts = new BitmapFactory.Options();
+
+        // Determine insample size
+        opts.inJustDecodeBounds = true;
+        BitmapFactory.decodeStream(is, null, opts);
+        opts.inSampleSize = calculateInSampleSize(opts, reqWidth, reqHeight);
+
+        // Decode the bitmap, regionally if necessary
+        Bitmap bitmap = null;
+        opts.inJustDecodeBounds = false;
+        Rect rect = getCropRectIfNecessary(opts, reqWidth, reqHeight);
+        try {
+            if (rect != null) {
+                BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(is, false);
+                bitmap = decoder.decodeRegion(rect, opts);
+            } else {
+                bitmap = BitmapFactory.decodeStream(is, null, opts);
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Unable to decode bitmap from stream", e);
+        }
+        return bitmap;
+    }
+
+    public static Bitmap decodeResource(Resources res, int resId, int reqWidth, int reqHeight) {
+        BitmapFactory.Options opts = new BitmapFactory.Options();
+
+        // Determine insample size
+        opts.inJustDecodeBounds = true;
+        BitmapFactory.decodeResource(res, resId, opts);
+        opts.inSampleSize = calculateInSampleSize(opts, reqWidth, reqHeight);
+
+        // Decode the bitmap, regionally if necessary
+        Bitmap bitmap = null;
+        opts.inJustDecodeBounds = false;
+        Rect rect = getCropRectIfNecessary(opts, reqWidth, reqHeight);
+
+        InputStream stream = null;
+        try {
+            if (rect != null) {
+                stream = res.openRawResource(resId, new TypedValue());
+                if (stream == null) return null;
+                BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(stream, false);
+                bitmap = decoder.decodeRegion(rect, opts);
+            } else {
+                bitmap = BitmapFactory.decodeResource(res, resId, opts);
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Unable to open resource " + resId, e);
+        } finally {
+            closeSilently(stream);
+        }
+        return bitmap;
+    }
+
+
+    public static Bitmap decodeByteArray(byte[] buffer, int reqWidth, int reqHeight) {
+        BitmapFactory.Options opts = new BitmapFactory.Options();
+
+        // Determine insample size
+        opts.inJustDecodeBounds = true;
+        BitmapFactory.decodeByteArray(buffer, 0, buffer.length, opts);
+        opts.inSampleSize = calculateInSampleSize(opts, reqWidth, reqHeight);
+
+        // Decode the bitmap, regionally if necessary
+        Bitmap bitmap = null;
+        opts.inJustDecodeBounds = false;
+        Rect rect = getCropRectIfNecessary(opts, reqWidth, reqHeight);
+        try {
+            if (rect != null) {
+                BitmapRegionDecoder decoder =
+                        BitmapRegionDecoder.newInstance(buffer, 0, buffer.length, false);
+                bitmap = decoder.decodeRegion(rect, opts);
+            } else {
+                bitmap = BitmapFactory.decodeByteArray(buffer, 0, buffer.length, opts);
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Unable to decode bitmap from stream", e);
+        }
+        return bitmap;
+    }
+
+    public static Bitmap getBitmapFromAsset(Context ctx, String path, int reqWidth, int reqHeight) {
+        if (ctx == null || path == null)
+            return null;
+
+        Bitmap bitmap = null;
+        try {
+            AssetManager assets = ctx.getAssets();
+            InputStream is = assets.open(path);
+            bitmap = decodeStream(is, reqWidth, reqHeight);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return bitmap;
+    }
+
+
+    /**
+     * For excessively large images with an awkward ratio we
+     * will want to crop them
+     * @return
+     */
+    public static Rect getCropRectIfNecessary(
+            BitmapFactory.Options options,int reqWidth, int reqHeight) {
+        final int width = options.outWidth;
+        final int height = options.outHeight;
+        Rect rect = new Rect(0, 0, width, height);
+        // Determine downsampled size
+        int targetWidth = reqWidth * options.inSampleSize;
+        int targetHeight = reqHeight * options.inSampleSize;
+
+        if (targetHeight < height) {
+            rect.top = (height - targetHeight) / 2;
+            rect.bottom = rect.top + targetHeight;
+        }
+        if (targetWidth < width) {
+            rect.left = (width - targetWidth) / 2;
+            rect.right = rect.left + targetWidth;
+        }
+        return rect;
+    }
+
+    public static int calculateInSampleSize(
+            BitmapFactory.Options options, int reqWidth, int reqHeight) {
+        return calculateInSampleSize(options.outWidth, options.outHeight, reqWidth, reqHeight);
+    }
+
+    // Modified from original source:
+    // http://developer.android.com/training/displaying-bitmaps/load-bitmap.html
+    public static int calculateInSampleSize(
+            int decodeWidth, int decodeHeight, int reqWidth, int reqHeight) {
+        // Raw height and width of image
+        int inSampleSize = 1;
+
+        if (decodeHeight > reqHeight || decodeWidth > reqWidth) {
+            final int halfHeight = decodeHeight / 2;
+            final int halfWidth = decodeWidth / 2;
+
+            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+            // height and width larger than the requested height and width.
+            while ((halfHeight / inSampleSize) > reqHeight &&
+                    (halfWidth / inSampleSize) > reqWidth) {
+                inSampleSize *= 2;
+            }
+        }
+
+        return inSampleSize;
+    }
+
+    public static void closeSilently(Closeable c) {
+        if (c == null) return;
+        try {
+            c.close();
+        } catch (IOException t) {
+            Log.w(TAG, "close fail ", t);
+        }
+    }
+}