src/com/android/launcher3/WallpaperCropActivity.java - fp2-dev/platform/packages/apps/Launcher3 - Gitiles

 /*
  * Copyright (C) 2013 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 com.android.launcher3;

 import android.app.ActionBar;
 import android.app.Activity;
 import android.app.WallpaperManager;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Bitmap.CompressFormat;
 import android.graphics.BitmapFactory;
 import android.graphics.BitmapRegionDecoder;
 import android.graphics.Canvas;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.Display;
 import android.view.View;
 import android.view.WindowManager;

 import com.android.gallery3d.common.Utils;
 import com.android.photos.BitmapRegionTileSource;

 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;

 public class WallpaperCropActivity extends Activity {
     private static final String LOGTAG = "Launcher3.CropActivity";

     protected static final String WALLPAPER_WIDTH_KEY = "wallpaper.width";
     protected static final String WALLPAPER_HEIGHT_KEY = "wallpaper.height";
     private static final int DEFAULT_COMPRESS_QUALITY = 90;
     /**
      * The maximum bitmap size we allow to be returned through the intent.
      * Intents have a maximum of 1MB in total size. However, the Bitmap seems to
      * have some overhead to hit so that we go way below the limit here to make
      * sure the intent stays below 1MB.We should consider just returning a byte
      * array instead of a Bitmap instance to avoid overhead.
      */
     public static final int MAX_BMAP_IN_INTENT = 750000;
     private static final float WALLPAPER_SCREENS_SPAN = 2f;

     protected CropView mCropView;
     protected Uri mUri;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         init();
     }

     protected void init() {
         setContentView(R.layout.wallpaper_cropper);

         mCropView = (CropView) findViewById(R.id.cropView);

         Intent cropIntent = this.getIntent();
         final Uri imageUri = cropIntent.getData();

         mCropView.setTileSource(new BitmapRegionTileSource(this, imageUri, 1024, 0), null);
         mCropView.setTouchEnabled(true);
         // Action bar
         // Show the custom action bar view
         final ActionBar actionBar = getActionBar();
         actionBar.setCustomView(R.layout.actionbar_set_wallpaper);
         actionBar.getCustomView().setOnClickListener(
                 new View.OnClickListener() {
                     @Override
                     public void onClick(View v) {
                         boolean finishActivityWhenDone = true;
                         cropImageAndSetWallpaper(imageUri, finishActivityWhenDone);
                     }
                 });
     }

     // As a ratio of screen height, the total distance we want the parallax effect to span
     // horizontally
     private static float wallpaperTravelToScreenWidthRatio(int width, int height) {
         float aspectRatio = width / (float) height;

         // At an aspect ratio of 16/10, the wallpaper parallax effect should span 1.5 * screen width
         // At an aspect ratio of 10/16, the wallpaper parallax effect should span 1.2 * screen width
         // We will use these two data points to extrapolate how much the wallpaper parallax effect
         // to span (ie travel) at any aspect ratio:

         final float ASPECT_RATIO_LANDSCAPE = 16/10f;
         final float ASPECT_RATIO_PORTRAIT = 10/16f;
         final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE = 1.5f;
         final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT = 1.2f;

         // To find out the desired width at different aspect ratios, we use the following two
         // formulas, where the coefficient on x is the aspect ratio (width/height):
         //   (16/10)x + y = 1.5
         //   (10/16)x + y = 1.2
         // We solve for x and y and end up with a final formula:
         final float x =
             (WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE - WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT) /
             (ASPECT_RATIO_LANDSCAPE - ASPECT_RATIO_PORTRAIT);
         final float y = WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT - x * ASPECT_RATIO_PORTRAIT;
         return x * aspectRatio + y;
     }

     static protected Point getDefaultWallpaperSize(Resources res, WindowManager windowManager) {
         Point minDims = new Point();
         Point maxDims = new Point();
         windowManager.getDefaultDisplay().getCurrentSizeRange(minDims, maxDims);

         int maxDim = Math.max(maxDims.x, maxDims.y);
         final int minDim = Math.min(minDims.x, minDims.y);

         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
             Point realSize = new Point();
             windowManager.getDefaultDisplay().getRealSize(realSize);
             maxDim = Math.max(realSize.x, realSize.y);
         }

         // We need to ensure that there is enough extra space in the wallpaper
         // for the intended
         // parallax effects
         final int defaultWidth, defaultHeight;
         if (LauncherAppState.isScreenLarge(res)) {
             defaultWidth = (int) (maxDim * wallpaperTravelToScreenWidthRatio(maxDim, minDim));
             defaultHeight = maxDim;
         } else {
             defaultWidth = Math.max((int) (minDim * WALLPAPER_SCREENS_SPAN), maxDim);
             defaultHeight = maxDim;
         }
         return new Point(defaultWidth, defaultHeight);
     }

     protected void cropImageAndSetWallpaper(Resources res,
             int resId, final boolean finishActivityWhenDone) {
         // crop this image and scale it down to the default wallpaper size for
         // this device
         Point inSize = mCropView.getSourceDimensions();
         Point outSize = getDefaultWallpaperSize(getResources(),
                 getWindowManager());
         RectF crop = getMaxCropRect(
                 inSize.x, inSize.y, outSize.x, outSize.y);
         Runnable onEndCrop = new Runnable() {
             public void run() {
                 // Passing 0, 0 will cause launcher to revert to using the
                 // default wallpaper size
                 updateWallpaperDimensions(0, 0);
                 if (finishActivityWhenDone) {
                     setResult(Activity.RESULT_OK);
                     finish();
                 }
             }
         };
         BitmapCropTask cropTask = new BitmapCropTask(res, resId,
                 crop, outSize.x, outSize.y,
                 true, false, onEndCrop);
         cropTask.execute();
     }

     protected void cropImageAndSetWallpaper(Uri uri, final boolean finishActivityWhenDone) {
      // Get the crop
         Point inSize = mCropView.getSourceDimensions();

         Point minDims = new Point();
         Point maxDims = new Point();
         Display d = getWindowManager().getDefaultDisplay();
         d.getCurrentSizeRange(minDims, maxDims);

         Point displaySize = new Point();
         d.getSize(displaySize);

         int maxDim = Math.max(maxDims.x, maxDims.y);
         final int minDim = Math.min(minDims.x, minDims.y);
         int defaultWidth;
         if (LauncherAppState.isScreenLarge(getResources())) {
             defaultWidth = (int) (maxDim *
                     wallpaperTravelToScreenWidthRatio(maxDim, minDim));
         } else {
             defaultWidth = Math.max((int)
                     (minDim * WALLPAPER_SCREENS_SPAN), maxDim);
         }

         boolean isPortrait = displaySize.x < displaySize.y;
         int portraitHeight;
         if (isPortrait) {
             portraitHeight = mCropView.getHeight();
         } else {
             // TODO: how to actually get the proper portrait height?
             // This is not quite right:
             portraitHeight = Math.max(maxDims.x, maxDims.y);
         }
         if (android.os.Build.VERSION.SDK_INT >=
                 android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
             Point realSize = new Point();
             d.getRealSize(realSize);
             portraitHeight = Math.max(realSize.x, realSize.y);
         }
         // Get the crop
         RectF cropRect = mCropView.getCrop();
         float cropScale = mCropView.getWidth() / (float) cropRect.width();

         // ADJUST CROP WIDTH
         // Extend the crop all the way to the right, for parallax
         float extraSpaceToRight = inSize.x - cropRect.right;
         // Cap the amount of extra width
         float maxExtraSpace = defaultWidth / cropScale - cropRect.width();
         extraSpaceToRight = Math.min(extraSpaceToRight, maxExtraSpace);

         cropRect.right += extraSpaceToRight;

         // ADJUST CROP HEIGHT
         if (isPortrait) {
             cropRect.bottom = cropRect.top + portraitHeight / cropScale;
         } else { // LANDSCAPE
             float extraPortraitHeight =
                     portraitHeight / cropScale - cropRect.height();
             float expandHeight =
                     Math.min(Math.min(inSize.y - cropRect.bottom, cropRect.top),
                             extraPortraitHeight / 2);
             cropRect.top -= expandHeight;
             cropRect.bottom += expandHeight;
         }
         final int outWidth = (int) Math.round(cropRect.width() * cropScale);
         final int outHeight = (int) Math.round(cropRect.height() * cropScale);

         Runnable onEndCrop = new Runnable() {
             public void run() {
                 updateWallpaperDimensions(outWidth, outHeight);
                 if (finishActivityWhenDone) {
                     setResult(Activity.RESULT_OK);
                     finish();
                 }
             }
         };
         BitmapCropTask cropTask = new BitmapCropTask(uri,
                 cropRect, outWidth, outHeight, true, false, onEndCrop);
         cropTask.execute();
     }

     protected class BitmapCropTask extends AsyncTask<Void, Void, Boolean> {
         Uri mInUri = null;
         int mInResId = 0;
         InputStream mInStream;
         RectF mCropBounds = null;
         int mOutWidth, mOutHeight;
         int mRotation = 0; // for now
         protected final WallpaperManager mWPManager;
         String mOutputFormat = "jpg"; // for now
         boolean mSetWallpaper;
         boolean mSaveCroppedBitmap;
         Bitmap mCroppedBitmap;
         Runnable mOnEndRunnable;
         Resources mResources;

         public BitmapCropTask(Uri inUri,
                 RectF cropBounds, int outWidth, int outHeight,
                 boolean setWallpaper, boolean saveCroppedBitmap, Runnable onEndRunnable) {
             mInUri = inUri;
             mCropBounds = cropBounds;
             mOutWidth = outWidth;
             mOutHeight = outHeight;
             mWPManager = WallpaperManager.getInstance(getApplicationContext());
             mSetWallpaper = setWallpaper;
             mSaveCroppedBitmap = saveCroppedBitmap;
             mOnEndRunnable = onEndRunnable;
         }

         public BitmapCropTask(Resources res, int inResId,
                 RectF cropBounds, int outWidth, int outHeight,
                 boolean setWallpaper, boolean saveCroppedBitmap, Runnable onEndRunnable) {
             mInResId = inResId;
             mCropBounds = cropBounds;
             mOutWidth = outWidth;
             mOutHeight = outHeight;
             mWPManager = WallpaperManager.getInstance(getApplicationContext());
             mSetWallpaper = setWallpaper;
             mSaveCroppedBitmap = saveCroppedBitmap;
             mOnEndRunnable = onEndRunnable;
             mResources = res;
         }

         // Helper to setup input stream
         private void regenerateInputStream() {
             if (mInUri == null && mInResId == 0) {
                 Log.w(LOGTAG, "cannot read original file, no input URI or resource ID given");
             } else {
                 Utils.closeSilently(mInStream);
                 try {
                     if (mInUri != null) {
                         mInStream = new BufferedInputStream(
                                 getContentResolver().openInputStream(mInUri));
                     } else {
                         mInStream = new BufferedInputStream(
                                 mResources.openRawResource(mInResId));
                     }
                 } catch (FileNotFoundException e) {
                     Log.w(LOGTAG, "cannot read file: " + mInUri.toString(), e);
                 }
             }
         }

         public Point getImageBounds() {
             regenerateInputStream();
             if (mInStream != null) {
                 BitmapFactory.Options options = new BitmapFactory.Options();
                 options.inJustDecodeBounds = true;
                 BitmapFactory.decodeStream(mInStream, null, options);
                 if (options.outWidth != 0 && options.outHeight != 0) {
                     return new Point(options.outWidth, options.outHeight);
                 }
             }
             return null;
         }

         public void setCropBounds(RectF cropBounds) {
             mCropBounds = cropBounds;
         }

         public Bitmap getCroppedBitmap() {
             return mCroppedBitmap;
         }
         public boolean cropBitmap() {
             boolean failure = false;

             regenerateInputStream();

             if (mInStream != null) {
                 // Find crop bounds (scaled to original image size)
                 Rect roundedTrueCrop = new Rect();
                 mCropBounds.roundOut(roundedTrueCrop);

                 if (roundedTrueCrop.width() <= 0 || roundedTrueCrop.height() <= 0) {
                     Log.w(LOGTAG, "crop has bad values for full size image");
                     failure = true;
                     return false;
                 }

                 // See how much we're reducing the size of the image
                 int scaleDownSampleSize = Math.min(roundedTrueCrop.width() / mOutWidth,
                         roundedTrueCrop.height() / mOutHeight);

                 // Attempt to open a region decoder
                 BitmapRegionDecoder decoder = null;
                 try {
                     decoder = BitmapRegionDecoder.newInstance(mInStream, true);
                 } catch (IOException e) {
                     Log.w(LOGTAG, "cannot open region decoder for file: " + mInUri.toString(), e);
                 }

                 Bitmap crop = null;
                 if (decoder != null) {
                     // Do region decoding to get crop bitmap
                     BitmapFactory.Options options = new BitmapFactory.Options();
                     if (scaleDownSampleSize > 1) {
                         options.inSampleSize = scaleDownSampleSize;
                     }
                     crop = decoder.decodeRegion(roundedTrueCrop, options);
                     decoder.recycle();
                 }

                 if (crop == null) {
                     // BitmapRegionDecoder has failed, try to crop in-memory
                     regenerateInputStream();
                     Bitmap fullSize = null;
                     if (mInStream != null) {
                         BitmapFactory.Options options = new BitmapFactory.Options();
                         if (scaleDownSampleSize > 1) {
                             options.inSampleSize = scaleDownSampleSize;
                         }
                         fullSize = BitmapFactory.decodeStream(mInStream, null, options);
                     }
                     if (fullSize != null) {
                         crop = Bitmap.createBitmap(fullSize, roundedTrueCrop.left,
                                 roundedTrueCrop.top, roundedTrueCrop.width(),
                                 roundedTrueCrop.height());
                     }
                 }

                 if (crop == null) {
                     Log.w(LOGTAG, "cannot decode file: " + mInUri.toString());
                     failure = true;
                     return false;
                 }
                 if (mOutWidth > 0 && mOutHeight > 0) {
                     Matrix m = new Matrix();
                     RectF cropRect = new RectF(0, 0, crop.getWidth(), crop.getHeight());
                     if (mRotation > 0) {
                         m.setRotate(mRotation);
                         m.mapRect(cropRect);
                     }
                     RectF returnRect = new RectF(0, 0, mOutWidth, mOutHeight);
                     m.setRectToRect(cropRect, returnRect, Matrix.ScaleToFit.FILL);
                     m.preRotate(mRotation);
                     Bitmap tmp = Bitmap.createBitmap((int) returnRect.width(),
                             (int) returnRect.height(), Bitmap.Config.ARGB_8888);
                     if (tmp != null) {
                         Canvas c = new Canvas(tmp);
                         c.drawBitmap(crop, m, new Paint());
                         crop = tmp;
                     }
                 } else if (mRotation > 0) {
                     Matrix m = new Matrix();
                     m.setRotate(mRotation);
                     Bitmap tmp = Bitmap.createBitmap(crop, 0, 0, crop.getWidth(),
                             crop.getHeight(), m, true);
                     if (tmp != null) {
                         crop = tmp;
                     }
                 }

                 if (mSaveCroppedBitmap) {
                     mCroppedBitmap = crop;
                 }

                 // Get output compression format
                 CompressFormat cf =
                         convertExtensionToCompressFormat(getFileExtension(mOutputFormat));

                 // Compress to byte array
                 ByteArrayOutputStream tmpOut = new ByteArrayOutputStream(2048);
                 if (crop.compress(cf, DEFAULT_COMPRESS_QUALITY, tmpOut)) {
                     // If we need to set to the wallpaper, set it
                     if (mSetWallpaper && mWPManager != null) {
                         if (mWPManager == null) {
                             Log.w(LOGTAG, "no wallpaper manager");
                             failure = true;
                         } else {
                             try {
                                 mWPManager.setStream(new ByteArrayInputStream(tmpOut
                                         .toByteArray()));
                             } catch (IOException e) {
                                 Log.w(LOGTAG, "cannot write stream to wallpaper", e);
                                 failure = true;
                             }
                         }
                     }
                     if (mOnEndRunnable != null) {
                         mOnEndRunnable.run();
                     }
                 } else {
                     Log.w(LOGTAG, "cannot compress bitmap");
                     failure = true;
                 }
             }
             return !failure; // True if any of the operations failed
         }

         @Override
         protected Boolean doInBackground(Void... params) {
             return cropBitmap();
         }

         @Override
         protected void onPostExecute(Boolean result) {
             setResult(Activity.RESULT_OK);
             finish();
         }
     }

     protected void updateWallpaperDimensions(int width, int height) {
         String spKey = LauncherAppState.getSharedPreferencesKey();
         SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = sp.edit();
         if (width != 0 && height != 0) {
             editor.putInt(WALLPAPER_WIDTH_KEY, width);
             editor.putInt(WALLPAPER_HEIGHT_KEY, height);
         } else {
             editor.remove(WALLPAPER_WIDTH_KEY);
             editor.remove(WALLPAPER_HEIGHT_KEY);
         }
         editor.commit();

         suggestWallpaperDimension(getResources(),
                 sp, getWindowManager(), WallpaperManager.getInstance(this));
     }

     static public void suggestWallpaperDimension(Resources res,
             final SharedPreferences sharedPrefs,
             WindowManager windowManager,
             final WallpaperManager wallpaperManager) {
         final Point defaultWallpaperSize =
                 WallpaperCropActivity.getDefaultWallpaperSize(res, windowManager);

         new Thread("suggestWallpaperDimension") {
             public void run() {
                 // If we have saved a wallpaper width/height, use that instead
                 int savedWidth = sharedPrefs.getInt(WALLPAPER_WIDTH_KEY, defaultWallpaperSize.x);
                 int savedHeight = sharedPrefs.getInt(WALLPAPER_HEIGHT_KEY, defaultWallpaperSize.y);
                 wallpaperManager.suggestDesiredDimensions(savedWidth, savedHeight);
             }
         }.start();
     }


     protected static RectF getMaxCropRect(int inWidth, int inHeight, int outWidth, int outHeight) {
         RectF cropRect = new RectF();
         // Get a crop rect that will fit this
         if (inWidth / (float) inHeight > outWidth / (float) outHeight) {
              cropRect.top = 0;
              cropRect.bottom = inHeight;
              cropRect.left = (inWidth - (outWidth / (float) outHeight) * inHeight) / 2;
              cropRect.right = inWidth - cropRect.left;
         } else {
             cropRect.left = 0;
             cropRect.right = inWidth;
             cropRect.top = (inHeight - (outHeight / (float) outWidth) * inWidth) / 2;
             cropRect.bottom = inHeight - cropRect.top;
         }
         return cropRect;
     }

     protected static CompressFormat convertExtensionToCompressFormat(String extension) {
         return extension.equals("png") ? CompressFormat.PNG : CompressFormat.JPEG;
     }

     protected static String getFileExtension(String requestFormat) {
         String outputFormat = (requestFormat == null)
                 ? "jpg"
                 : requestFormat;
         outputFormat = outputFormat.toLowerCase();
         return (outputFormat.equals("png") || outputFormat.equals("gif"))
                 ? "png" // We don't support gif compression.
                 : "jpg";
     }
 }
	/*
	* Copyright (C) 2013 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 com.android.launcher3;

	import android.app.ActionBar;
	import android.app.Activity;
	import android.app.WallpaperManager;
	import android.content.Context;
	import android.content.Intent;
	import android.content.SharedPreferences;
	import android.content.res.Resources;
	import android.graphics.Bitmap;
	import android.graphics.Bitmap.CompressFormat;
	import android.graphics.BitmapFactory;
	import android.graphics.BitmapRegionDecoder;
	import android.graphics.Canvas;
	import android.graphics.Matrix;
	import android.graphics.Paint;
	import android.graphics.Point;
	import android.graphics.Rect;
	import android.graphics.RectF;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.os.Bundle;
	import android.util.Log;
	import android.view.Display;
	import android.view.View;
	import android.view.WindowManager;

	import com.android.gallery3d.common.Utils;
	import com.android.photos.BitmapRegionTileSource;

	import java.io.BufferedInputStream;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;

	public class WallpaperCropActivity extends Activity {
	private static final String LOGTAG = "Launcher3.CropActivity";

	protected static final String WALLPAPER_WIDTH_KEY = "wallpaper.width";
	protected static final String WALLPAPER_HEIGHT_KEY = "wallpaper.height";
	private static final int DEFAULT_COMPRESS_QUALITY = 90;
	/**
	* The maximum bitmap size we allow to be returned through the intent.
	* Intents have a maximum of 1MB in total size. However, the Bitmap seems to
	* have some overhead to hit so that we go way below the limit here to make
	* sure the intent stays below 1MB.We should consider just returning a byte
	* array instead of a Bitmap instance to avoid overhead.
	*/
	public static final int MAX_BMAP_IN_INTENT = 750000;
	private static final float WALLPAPER_SCREENS_SPAN = 2f;

	protected CropView mCropView;
	protected Uri mUri;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	init();
	}

	protected void init() {
	setContentView(R.layout.wallpaper_cropper);

	mCropView = (CropView) findViewById(R.id.cropView);

	Intent cropIntent = this.getIntent();
	final Uri imageUri = cropIntent.getData();

	mCropView.setTileSource(new BitmapRegionTileSource(this, imageUri, 1024, 0), null);
	mCropView.setTouchEnabled(true);
	// Action bar
	// Show the custom action bar view
	final ActionBar actionBar = getActionBar();
	actionBar.setCustomView(R.layout.actionbar_set_wallpaper);
	actionBar.getCustomView().setOnClickListener(
	new View.OnClickListener() {
	@Override
	public void onClick(View v) {
	boolean finishActivityWhenDone = true;
	cropImageAndSetWallpaper(imageUri, finishActivityWhenDone);
	}
	});
	}

	// As a ratio of screen height, the total distance we want the parallax effect to span
	// horizontally
	private static float wallpaperTravelToScreenWidthRatio(int width, int height) {
	float aspectRatio = width / (float) height;

	// At an aspect ratio of 16/10, the wallpaper parallax effect should span 1.5 * screen width
	// At an aspect ratio of 10/16, the wallpaper parallax effect should span 1.2 * screen width
	// We will use these two data points to extrapolate how much the wallpaper parallax effect
	// to span (ie travel) at any aspect ratio:

	final float ASPECT_RATIO_LANDSCAPE = 16/10f;
	final float ASPECT_RATIO_PORTRAIT = 10/16f;
	final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE = 1.5f;
	final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT = 1.2f;

	// To find out the desired width at different aspect ratios, we use the following two
	// formulas, where the coefficient on x is the aspect ratio (width/height):
	// (16/10)x + y = 1.5
	// (10/16)x + y = 1.2
	// We solve for x and y and end up with a final formula:
	final float x =
	(WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE - WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT) /
	(ASPECT_RATIO_LANDSCAPE - ASPECT_RATIO_PORTRAIT);
	final float y = WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT - x * ASPECT_RATIO_PORTRAIT;
	return x * aspectRatio + y;
	}

	static protected Point getDefaultWallpaperSize(Resources res, WindowManager windowManager) {
	Point minDims = new Point();
	Point maxDims = new Point();
	windowManager.getDefaultDisplay().getCurrentSizeRange(minDims, maxDims);

	int maxDim = Math.max(maxDims.x, maxDims.y);
	final int minDim = Math.min(minDims.x, minDims.y);

	if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
	Point realSize = new Point();
	windowManager.getDefaultDisplay().getRealSize(realSize);
	maxDim = Math.max(realSize.x, realSize.y);
	}

	// We need to ensure that there is enough extra space in the wallpaper
	// for the intended
	// parallax effects
	final int defaultWidth, defaultHeight;
	if (LauncherAppState.isScreenLarge(res)) {
	defaultWidth = (int) (maxDim * wallpaperTravelToScreenWidthRatio(maxDim, minDim));
	defaultHeight = maxDim;
	} else {
	defaultWidth = Math.max((int) (minDim * WALLPAPER_SCREENS_SPAN), maxDim);
	defaultHeight = maxDim;
	}
	return new Point(defaultWidth, defaultHeight);
	}

	protected void cropImageAndSetWallpaper(Resources res,
	int resId, final boolean finishActivityWhenDone) {
	// crop this image and scale it down to the default wallpaper size for
	// this device
	Point inSize = mCropView.getSourceDimensions();
	Point outSize = getDefaultWallpaperSize(getResources(),
	getWindowManager());
	RectF crop = getMaxCropRect(
	inSize.x, inSize.y, outSize.x, outSize.y);
	Runnable onEndCrop = new Runnable() {
	public void run() {
	// Passing 0, 0 will cause launcher to revert to using the
	// default wallpaper size
	updateWallpaperDimensions(0, 0);
	if (finishActivityWhenDone) {
	setResult(Activity.RESULT_OK);
	finish();
	}
	}
	};
	BitmapCropTask cropTask = new BitmapCropTask(res, resId,
	crop, outSize.x, outSize.y,
	true, false, onEndCrop);
	cropTask.execute();
	}

	protected void cropImageAndSetWallpaper(Uri uri, final boolean finishActivityWhenDone) {
	// Get the crop
	Point inSize = mCropView.getSourceDimensions();

	Point minDims = new Point();
	Point maxDims = new Point();
	Display d = getWindowManager().getDefaultDisplay();
	d.getCurrentSizeRange(minDims, maxDims);

	Point displaySize = new Point();
	d.getSize(displaySize);

	int maxDim = Math.max(maxDims.x, maxDims.y);
	final int minDim = Math.min(minDims.x, minDims.y);
	int defaultWidth;
	if (LauncherAppState.isScreenLarge(getResources())) {
	defaultWidth = (int) (maxDim *
	wallpaperTravelToScreenWidthRatio(maxDim, minDim));
	} else {
	defaultWidth = Math.max((int)
	(minDim * WALLPAPER_SCREENS_SPAN), maxDim);
	}

	boolean isPortrait = displaySize.x < displaySize.y;
	int portraitHeight;
	if (isPortrait) {
	portraitHeight = mCropView.getHeight();
	} else {
	// TODO: how to actually get the proper portrait height?
	// This is not quite right:
	portraitHeight = Math.max(maxDims.x, maxDims.y);
	}
	if (android.os.Build.VERSION.SDK_INT >=
	android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
	Point realSize = new Point();
	d.getRealSize(realSize);
	portraitHeight = Math.max(realSize.x, realSize.y);
	}
	// Get the crop
	RectF cropRect = mCropView.getCrop();
	float cropScale = mCropView.getWidth() / (float) cropRect.width();

	// ADJUST CROP WIDTH
	// Extend the crop all the way to the right, for parallax
	float extraSpaceToRight = inSize.x - cropRect.right;
	// Cap the amount of extra width
	float maxExtraSpace = defaultWidth / cropScale - cropRect.width();
	extraSpaceToRight = Math.min(extraSpaceToRight, maxExtraSpace);

	cropRect.right += extraSpaceToRight;

	// ADJUST CROP HEIGHT
	if (isPortrait) {
	cropRect.bottom = cropRect.top + portraitHeight / cropScale;
	} else { // LANDSCAPE
	float extraPortraitHeight =
	portraitHeight / cropScale - cropRect.height();
	float expandHeight =
	Math.min(Math.min(inSize.y - cropRect.bottom, cropRect.top),
	extraPortraitHeight / 2);
	cropRect.top -= expandHeight;
	cropRect.bottom += expandHeight;
	}
	final int outWidth = (int) Math.round(cropRect.width() * cropScale);
	final int outHeight = (int) Math.round(cropRect.height() * cropScale);

	Runnable onEndCrop = new Runnable() {
	public void run() {
	updateWallpaperDimensions(outWidth, outHeight);
	if (finishActivityWhenDone) {
	setResult(Activity.RESULT_OK);
	finish();
	}
	}
	};
	BitmapCropTask cropTask = new BitmapCropTask(uri,
	cropRect, outWidth, outHeight, true, false, onEndCrop);
	cropTask.execute();
	}

	protected class BitmapCropTask extends AsyncTask<Void, Void, Boolean> {
	Uri mInUri = null;
	int mInResId = 0;
	InputStream mInStream;
	RectF mCropBounds = null;
	int mOutWidth, mOutHeight;
	int mRotation = 0; // for now
	protected final WallpaperManager mWPManager;
	String mOutputFormat = "jpg"; // for now
	boolean mSetWallpaper;
	boolean mSaveCroppedBitmap;
	Bitmap mCroppedBitmap;
	Runnable mOnEndRunnable;
	Resources mResources;

	public BitmapCropTask(Uri inUri,
	RectF cropBounds, int outWidth, int outHeight,
	boolean setWallpaper, boolean saveCroppedBitmap, Runnable onEndRunnable) {
	mInUri = inUri;
	mCropBounds = cropBounds;
	mOutWidth = outWidth;
	mOutHeight = outHeight;
	mWPManager = WallpaperManager.getInstance(getApplicationContext());
	mSetWallpaper = setWallpaper;
	mSaveCroppedBitmap = saveCroppedBitmap;
	mOnEndRunnable = onEndRunnable;
	}

	public BitmapCropTask(Resources res, int inResId,
	RectF cropBounds, int outWidth, int outHeight,
	boolean setWallpaper, boolean saveCroppedBitmap, Runnable onEndRunnable) {
	mInResId = inResId;
	mCropBounds = cropBounds;
	mOutWidth = outWidth;
	mOutHeight = outHeight;
	mWPManager = WallpaperManager.getInstance(getApplicationContext());
	mSetWallpaper = setWallpaper;
	mSaveCroppedBitmap = saveCroppedBitmap;
	mOnEndRunnable = onEndRunnable;
	mResources = res;
	}

	// Helper to setup input stream
	private void regenerateInputStream() {
	if (mInUri == null && mInResId == 0) {
	Log.w(LOGTAG, "cannot read original file, no input URI or resource ID given");
	} else {
	Utils.closeSilently(mInStream);
	try {
	if (mInUri != null) {
	mInStream = new BufferedInputStream(
	getContentResolver().openInputStream(mInUri));
	} else {
	mInStream = new BufferedInputStream(
	mResources.openRawResource(mInResId));
	}
	} catch (FileNotFoundException e) {
	Log.w(LOGTAG, "cannot read file: " + mInUri.toString(), e);
	}
	}
	}

	public Point getImageBounds() {
	regenerateInputStream();
	if (mInStream != null) {
	BitmapFactory.Options options = new BitmapFactory.Options();
	options.inJustDecodeBounds = true;
	BitmapFactory.decodeStream(mInStream, null, options);
	if (options.outWidth != 0 && options.outHeight != 0) {
	return new Point(options.outWidth, options.outHeight);
	}
	}
	return null;
	}

	public void setCropBounds(RectF cropBounds) {
	mCropBounds = cropBounds;
	}

	public Bitmap getCroppedBitmap() {
	return mCroppedBitmap;
	}
	public boolean cropBitmap() {
	boolean failure = false;

	regenerateInputStream();

	if (mInStream != null) {
	// Find crop bounds (scaled to original image size)
	Rect roundedTrueCrop = new Rect();
	mCropBounds.roundOut(roundedTrueCrop);

	if (roundedTrueCrop.width() <= 0 \|\| roundedTrueCrop.height() <= 0) {
	Log.w(LOGTAG, "crop has bad values for full size image");
	failure = true;
	return false;
	}

	// See how much we're reducing the size of the image
	int scaleDownSampleSize = Math.min(roundedTrueCrop.width() / mOutWidth,
	roundedTrueCrop.height() / mOutHeight);

	// Attempt to open a region decoder
	BitmapRegionDecoder decoder = null;
	try {
	decoder = BitmapRegionDecoder.newInstance(mInStream, true);
	} catch (IOException e) {
	Log.w(LOGTAG, "cannot open region decoder for file: " + mInUri.toString(), e);
	}

	Bitmap crop = null;
	if (decoder != null) {
	// Do region decoding to get crop bitmap
	BitmapFactory.Options options = new BitmapFactory.Options();
	if (scaleDownSampleSize > 1) {
	options.inSampleSize = scaleDownSampleSize;
	}
	crop = decoder.decodeRegion(roundedTrueCrop, options);
	decoder.recycle();
	}

	if (crop == null) {
	// BitmapRegionDecoder has failed, try to crop in-memory
	regenerateInputStream();
	Bitmap fullSize = null;
	if (mInStream != null) {
	BitmapFactory.Options options = new BitmapFactory.Options();
	if (scaleDownSampleSize > 1) {
	options.inSampleSize = scaleDownSampleSize;
	}
	fullSize = BitmapFactory.decodeStream(mInStream, null, options);
	}
	if (fullSize != null) {
	crop = Bitmap.createBitmap(fullSize, roundedTrueCrop.left,
	roundedTrueCrop.top, roundedTrueCrop.width(),
	roundedTrueCrop.height());
	}
	}

	if (crop == null) {
	Log.w(LOGTAG, "cannot decode file: " + mInUri.toString());
	failure = true;
	return false;
	}
	if (mOutWidth > 0 && mOutHeight > 0) {
	Matrix m = new Matrix();
	RectF cropRect = new RectF(0, 0, crop.getWidth(), crop.getHeight());
	if (mRotation > 0) {
	m.setRotate(mRotation);
	m.mapRect(cropRect);
	}
	RectF returnRect = new RectF(0, 0, mOutWidth, mOutHeight);
	m.setRectToRect(cropRect, returnRect, Matrix.ScaleToFit.FILL);
	m.preRotate(mRotation);
	Bitmap tmp = Bitmap.createBitmap((int) returnRect.width(),
	(int) returnRect.height(), Bitmap.Config.ARGB_8888);
	if (tmp != null) {
	Canvas c = new Canvas(tmp);
	c.drawBitmap(crop, m, new Paint());
	crop = tmp;
	}
	} else if (mRotation > 0) {
	Matrix m = new Matrix();
	m.setRotate(mRotation);
	Bitmap tmp = Bitmap.createBitmap(crop, 0, 0, crop.getWidth(),
	crop.getHeight(), m, true);
	if (tmp != null) {
	crop = tmp;
	}
	}

	if (mSaveCroppedBitmap) {
	mCroppedBitmap = crop;
	}

	// Get output compression format
	CompressFormat cf =
	convertExtensionToCompressFormat(getFileExtension(mOutputFormat));

	// Compress to byte array
	ByteArrayOutputStream tmpOut = new ByteArrayOutputStream(2048);
	if (crop.compress(cf, DEFAULT_COMPRESS_QUALITY, tmpOut)) {
	// If we need to set to the wallpaper, set it
	if (mSetWallpaper && mWPManager != null) {
	if (mWPManager == null) {
	Log.w(LOGTAG, "no wallpaper manager");
	failure = true;
	} else {
	try {
	mWPManager.setStream(new ByteArrayInputStream(tmpOut
	.toByteArray()));
	} catch (IOException e) {
	Log.w(LOGTAG, "cannot write stream to wallpaper", e);
	failure = true;
	}
	}
	}
	if (mOnEndRunnable != null) {
	mOnEndRunnable.run();
	}
	} else {
	Log.w(LOGTAG, "cannot compress bitmap");
	failure = true;
	}
	}
	return !failure; // True if any of the operations failed
	}

	@Override
	protected Boolean doInBackground(Void... params) {
	return cropBitmap();
	}

	@Override
	protected void onPostExecute(Boolean result) {
	setResult(Activity.RESULT_OK);
	finish();
	}
	}

	protected void updateWallpaperDimensions(int width, int height) {
	String spKey = LauncherAppState.getSharedPreferencesKey();
	SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
	SharedPreferences.Editor editor = sp.edit();
	if (width != 0 && height != 0) {
	editor.putInt(WALLPAPER_WIDTH_KEY, width);
	editor.putInt(WALLPAPER_HEIGHT_KEY, height);
	} else {
	editor.remove(WALLPAPER_WIDTH_KEY);
	editor.remove(WALLPAPER_HEIGHT_KEY);
	}
	editor.commit();

	suggestWallpaperDimension(getResources(),
	sp, getWindowManager(), WallpaperManager.getInstance(this));
	}

	static public void suggestWallpaperDimension(Resources res,
	final SharedPreferences sharedPrefs,
	WindowManager windowManager,
	final WallpaperManager wallpaperManager) {
	final Point defaultWallpaperSize =
	WallpaperCropActivity.getDefaultWallpaperSize(res, windowManager);

	new Thread("suggestWallpaperDimension") {
	public void run() {
	// If we have saved a wallpaper width/height, use that instead
	int savedWidth = sharedPrefs.getInt(WALLPAPER_WIDTH_KEY, defaultWallpaperSize.x);
	int savedHeight = sharedPrefs.getInt(WALLPAPER_HEIGHT_KEY, defaultWallpaperSize.y);
	wallpaperManager.suggestDesiredDimensions(savedWidth, savedHeight);
	}
	}.start();
	}


	protected static RectF getMaxCropRect(int inWidth, int inHeight, int outWidth, int outHeight) {
	RectF cropRect = new RectF();
	// Get a crop rect that will fit this
	if (inWidth / (float) inHeight > outWidth / (float) outHeight) {
	cropRect.top = 0;
	cropRect.bottom = inHeight;
	cropRect.left = (inWidth - (outWidth / (float) outHeight) * inHeight) / 2;
	cropRect.right = inWidth - cropRect.left;
	} else {
	cropRect.left = 0;
	cropRect.right = inWidth;
	cropRect.top = (inHeight - (outHeight / (float) outWidth) * inWidth) / 2;
	cropRect.bottom = inHeight - cropRect.top;
	}
	return cropRect;
	}

	protected static CompressFormat convertExtensionToCompressFormat(String extension) {
	return extension.equals("png") ? CompressFormat.PNG : CompressFormat.JPEG;
	}

	protected static String getFileExtension(String requestFormat) {
	String outputFormat = (requestFormat == null)
	? "jpg"
	: requestFormat;
	outputFormat = outputFormat.toLowerCase();
	return (outputFormat.equals("png") \|\| outputFormat.equals("gif"))
	? "png" // We don't support gif compression.
	: "jpg";
	}
	}