Make MMS more asynchronous and consistent with new SMS types.

1) We now delay MMS notifications until a payload is received,
   or there's an error downloading the payload.  This makes
   group messages more consistent.

2) All "text" parts of an MMS are combined into a second text
   record, which is stored in the MMS row directly rather than
   as a distinct part.  This allows for immediate text loading,
   which means there's no chance a ConversationItem will resize.

   To do this, we need to include MMS in the big DB migration
   that's already staged for this application update.  It's also
   an "application-level" migration, because we need the MasterSecret
   to do it.

3) On conversation display, all image-based parts now have their
   thumbnails loaded asynchronously.  This allows for smooth-scrolling.
   The thumbnails are also scaled more accurately.

src/org/thoughtcrime/securesms/util/BitmapUtil.java

@@ -0,0 +1,84 @@
+package org.thoughtcrime.securesms.util;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class BitmapUtil {
+
+  private static final int MAX_COMPRESSION_QUALITY  = 95;
+  private static final int MIN_COMPRESSION_QUALITY  = 50;
+  private static final int MAX_COMPRESSION_ATTEMPTS = 4;
+
+  public static byte[] createScaledBytes(Context context, Uri uri, int maxWidth,
+                                         int maxHeight, int maxSize)
+      throws IOException
+  {
+    InputStream measure = context.getContentResolver().openInputStream(uri);
+    InputStream data    = context.getContentResolver().openInputStream(uri);
+    Bitmap bitmap       = createScaledBitmap(measure, data, maxWidth, maxHeight);
+    int quality         = MAX_COMPRESSION_QUALITY;
+    int attempts        = 0;
+
+    ByteArrayOutputStream baos;
+
+    do {
+      baos = new ByteArrayOutputStream();
+      bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
+
+      quality = Math.max((quality * maxSize) / baos.size(), MIN_COMPRESSION_QUALITY);
+    } while (baos.size() > maxSize && attempts++ < MAX_COMPRESSION_ATTEMPTS);
+
+    bitmap.recycle();
+
+    if (baos.size() <= maxSize) return baos.toByteArray();
+    else                        throw new IOException("Unable to scale image below: " + baos.size());
+  }
+
+  public static Bitmap createScaledBitmap(InputStream measure, InputStream data,
+                                          int maxWidth, int maxHeight)
+  {
+    BitmapFactory.Options options = getImageDimensions(measure);
+    int imageWidth                = options.outWidth;
+    int imageHeight               = options.outHeight;
+
+    int scaler = 1;
+
+    while ((imageWidth / scaler > maxWidth) && (imageHeight / scaler > maxHeight))
+      scaler *= 2;
+
+    if (scaler > 1)
+      scaler /= 2;
+
+    options.inSampleSize       = scaler;
+    options.inJustDecodeBounds = false;
+
+    Bitmap roughThumbnail  = BitmapFactory.decodeStream(data, null, options);
+
+    if (imageWidth > maxWidth || imageHeight > maxHeight) {
+      Log.w("BitmapUtil", "Scaling to max width and height: " + maxWidth + "," + maxHeight);
+      Bitmap scaledThumbnail = Bitmap.createScaledBitmap(roughThumbnail, maxWidth, maxHeight, true);
+      roughThumbnail.recycle();
+      return scaledThumbnail;
+    } else {
+      return roughThumbnail;
+    }
+  }
+
+  private static BitmapFactory.Options getImageDimensions(InputStream inputStream) {
+    BitmapFactory.Options options = new BitmapFactory.Options();
+    options.inJustDecodeBounds    = true;
+    BitmapFactory.decodeStream(inputStream, null, options);
+
+    return options;
+  }
+
+
+}