gt:                 jpeg = new File(thumbData);
context: package org.wordpress.android.util;
  
  import android.content.ContentResolver;
  import android.content.Context;
  import android.database.Cursor;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.graphics.Canvas;
  import android.graphics.Color;
  import android.graphics.Matrix;
  import android.graphics.Paint;
  import android.graphics.Point;
  import android.graphics.PorterDuff;
  import android.graphics.PorterDuffXfermode;
  import android.graphics.Rect;
  import android.graphics.RectF;
  import android.media.ExifInterface;
  import android.net.Uri;
  import android.os.AsyncTask;
  import android.provider.MediaStore;
  import android.text.TextUtils;
  import android.util.Log;
  import android.widget.ImageView;
  
  import org.apache.http.HttpEntity;
  import org.apache.http.HttpResponse;
  import org.apache.http.HttpStatus;
  import org.apache.http.client.methods.HttpGet;
  import org.apache.http.impl.client.DefaultHttpClient;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.ref.WeakReference;
  
  public class ImageUtils {
      public static int[] getImageSize(Uri uri, Context context){
          String path = null;
          BitmapFactory.Options options = new BitmapFactory.Options();
          options.inJustDecodeBounds = true;
  
          if (uri.toString().contains("content:")) {
              String[] projection = new String[] { MediaStore.Images.Media._ID, MediaStore.Images.Media.DATA };
              Cursor cur = null;
              try {
                  cur = context.getContentResolver().query(uri, projection, null, null, null);
                  if (cur != null && cur.moveToFirst()) {
                      int dataColumn = cur.getColumnIndex(MediaStore.Images.Media.DATA);
                      path = cur.getString(dataColumn);
                  }
              } catch (IllegalStateException stateException) {
                  Log.d(ImageUtils.class.getName(), "IllegalStateException querying content:" + uri);
              } finally {
                  SqlUtils.closeCursor(cur);
              }
          }
  
          if (TextUtils.isEmpty(path)) {
              //The file isn't ContentResolver, or it can't be access by ContentResolver. Try to access the file directly.
              path = uri.toString().replace("content://media", "");
              path = path.replace("file://", "");
          }
  
          BitmapFactory.decodeFile(path, options);
          int imageHeight = options.outHeight;
          int imageWidth = options.outWidth;
          return new int[]{imageWidth, imageHeight};
      }
  
      // Read the orientation from ContentResolver. If it fails, read from EXIF.
      public static int getImageOrientation(Context ctx, String filePath) {
          Uri curStream;
          int orientation = 0;
  
          // Remove file protocol
          filePath = filePath.replace("file://", "");
  
          if (!filePath.contains("content://"))
              curStream = Uri.parse("content://media" + filePath);
          else
              curStream = Uri.parse(filePath);
  
          try {
              Cursor cur = ctx.getContentResolver().query(curStream, new String[]{MediaStore.Images.Media.ORIENTATION}, null, null, null);
              if (cur != null) {
                  if (cur.moveToFirst()) {
                      orientation = cur.getInt(cur.getColumnIndex(MediaStore.Images.Media.ORIENTATION));
                  }
                  cur.close();
              }
          } catch (Exception errReadingContentResolver) {
              AppLog.e(AppLog.T.UTILS, errReadingContentResolver);
          }
  
          if (orientation == 0) {
              orientation = getExifOrientation(filePath);
          }
  
          return orientation;
      }
  
  
      public static int getExifOrientation(String path) {
          ExifInterface exif;
          try {
              exif = new ExifInterface(path);
          } catch (IOException e) {
              AppLog.e(AppLog.T.UTILS, e);
              return 0;
          }
  
          int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
  
          switch (exifOrientation) {
              case ExifInterface.ORIENTATION_NORMAL:
                  return 0;
              case ExifInterface.ORIENTATION_ROTATE_90:
                  return 90;
              case ExifInterface.ORIENTATION_ROTATE_180:
                  return 180;
              case ExifInterface.ORIENTATION_ROTATE_270:
                  return 270;
              default:
                  return 0;
          }
      }
  
      public static Bitmap downloadBitmap(String url) {
          final DefaultHttpClient client = new DefaultHttpClient();
  
          final HttpGet getRequest = new HttpGet(url);
  
          try {
              HttpResponse response = client.execute(getRequest);
              final int statusCode = response.getStatusLine().getStatusCode();
              if (statusCode != HttpStatus.SC_OK) {
                  AppLog.w(AppLog.T.UTILS, "ImageDownloader Error " + statusCode
                          + " while retrieving bitmap from " + url);
                  return null;
              }
  
              final HttpEntity entity = response.getEntity();
              if (entity != null) {
                  InputStream inputStream = null;
                  try {
                      inputStream = entity.getContent();
                      return BitmapFactory.decodeStream(inputStream);
                  } finally {
                      if (inputStream != null) {
                          inputStream.close();
                      }
                      entity.consumeContent();
                  }
              }
          } catch (Exception e) {
              // Could provide a more explicit error message for IOException or
              // IllegalStateException
              getRequest.abort();
              AppLog.w(AppLog.T.UTILS, "ImageDownloader Error while retrieving bitmap from " + url);
          }
          return null;
      }
  
      /** From http://developer.android.com/training/displaying-bitmaps/load-bitmap.html **/
      public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
          // Raw height and width of image
          final int height = options.outHeight;
          final int width = options.outWidth;
          int inSampleSize = 1;
  
          if (height > reqHeight || width > reqWidth) {
              // Calculate ratios of height and width to requested height and width
              final int heightRatio = Math.round((float) height / (float) reqHeight);
              final int widthRatio = Math.round((float) width / (float) reqWidth);
  
              // Choose the smallest ratio as inSampleSize value, this will guarantee
              // a final image with both dimensions larger than or equal to the
              // requested height and width.
              inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
          }
  
          return inSampleSize;
      }
  
  
      public interface BitmapWorkerCallback {
          public void onBitmapReady(String filePath, ImageView imageView, Bitmap bitmap);
      }
  
      public static class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {
          private final WeakReference<ImageView> imageViewReference;
          private final BitmapWorkerCallback callback;
          private int targetWidth;
          private int targetHeight;
          private String path;
  
          public BitmapWorkerTask(ImageView imageView, int width, int height, BitmapWorkerCallback callback) {
              // Use a WeakReference to ensure the ImageView can be garbage collected
              imageViewReference = new WeakReference<ImageView>(imageView);
              this.callback = callback;
              targetWidth = width;
              targetHeight = height;
          }
  
          // Decode image in background.
          @Override
          protected Bitmap doInBackground(String... params) {
              path = params[0];
  
              BitmapFactory.Options bfo = new BitmapFactory.Options();
              bfo.inJustDecodeBounds = true;
              BitmapFactory.decodeFile(path, bfo);
  
              bfo.inSampleSize = calculateInSampleSize(bfo, targetWidth, targetHeight);
              bfo.inJustDecodeBounds = false;
  
              // get proper rotation
              int bitmapWidth = 0;
              int bitmapHeight = 0;
              try {
                  File f = new File(path);
                  ExifInterface exif = new ExifInterface(f.getPath());
                  int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
                  int angle = 0;
                  if (orientation == ExifInterface.ORIENTATION_NORMAL) { // no need to rotate
                      return BitmapFactory.decodeFile(path, bfo);
                  } else if (orientation == ExifInterface.ORIENTATION_ROTATE_90) {
                      angle = 90;
                  } else if (orientation == ExifInterface.ORIENTATION_ROTATE_180) {
                      angle = 180;
                  } else if (orientation == ExifInterface.ORIENTATION_ROTATE_270) {
                      angle = 270;
                  }
  
                  Matrix mat = new Matrix();
                  mat.postRotate(angle);
  
                  try {
                      Bitmap bmp = BitmapFactory.decodeStream(new FileInputStream(f), null, bfo);
                      if (bmp == null) {
                          AppLog.e(AppLog.T.UTILS, "can't decode bitmap: " + f.getPath());
                          return null;
                      }
                      bitmapWidth = bmp.getWidth();
                      bitmapHeight = bmp.getHeight();
                      return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), mat, true);
                  } catch (OutOfMemoryError oom) {
                      AppLog.e(AppLog.T.UTILS, "OutOfMemoryError Error in setting image: " + oom);
                  }
              } catch (IOException e) {
                  AppLog.e(AppLog.T.UTILS, "Error in setting image", e);
              }
  
              return null;
          }
  
          // Once complete, see if ImageView is still around and set bitmap.
          @Override
          protected void onPostExecute(Bitmap bitmap) {
              if (imageViewReference == null || bitmap == null)
                  return;
  
              final ImageView imageView = imageViewReference.get();
  
              if (callback != null)
                  callback.onBitmapReady(path, imageView, bitmap);
  
          }
      }
  
  
      public static String getTitleForWPImageSpan(Context ctx, String filePath) {
          if (filePath == null)
              return null;
  
          Uri curStream;
          String title;
  
          if (!filePath.contains("content://"))
              curStream = Uri.parse("content://media" + filePath);
          else
              curStream = Uri.parse(filePath);
  
          if (filePath.contains("video")) {
              return "Video";
          } else {
              String[] projection = new String[] { MediaStore.Images.Thumbnails.DATA };
  
              Cursor cur;
              try {
                  cur = ctx.getContentResolver().query(curStream, projection, null, null, null);
              } catch (Exception e1) {
                  AppLog.e(AppLog.T.UTILS, e1);
                  return null;
              }
              File jpeg;
              if (cur != null) {
                  String thumbData = "";
                  if (cur.moveToFirst()) {
                      int dataColumn = cur.getColumnIndex(MediaStore.Images.Media.DATA);
                      thumbData = cur.getString(dataColumn);
                  }
                  cur.close();
                  if (thumbData == null) {
                      return null;
                  }
  