src/com/android/wallpaperpicker/WallpaperCropActivity.java - platform/packages/apps/WallpaperPicker - Git at Google

 /*
  * 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.wallpaperpicker;

 import android.annotation.TargetApi;
 import android.app.ActionBar;
 import android.app.Activity;
 import android.app.WallpaperManager;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Matrix;
 import android.graphics.Point;
 import android.graphics.RectF;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Message;
 import android.util.Log;
 import android.view.Display;
 import android.view.View;
 import android.widget.Toast;

 import com.android.wallpaperpicker.common.CropAndSetWallpaperTask;
 import com.android.gallery3d.common.Utils;
 import com.android.photos.BitmapRegionTileSource;
 import com.android.photos.BitmapRegionTileSource.BitmapSource;
 import com.android.photos.BitmapRegionTileSource.BitmapSource.InBitmapProvider;
 import com.android.photos.views.TiledImageRenderer.TileSource;
 import com.android.wallpaperpicker.common.DialogUtils;
 import com.android.wallpaperpicker.common.InputStreamProvider;

 import java.util.Collections;
 import java.util.Set;
 import java.util.WeakHashMap;

 public class WallpaperCropActivity extends Activity implements Handler.Callback {
     private static final String LOGTAG = "WallpaperCropActivity";

     private static final int MSG_LOAD_IMAGE = 1;

     protected CropView mCropView;
     protected View mProgressView;
     protected View mSetWallpaperButton;

     private HandlerThread mLoaderThread;
     private Handler mLoaderHandler;
     private LoadRequest mCurrentLoadRequest;
     private byte[] mTempStorageForDecoding = new byte[16 * 1024];
     // A weak-set of reusable bitmaps
     private Set<Bitmap> mReusableBitmaps =
             Collections.newSetFromMap(new WeakHashMap<Bitmap, Boolean>());

     private final DialogInterface.OnCancelListener mOnDialogCancelListener =
             new DialogInterface.OnCancelListener() {
                 @Override
                 public void onCancel(DialogInterface dialog) {
                     showActionBarAndTiles();
                 }
             };

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         mLoaderThread = new HandlerThread("wallpaper_loader");
         mLoaderThread.start();
         mLoaderHandler = new Handler(mLoaderThread.getLooper(), this);

         init();
         if (!enableRotation()) {
             setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
         }
     }

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

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

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

         if (imageUri == null) {
             Log.e(LOGTAG, "No URI passed in intent, exiting WallpaperCropActivity");
             finish();
             return;
         }

         // 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) {
                         actionBar.hide();
                         // Never fade on finish because we return to the app that started us (e.g.
                         // Photos), not the home screen.
                         cropImageAndSetWallpaper(imageUri, null, false /* shouldFadeOutOnFinish */);
                     }
                 });
         mSetWallpaperButton = findViewById(R.id.set_wallpaper_button);

         // Load image in background
         final BitmapRegionTileSource.InputStreamSource bitmapSource =
                 new BitmapRegionTileSource.InputStreamSource(this, imageUri);
         mSetWallpaperButton.setEnabled(false);
         Runnable onLoad = new Runnable() {
             public void run() {
                 if (bitmapSource.getLoadingState() != BitmapSource.State.LOADED) {
                     Toast.makeText(WallpaperCropActivity.this, R.string.wallpaper_load_fail,
                             Toast.LENGTH_LONG).show();
                     finish();
                 } else {
                     mSetWallpaperButton.setEnabled(true);
                 }
             }
         };
         setCropViewTileSource(bitmapSource, true, false, null, onLoad);
     }

     @Override
     public void onDestroy() {
         if (mCropView != null) {
             mCropView.destroy();
         }
         if (mLoaderThread != null) {
             mLoaderThread.quit();
         }
         super.onDestroy();
     }

     /**
      * This is called on {@link #mLoaderThread}
      */
     @TargetApi(Build.VERSION_CODES.KITKAT)
     @Override
     public boolean handleMessage(Message msg) {
         if (msg.what == MSG_LOAD_IMAGE) {
             final LoadRequest req = (LoadRequest) msg.obj;
             final boolean loadSuccess;

             if (req.src == null) {
                 Drawable defaultWallpaper = WallpaperManager.getInstance(this)
                         .getBuiltInDrawable(mCropView.getWidth(), mCropView.getHeight(),
                                 false, 0.5f, 0.5f);

                 if (defaultWallpaper == null) {
                     loadSuccess = false;
                     Log.w(LOGTAG, "Null default wallpaper encountered.");
                 } else {
                     loadSuccess = true;
                     req.result = new DrawableTileSource(this,
                             defaultWallpaper, DrawableTileSource.MAX_PREVIEW_SIZE);
                 }
             } else {
                 try {
                     req.src.loadInBackground(new InBitmapProvider() {

                         @Override
                         public Bitmap forPixelCount(int count) {
                             Bitmap bitmapToReuse = null;
                             // Find the smallest bitmap that satisfies the pixel count limit
                             synchronized (mReusableBitmaps) {
                                 int currentBitmapSize = Integer.MAX_VALUE;
                                 for (Bitmap b : mReusableBitmaps) {
                                     int bitmapSize = b.getWidth() * b.getHeight();
                                     if ((bitmapSize >= count) && (bitmapSize < currentBitmapSize)) {
                                         bitmapToReuse = b;
                                         currentBitmapSize = bitmapSize;
                                     }
                                 }

                                 if (bitmapToReuse != null) {
                                     mReusableBitmaps.remove(bitmapToReuse);
                                 }
                             }
                             return bitmapToReuse;
                         }
                     });
                 } catch (SecurityException securityException) {
                     if (isActivityDestroyed()) {
                         // Temporarily granted permissions are revoked when the activity
                         // finishes, potentially resulting in a SecurityException here.
                         // Even though {@link #isDestroyed} might also return true in different
                         // situations where the configuration changes, we are fine with
                         // catching these cases here as well.
                         return true;
                     } else {
                         // otherwise it had a different cause and we throw it further
                         throw securityException;
                     }
                 }

                 req.result = new BitmapRegionTileSource(WallpaperCropActivity.this, req.src,
                         mTempStorageForDecoding);
                 loadSuccess = req.src.getLoadingState() == BitmapSource.State.LOADED;
             }

             runOnUiThread(new Runnable() {

                 @Override
                 public void run() {
                     if (req == mCurrentLoadRequest) {
                         onLoadRequestComplete(req, loadSuccess);
                     } else {
                         addReusableBitmap(req.result);
                     }
                 }
             });
             return true;
         }
         return false;
     }

     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
     public boolean isActivityDestroyed() {
         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 && isDestroyed();
     }

     private void addReusableBitmap(TileSource src) {
         synchronized (mReusableBitmaps) {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
                 && src instanceof BitmapRegionTileSource) {
                 Bitmap preview = ((BitmapRegionTileSource) src).getBitmap();
                 if (preview != null && preview.isMutable()) {
                     mReusableBitmaps.add(preview);
                 }
             }
         }
     }

     public DialogInterface.OnCancelListener getOnDialogCancelListener() {
         return mOnDialogCancelListener;
     }

     private void showActionBarAndTiles() {
         getActionBar().show();
         View wallpaperStrip = findViewById(R.id.wallpaper_strip);
         if (wallpaperStrip != null) {
             wallpaperStrip.setVisibility(View.VISIBLE);
         }
     }

     protected void onLoadRequestComplete(LoadRequest req, boolean success) {
         mCurrentLoadRequest = null;
         if (success) {
             TileSource oldSrc = mCropView.getTileSource();
             mCropView.setTileSource(req.result, null);
             mCropView.setTouchEnabled(req.touchEnabled);
             if (req.moveToLeft) {
                 mCropView.moveToLeft();
             }
             if (req.scaleAndOffsetProvider != null) {
                 TileSource src = req.result;
                 Point wallpaperSize = WallpaperUtils.getDefaultWallpaperSize(
                         getResources(), getWindowManager());
                 RectF crop = Utils.getMaxCropRect(src.getImageWidth(), src.getImageHeight(),
                         wallpaperSize.x, wallpaperSize.y, false /* leftAligned */);
                 mCropView.setScale(req.scaleAndOffsetProvider.getScale(wallpaperSize, crop));
                 mCropView.setParallaxOffset(req.scaleAndOffsetProvider.getParallaxOffset(), crop);
             }

             // Free last image
             if (oldSrc != null) {
                 // Call yield instead of recycle, as we only want to free GL resource.
                 // We can still reuse the bitmap for decoding any other image.
                 oldSrc.getPreview().yield();
             }
             addReusableBitmap(oldSrc);
         }
         if (req.postExecute != null) {
             req.postExecute.run();
         }
         mProgressView.setVisibility(View.GONE);
     }

     @TargetApi(Build.VERSION_CODES.KITKAT)
     public final void setCropViewTileSource(BitmapSource bitmapSource, boolean touchEnabled,
             boolean moveToLeft, CropViewScaleAndOffsetProvider scaleAndOffsetProvider,
             Runnable postExecute) {
         final LoadRequest req = new LoadRequest();
         req.moveToLeft = moveToLeft;
         req.src = bitmapSource;
         req.touchEnabled = touchEnabled;
         req.postExecute = postExecute;
         req.scaleAndOffsetProvider = scaleAndOffsetProvider;
         mCurrentLoadRequest = req;

         // Remove any pending requests
         mLoaderHandler.removeMessages(MSG_LOAD_IMAGE);
         Message.obtain(mLoaderHandler, MSG_LOAD_IMAGE, req).sendToTarget();

         // We don't want to show the spinner every time we load an image, because that would be
         // annoying; instead, only start showing the spinner if loading the image has taken
         // longer than 1 sec (ie 1000 ms)
         mProgressView.postDelayed(new Runnable() {
             public void run() {
                 if (mCurrentLoadRequest == req) {
                     mProgressView.setVisibility(View.VISIBLE);
                 }
             }
         }, 1000);
     }


     public boolean enableRotation() {
         return true;
     }

     public void cropImageAndSetWallpaper(Resources res, int resId, boolean shouldFadeOutOnFinish) {
         // crop this image and scale it down to the default wallpaper size for
         // this device
         InputStreamProvider streamProvider = InputStreamProvider.fromResource(res, resId);
         Point inSize = mCropView.getSourceDimensions();
         Point outSize = WallpaperUtils.getDefaultWallpaperSize(getResources(),
                 getWindowManager());
         RectF crop = Utils.getMaxCropRect(
                 inSize.x, inSize.y, outSize.x, outSize.y, false);
         // Passing 0, 0 will cause launcher to revert to using the
         // default wallpaper size
         CropAndFinishHandler onEndCrop = new CropAndFinishHandler(new Point(0, 0),
                 shouldFadeOutOnFinish);
         CropAndSetWallpaperTask cropTask = new CropAndSetWallpaperTask(
                 streamProvider, this, crop, streamProvider.getRotationFromExif(this),
                 outSize.x, outSize.y, onEndCrop);
         DialogUtils.executeCropTaskAfterPrompt(this, cropTask, getOnDialogCancelListener());
     }

     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
     public void cropImageAndSetWallpaper(Uri uri,
             CropAndSetWallpaperTask.OnBitmapCroppedHandler onBitmapCroppedHandler,
             boolean shouldFadeOutOnFinish) {
         // Get the crop
         boolean ltr = mCropView.getLayoutDirection() == View.LAYOUT_DIRECTION_LTR;

         Display d = getWindowManager().getDefaultDisplay();

         Point displaySize = new Point();
         d.getSize(displaySize);
         boolean isPortrait = displaySize.x < displaySize.y;

         Point defaultWallpaperSize = WallpaperUtils.getDefaultWallpaperSize(getResources(),
                 getWindowManager());
         // Get the crop
         RectF cropRect = mCropView.getCrop();

         Point inSize = mCropView.getSourceDimensions();

         int cropRotation = mCropView.getImageRotation();
         float cropScale = mCropView.getWidth() / (float) cropRect.width();

         Matrix rotateMatrix = new Matrix();
         rotateMatrix.setRotate(cropRotation);
         float[] rotatedInSize = new float[] { inSize.x, inSize.y };
         rotateMatrix.mapPoints(rotatedInSize);
         rotatedInSize[0] = Math.abs(rotatedInSize[0]);
         rotatedInSize[1] = Math.abs(rotatedInSize[1]);

         // due to rounding errors in the cropview renderer the edges can be slightly offset
         // therefore we ensure that the boundaries are sanely defined
         cropRect.left = Math.max(0, cropRect.left);
         cropRect.right = Math.min(rotatedInSize[0], cropRect.right);
         cropRect.top = Math.max(0, cropRect.top);
         cropRect.bottom = Math.min(rotatedInSize[1], cropRect.bottom);

         // ADJUST CROP WIDTH
         // Extend the crop all the way to the right, for parallax
         // (or all the way to the left, in RTL)
         float extraSpace = ltr ? rotatedInSize[0] - cropRect.right : cropRect.left;
         // Cap the amount of extra width
         float maxExtraSpace = defaultWallpaperSize.x / cropScale - cropRect.width();
         extraSpace = Math.min(extraSpace, maxExtraSpace);

         if (ltr) {
             cropRect.right += extraSpace;
         } else {
             cropRect.left -= extraSpace;
         }

         // ADJUST CROP HEIGHT
         if (isPortrait) {
             cropRect.bottom = cropRect.top + defaultWallpaperSize.y / cropScale;
         } else { // LANDSCAPE
             float extraPortraitHeight =
                     defaultWallpaperSize.y / cropScale - cropRect.height();
             float expandHeight =
                     Math.min(Math.min(rotatedInSize[1] - 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);
         CropAndFinishHandler onEndCrop = new CropAndFinishHandler(new Point(outWidth, outHeight),
                 shouldFadeOutOnFinish);

         CropAndSetWallpaperTask cropTask = new CropAndSetWallpaperTask(
                 InputStreamProvider.fromUri(this, uri), this,
                 cropRect, cropRotation, outWidth, outHeight, onEndCrop) {
             @Override
             protected void onPreExecute() {
                 // Give some feedback so user knows something is happening.
                 mProgressView.setVisibility(View.VISIBLE);
             }
         };
         if (onBitmapCroppedHandler != null) {
             cropTask.setOnBitmapCropped(onBitmapCroppedHandler);
         }
         DialogUtils.executeCropTaskAfterPrompt(this, cropTask, getOnDialogCancelListener());
     }

     public void setBoundsAndFinish(Point bounds, boolean overrideTransition) {
         WallpaperUtils.saveWallpaperDimensions(bounds.x, bounds.y, this);
         setResult(Activity.RESULT_OK);
         finish();
         if (overrideTransition) {
             overridePendingTransition(0, R.anim.fade_out);
         }
     }

     public class CropAndFinishHandler implements CropAndSetWallpaperTask.OnEndCropHandler {
         private final Point mBounds;
         private boolean mShouldFadeOutOnFinish;

         /**
          * @param shouldFadeOutOnFinish Whether the wallpaper picker should override the default
          * exit animation to fade out instead. This should only be set to true if the wallpaper
          * preview will exactly match the actual wallpaper on the page we are returning to.
          */
         public CropAndFinishHandler(Point bounds, boolean shouldFadeOutOnFinish) {
             mBounds = bounds;
             mShouldFadeOutOnFinish = shouldFadeOutOnFinish;
         }

         @Override
         public void run(boolean cropSucceeded) {
             setBoundsAndFinish(mBounds, cropSucceeded && mShouldFadeOutOnFinish);
         }
     }

     static class LoadRequest {
         BitmapSource src;
         boolean touchEnabled;
         boolean moveToLeft;
         Runnable postExecute;
         CropViewScaleAndOffsetProvider scaleAndOffsetProvider;

         TileSource result;
     }

     public interface CropViewScaleAndOffsetProvider {
         float getScale(Point wallpaperSize, RectF crop);
         float getParallaxOffset();
     }
 }
	/*
	* 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.wallpaperpicker;

	import android.annotation.TargetApi;
	import android.app.ActionBar;
	import android.app.Activity;
	import android.app.WallpaperManager;
	import android.content.DialogInterface;
	import android.content.Intent;
	import android.content.pm.ActivityInfo;
	import android.content.res.Resources;
	import android.graphics.Bitmap;
	import android.graphics.Matrix;
	import android.graphics.Point;
	import android.graphics.RectF;
	import android.graphics.drawable.Drawable;
	import android.net.Uri;
	import android.os.Build;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Message;
	import android.util.Log;
	import android.view.Display;
	import android.view.View;
	import android.widget.Toast;

	import com.android.wallpaperpicker.common.CropAndSetWallpaperTask;
	import com.android.gallery3d.common.Utils;
	import com.android.photos.BitmapRegionTileSource;
	import com.android.photos.BitmapRegionTileSource.BitmapSource;
	import com.android.photos.BitmapRegionTileSource.BitmapSource.InBitmapProvider;
	import com.android.photos.views.TiledImageRenderer.TileSource;
	import com.android.wallpaperpicker.common.DialogUtils;
	import com.android.wallpaperpicker.common.InputStreamProvider;

	import java.util.Collections;
	import java.util.Set;
	import java.util.WeakHashMap;

	public class WallpaperCropActivity extends Activity implements Handler.Callback {
	private static final String LOGTAG = "WallpaperCropActivity";

	private static final int MSG_LOAD_IMAGE = 1;

	protected CropView mCropView;
	protected View mProgressView;
	protected View mSetWallpaperButton;

	private HandlerThread mLoaderThread;
	private Handler mLoaderHandler;
	private LoadRequest mCurrentLoadRequest;
	private byte[] mTempStorageForDecoding = new byte[16 * 1024];
	// A weak-set of reusable bitmaps
	private Set<Bitmap> mReusableBitmaps =
	Collections.newSetFromMap(new WeakHashMap<Bitmap, Boolean>());

	private final DialogInterface.OnCancelListener mOnDialogCancelListener =
	new DialogInterface.OnCancelListener() {
	@Override
	public void onCancel(DialogInterface dialog) {
	showActionBarAndTiles();
	}
	};

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	mLoaderThread = new HandlerThread("wallpaper_loader");
	mLoaderThread.start();
	mLoaderHandler = new Handler(mLoaderThread.getLooper(), this);

	init();
	if (!enableRotation()) {
	setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
	}
	}

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

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

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

	if (imageUri == null) {
	Log.e(LOGTAG, "No URI passed in intent, exiting WallpaperCropActivity");
	finish();
	return;
	}

	// 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) {
	actionBar.hide();
	// Never fade on finish because we return to the app that started us (e.g.
	// Photos), not the home screen.
	cropImageAndSetWallpaper(imageUri, null, false /* shouldFadeOutOnFinish */);
	}
	});
	mSetWallpaperButton = findViewById(R.id.set_wallpaper_button);

	// Load image in background
	final BitmapRegionTileSource.InputStreamSource bitmapSource =
	new BitmapRegionTileSource.InputStreamSource(this, imageUri);
	mSetWallpaperButton.setEnabled(false);
	Runnable onLoad = new Runnable() {
	public void run() {
	if (bitmapSource.getLoadingState() != BitmapSource.State.LOADED) {
	Toast.makeText(WallpaperCropActivity.this, R.string.wallpaper_load_fail,
	Toast.LENGTH_LONG).show();
	finish();
	} else {
	mSetWallpaperButton.setEnabled(true);
	}
	}
	};
	setCropViewTileSource(bitmapSource, true, false, null, onLoad);
	}

	@Override
	public void onDestroy() {
	if (mCropView != null) {
	mCropView.destroy();
	}
	if (mLoaderThread != null) {
	mLoaderThread.quit();
	}
	super.onDestroy();
	}

	/**
	* This is called on {@link #mLoaderThread}
	*/
	@TargetApi(Build.VERSION_CODES.KITKAT)
	@Override
	public boolean handleMessage(Message msg) {
	if (msg.what == MSG_LOAD_IMAGE) {
	final LoadRequest req = (LoadRequest) msg.obj;
	final boolean loadSuccess;

	if (req.src == null) {
	Drawable defaultWallpaper = WallpaperManager.getInstance(this)
	.getBuiltInDrawable(mCropView.getWidth(), mCropView.getHeight(),
	false, 0.5f, 0.5f);

	if (defaultWallpaper == null) {
	loadSuccess = false;
	Log.w(LOGTAG, "Null default wallpaper encountered.");
	} else {
	loadSuccess = true;
	req.result = new DrawableTileSource(this,
	defaultWallpaper, DrawableTileSource.MAX_PREVIEW_SIZE);
	}
	} else {
	try {
	req.src.loadInBackground(new InBitmapProvider() {

	@Override
	public Bitmap forPixelCount(int count) {
	Bitmap bitmapToReuse = null;
	// Find the smallest bitmap that satisfies the pixel count limit
	synchronized (mReusableBitmaps) {
	int currentBitmapSize = Integer.MAX_VALUE;
	for (Bitmap b : mReusableBitmaps) {
	int bitmapSize = b.getWidth() * b.getHeight();
	if ((bitmapSize >= count) && (bitmapSize < currentBitmapSize)) {
	bitmapToReuse = b;
	currentBitmapSize = bitmapSize;
	}
	}

	if (bitmapToReuse != null) {
	mReusableBitmaps.remove(bitmapToReuse);
	}
	}
	return bitmapToReuse;
	}
	});
	} catch (SecurityException securityException) {
	if (isActivityDestroyed()) {
	// Temporarily granted permissions are revoked when the activity
	// finishes, potentially resulting in a SecurityException here.
	// Even though {@link #isDestroyed} might also return true in different
	// situations where the configuration changes, we are fine with
	// catching these cases here as well.
	return true;
	} else {
	// otherwise it had a different cause and we throw it further
	throw securityException;
	}
	}

	req.result = new BitmapRegionTileSource(WallpaperCropActivity.this, req.src,
	mTempStorageForDecoding);
	loadSuccess = req.src.getLoadingState() == BitmapSource.State.LOADED;
	}

	runOnUiThread(new Runnable() {

	@Override
	public void run() {
	if (req == mCurrentLoadRequest) {
	onLoadRequestComplete(req, loadSuccess);
	} else {
	addReusableBitmap(req.result);
	}
	}
	});
	return true;
	}
	return false;
	}

	@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
	public boolean isActivityDestroyed() {
	return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 && isDestroyed();
	}

	private void addReusableBitmap(TileSource src) {
	synchronized (mReusableBitmaps) {
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
	&& src instanceof BitmapRegionTileSource) {
	Bitmap preview = ((BitmapRegionTileSource) src).getBitmap();
	if (preview != null && preview.isMutable()) {
	mReusableBitmaps.add(preview);
	}
	}
	}
	}

	public DialogInterface.OnCancelListener getOnDialogCancelListener() {
	return mOnDialogCancelListener;
	}

	private void showActionBarAndTiles() {
	getActionBar().show();
	View wallpaperStrip = findViewById(R.id.wallpaper_strip);
	if (wallpaperStrip != null) {
	wallpaperStrip.setVisibility(View.VISIBLE);
	}
	}

	protected void onLoadRequestComplete(LoadRequest req, boolean success) {
	mCurrentLoadRequest = null;
	if (success) {
	TileSource oldSrc = mCropView.getTileSource();
	mCropView.setTileSource(req.result, null);
	mCropView.setTouchEnabled(req.touchEnabled);
	if (req.moveToLeft) {
	mCropView.moveToLeft();
	}
	if (req.scaleAndOffsetProvider != null) {
	TileSource src = req.result;
	Point wallpaperSize = WallpaperUtils.getDefaultWallpaperSize(
	getResources(), getWindowManager());
	RectF crop = Utils.getMaxCropRect(src.getImageWidth(), src.getImageHeight(),
	wallpaperSize.x, wallpaperSize.y, false /* leftAligned */);
	mCropView.setScale(req.scaleAndOffsetProvider.getScale(wallpaperSize, crop));
	mCropView.setParallaxOffset(req.scaleAndOffsetProvider.getParallaxOffset(), crop);
	}

	// Free last image
	if (oldSrc != null) {
	// Call yield instead of recycle, as we only want to free GL resource.
	// We can still reuse the bitmap for decoding any other image.
	oldSrc.getPreview().yield();
	}
	addReusableBitmap(oldSrc);
	}
	if (req.postExecute != null) {
	req.postExecute.run();
	}
	mProgressView.setVisibility(View.GONE);
	}

	@TargetApi(Build.VERSION_CODES.KITKAT)
	public final void setCropViewTileSource(BitmapSource bitmapSource, boolean touchEnabled,
	boolean moveToLeft, CropViewScaleAndOffsetProvider scaleAndOffsetProvider,
	Runnable postExecute) {
	final LoadRequest req = new LoadRequest();
	req.moveToLeft = moveToLeft;
	req.src = bitmapSource;
	req.touchEnabled = touchEnabled;
	req.postExecute = postExecute;
	req.scaleAndOffsetProvider = scaleAndOffsetProvider;
	mCurrentLoadRequest = req;

	// Remove any pending requests
	mLoaderHandler.removeMessages(MSG_LOAD_IMAGE);
	Message.obtain(mLoaderHandler, MSG_LOAD_IMAGE, req).sendToTarget();

	// We don't want to show the spinner every time we load an image, because that would be
	// annoying; instead, only start showing the spinner if loading the image has taken
	// longer than 1 sec (ie 1000 ms)
	mProgressView.postDelayed(new Runnable() {
	public void run() {
	if (mCurrentLoadRequest == req) {
	mProgressView.setVisibility(View.VISIBLE);
	}
	}
	}, 1000);
	}


	public boolean enableRotation() {
	return true;
	}

	public void cropImageAndSetWallpaper(Resources res, int resId, boolean shouldFadeOutOnFinish) {
	// crop this image and scale it down to the default wallpaper size for
	// this device
	InputStreamProvider streamProvider = InputStreamProvider.fromResource(res, resId);
	Point inSize = mCropView.getSourceDimensions();
	Point outSize = WallpaperUtils.getDefaultWallpaperSize(getResources(),
	getWindowManager());
	RectF crop = Utils.getMaxCropRect(
	inSize.x, inSize.y, outSize.x, outSize.y, false);
	// Passing 0, 0 will cause launcher to revert to using the
	// default wallpaper size
	CropAndFinishHandler onEndCrop = new CropAndFinishHandler(new Point(0, 0),
	shouldFadeOutOnFinish);
	CropAndSetWallpaperTask cropTask = new CropAndSetWallpaperTask(
	streamProvider, this, crop, streamProvider.getRotationFromExif(this),
	outSize.x, outSize.y, onEndCrop);
	DialogUtils.executeCropTaskAfterPrompt(this, cropTask, getOnDialogCancelListener());
	}

	@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
	public void cropImageAndSetWallpaper(Uri uri,
	CropAndSetWallpaperTask.OnBitmapCroppedHandler onBitmapCroppedHandler,
	boolean shouldFadeOutOnFinish) {
	// Get the crop
	boolean ltr = mCropView.getLayoutDirection() == View.LAYOUT_DIRECTION_LTR;

	Display d = getWindowManager().getDefaultDisplay();

	Point displaySize = new Point();
	d.getSize(displaySize);
	boolean isPortrait = displaySize.x < displaySize.y;

	Point defaultWallpaperSize = WallpaperUtils.getDefaultWallpaperSize(getResources(),
	getWindowManager());
	// Get the crop
	RectF cropRect = mCropView.getCrop();

	Point inSize = mCropView.getSourceDimensions();

	int cropRotation = mCropView.getImageRotation();
	float cropScale = mCropView.getWidth() / (float) cropRect.width();

	Matrix rotateMatrix = new Matrix();
	rotateMatrix.setRotate(cropRotation);
	float[] rotatedInSize = new float[] { inSize.x, inSize.y };
	rotateMatrix.mapPoints(rotatedInSize);
	rotatedInSize[0] = Math.abs(rotatedInSize[0]);
	rotatedInSize[1] = Math.abs(rotatedInSize[1]);

	// due to rounding errors in the cropview renderer the edges can be slightly offset
	// therefore we ensure that the boundaries are sanely defined
	cropRect.left = Math.max(0, cropRect.left);
	cropRect.right = Math.min(rotatedInSize[0], cropRect.right);
	cropRect.top = Math.max(0, cropRect.top);
	cropRect.bottom = Math.min(rotatedInSize[1], cropRect.bottom);

	// ADJUST CROP WIDTH
	// Extend the crop all the way to the right, for parallax
	// (or all the way to the left, in RTL)
	float extraSpace = ltr ? rotatedInSize[0] - cropRect.right : cropRect.left;
	// Cap the amount of extra width
	float maxExtraSpace = defaultWallpaperSize.x / cropScale - cropRect.width();
	extraSpace = Math.min(extraSpace, maxExtraSpace);

	if (ltr) {
	cropRect.right += extraSpace;
	} else {
	cropRect.left -= extraSpace;
	}

	// ADJUST CROP HEIGHT
	if (isPortrait) {
	cropRect.bottom = cropRect.top + defaultWallpaperSize.y / cropScale;
	} else { // LANDSCAPE
	float extraPortraitHeight =
	defaultWallpaperSize.y / cropScale - cropRect.height();
	float expandHeight =
	Math.min(Math.min(rotatedInSize[1] - 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);
	CropAndFinishHandler onEndCrop = new CropAndFinishHandler(new Point(outWidth, outHeight),
	shouldFadeOutOnFinish);

	CropAndSetWallpaperTask cropTask = new CropAndSetWallpaperTask(
	InputStreamProvider.fromUri(this, uri), this,
	cropRect, cropRotation, outWidth, outHeight, onEndCrop) {
	@Override
	protected void onPreExecute() {
	// Give some feedback so user knows something is happening.
	mProgressView.setVisibility(View.VISIBLE);
	}
	};
	if (onBitmapCroppedHandler != null) {
	cropTask.setOnBitmapCropped(onBitmapCroppedHandler);
	}
	DialogUtils.executeCropTaskAfterPrompt(this, cropTask, getOnDialogCancelListener());
	}

	public void setBoundsAndFinish(Point bounds, boolean overrideTransition) {
	WallpaperUtils.saveWallpaperDimensions(bounds.x, bounds.y, this);
	setResult(Activity.RESULT_OK);
	finish();
	if (overrideTransition) {
	overridePendingTransition(0, R.anim.fade_out);
	}
	}

	public class CropAndFinishHandler implements CropAndSetWallpaperTask.OnEndCropHandler {
	private final Point mBounds;
	private boolean mShouldFadeOutOnFinish;

	/**
	* @param shouldFadeOutOnFinish Whether the wallpaper picker should override the default
	* exit animation to fade out instead. This should only be set to true if the wallpaper
	* preview will exactly match the actual wallpaper on the page we are returning to.
	*/
	public CropAndFinishHandler(Point bounds, boolean shouldFadeOutOnFinish) {
	mBounds = bounds;
	mShouldFadeOutOnFinish = shouldFadeOutOnFinish;
	}

	@Override
	public void run(boolean cropSucceeded) {
	setBoundsAndFinish(mBounds, cropSucceeded && mShouldFadeOutOnFinish);
	}
	}

	static class LoadRequest {
	BitmapSource src;
	boolean touchEnabled;
	boolean moveToLeft;
	Runnable postExecute;
	CropViewScaleAndOffsetProvider scaleAndOffsetProvider;

	TileSource result;
	}

	public interface CropViewScaleAndOffsetProvider {
	float getScale(Point wallpaperSize, RectF crop);
	float getParallaxOffset();
	}
	}