packages/SettingsLib/AvatarPicker/src/AvatarPhotoController.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2022 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.settingslib.avatarpicker;

 import android.app.Activity;
 import android.content.ClipData;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.RectF;
 import android.media.ExifInterface;
 import android.net.Uri;
 import android.os.StrictMode;
 import android.provider.MediaStore;
 import android.util.EventLog;
 import android.util.Log;

 import androidx.annotation.Nullable;
 import androidx.core.content.FileProvider;

 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;

 import libcore.io.Streams;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.List;

 class AvatarPhotoController {

     interface AvatarUi {
         boolean isFinishing();

         void returnUriResult(Uri uri);

         void startActivityForResult(Intent intent, int resultCode);

         boolean startSystemActivityForResult(Intent intent, int resultCode);

         int getPhotoSize();
     }

     interface ContextInjector {
         File getCacheDir();

         Uri createTempImageUri(File parentDir, String fileName, boolean purge);

         ContentResolver getContentResolver();

         Context getContext();
     }

     private static final String TAG = "AvatarPhotoController";

     static final int REQUEST_CODE_CHOOSE_PHOTO = 1001;
     static final int REQUEST_CODE_TAKE_PHOTO = 1002;
     static final int REQUEST_CODE_CROP_PHOTO = 1003;

     /**
      * Delay to allow the photo picker exit animation to complete before the crop activity opens.
      */
     private static final long DELAY_BEFORE_CROP_MILLIS = 150;

     private static final String IMAGES_DIR = "multi_user";
     private static final String PRE_CROP_PICTURE_FILE_NAME = "PreCropEditUserPhoto.jpg";
     private static final String CROP_PICTURE_FILE_NAME = "CropEditUserPhoto.jpg";
     private static final String TAKE_PICTURE_FILE_NAME = "TakeEditUserPhoto.jpg";

     private final int mPhotoSize;

     private final AvatarUi mAvatarUi;
     private final ContextInjector mContextInjector;

     private final File mImagesDir;
     private final Uri mPreCropPictureUri;
     private final Uri mCropPictureUri;
     private final Uri mTakePictureUri;

     AvatarPhotoController(AvatarUi avatarUi, ContextInjector contextInjector, boolean waiting) {
         mAvatarUi = avatarUi;
         mContextInjector = contextInjector;

         mImagesDir = new File(mContextInjector.getCacheDir(), IMAGES_DIR);
         mImagesDir.mkdir();
         mPreCropPictureUri = mContextInjector
                 .createTempImageUri(mImagesDir, PRE_CROP_PICTURE_FILE_NAME, !waiting);
         mCropPictureUri =
                 mContextInjector.createTempImageUri(mImagesDir, CROP_PICTURE_FILE_NAME, !waiting);
         mTakePictureUri =
                 mContextInjector.createTempImageUri(mImagesDir, TAKE_PICTURE_FILE_NAME, !waiting);
         mPhotoSize = mAvatarUi.getPhotoSize();
     }

     /**
      * Handles activity result from containing activity/fragment after a take/choose/crop photo
      * action result is received.
      */
     public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
         if (resultCode != Activity.RESULT_OK) {
             return false;
         }
         final Uri pictureUri = data != null && data.getData() != null
                 ? data.getData() : mTakePictureUri;

         // Check if the result is a content uri
         if (!ContentResolver.SCHEME_CONTENT.equals(pictureUri.getScheme())) {
             Log.e(TAG, "Invalid pictureUri scheme: " + pictureUri.getScheme());
             EventLog.writeEvent(0x534e4554, "172939189", -1, pictureUri.getPath());
             return false;
         }

         switch (requestCode) {
             case REQUEST_CODE_CROP_PHOTO:
                 mAvatarUi.returnUriResult(pictureUri);
                 return true;
             case REQUEST_CODE_TAKE_PHOTO:
                 if (mTakePictureUri.equals(pictureUri)) {
                     cropPhoto(pictureUri);
                 } else {
                     copyAndCropPhoto(pictureUri, false);
                 }
                 return true;
             case REQUEST_CODE_CHOOSE_PHOTO:
                 copyAndCropPhoto(pictureUri, true);
                 return true;
         }
         return false;
     }

     void takePhoto() {
         Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE_SECURE);
         appendOutputExtra(intent, mTakePictureUri);
         mAvatarUi.startActivityForResult(intent, REQUEST_CODE_TAKE_PHOTO);
     }

     void choosePhoto() {
         Intent intent = new Intent(MediaStore.ACTION_PICK_IMAGES, null);
         intent.setType("image/*");
         mAvatarUi.startActivityForResult(intent, REQUEST_CODE_CHOOSE_PHOTO);
     }

     private void copyAndCropPhoto(final Uri pictureUri, boolean delayBeforeCrop) {
         ListenableFuture<Uri> future = ThreadUtils.getBackgroundExecutor().submit(() -> {
             final ContentResolver cr = mContextInjector.getContentResolver();
             try {
                 InputStream in = cr.openInputStream(pictureUri);
                 OutputStream out = cr.openOutputStream(mPreCropPictureUri);
                 Streams.copy(in, out);
                 return mPreCropPictureUri;
             } catch (IOException e) {
                 Log.w(TAG, "Failed to copy photo", e);
                 return null;
             }
         });
         Futures.addCallback(future, new FutureCallback<>() {
             @Override
             public void onSuccess(@Nullable Uri result) {
                 if (result == null) {
                     return;
                 }
                 Runnable cropRunnable = () -> {
                     if (!mAvatarUi.isFinishing()) {
                         cropPhoto(mPreCropPictureUri);
                     }
                 };
                 if (delayBeforeCrop) {
                     mContextInjector.getContext().getMainThreadHandler()
                             .postDelayed(cropRunnable, DELAY_BEFORE_CROP_MILLIS);
                 } else {
                     cropRunnable.run();
                 }
             }

             @Override
             public void onFailure(Throwable t) {
                 Log.e(TAG, "Error performing copy-and-crop", t);
             }
         }, mContextInjector.getContext().getMainExecutor());
     }

     private void cropPhoto(final Uri pictureUri) {
         // TODO: Use a public intent, when there is one.
         Intent intent = new Intent("com.android.camera.action.CROP");
         intent.setDataAndType(pictureUri, "image/*");
         appendOutputExtra(intent, mCropPictureUri);
         appendCropExtras(intent);
         try {
             StrictMode.disableDeathOnFileUriExposure();
             if (mAvatarUi.startSystemActivityForResult(intent, REQUEST_CODE_CROP_PHOTO)) {
                 return;
             }
         } finally {
             StrictMode.enableDeathOnFileUriExposure();
         }
         onPhotoNotCropped(pictureUri);
     }

     private void appendOutputExtra(Intent intent, Uri pictureUri) {
         intent.putExtra(MediaStore.EXTRA_OUTPUT, pictureUri);
         intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION
                 | Intent.FLAG_GRANT_READ_URI_PERMISSION);
         intent.setClipData(ClipData.newRawUri(MediaStore.EXTRA_OUTPUT, pictureUri));
     }

     private void appendCropExtras(Intent intent) {
         intent.putExtra("crop", "true");
         intent.putExtra("scale", true);
         intent.putExtra("scaleUpIfNeeded", true);
         intent.putExtra("aspectX", 1);
         intent.putExtra("aspectY", 1);
         intent.putExtra("outputX", mPhotoSize);
         intent.putExtra("outputY", mPhotoSize);
     }

     private void onPhotoNotCropped(final Uri data) {
         ListenableFuture<Bitmap> future = ThreadUtils.getBackgroundExecutor().submit(() -> {
             // Scale and crop to a square aspect ratio
             Bitmap croppedImage = Bitmap.createBitmap(mPhotoSize, mPhotoSize,
                     Bitmap.Config.ARGB_8888);
             Canvas canvas = new Canvas(croppedImage);
             Bitmap fullImage;
             try (InputStream imageStream = mContextInjector.getContentResolver()
                     .openInputStream(data)) {
                 fullImage = BitmapFactory.decodeStream(imageStream);
             }
             if (fullImage == null) {
                 Log.e(TAG, "Image data could not be decoded");
                 return null;
             }
             int rotation = getRotation(data);
             final int squareSize = Math.min(fullImage.getWidth(),
                     fullImage.getHeight());
             final int left = (fullImage.getWidth() - squareSize) / 2;
             final int top = (fullImage.getHeight() - squareSize) / 2;

             Matrix matrix = new Matrix();
             RectF rectSource = new RectF(left, top,
                     left + squareSize, top + squareSize);
             RectF rectDest = new RectF(0, 0, mPhotoSize, mPhotoSize);
             matrix.setRectToRect(rectSource, rectDest, Matrix.ScaleToFit.CENTER);
             matrix.postRotate(rotation, mPhotoSize / 2f, mPhotoSize / 2f);
             canvas.drawBitmap(fullImage, matrix, new Paint());
             saveBitmapToFile(croppedImage, new File(mImagesDir, CROP_PICTURE_FILE_NAME));
             return croppedImage;
         });
         Futures.addCallback(future, new FutureCallback<>() {
             @Override
             public void onSuccess(@Nullable Bitmap result) {
                 if (result != null) {
                     mAvatarUi.returnUriResult(mCropPictureUri);
                 }
             }

             @Override
             public void onFailure(Throwable t) {
                 Log.e(TAG, "Error performing internal crop", t);
             }
         }, mContextInjector.getContext().getMainExecutor());
     }

     /**
      * Reads the image's exif data and determines the rotation degree needed to display the image
      * in portrait mode.
      */
     private int getRotation(Uri selectedImage) {
         int rotation = -1;
         try {
             InputStream imageStream =
                     mContextInjector.getContentResolver().openInputStream(selectedImage);
             ExifInterface exif = new ExifInterface(imageStream);
             rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
         } catch (IOException exception) {
             Log.e(TAG, "Error while getting rotation", exception);
         }

         switch (rotation) {
             case ExifInterface.ORIENTATION_ROTATE_90:
                 return 90;
             case ExifInterface.ORIENTATION_ROTATE_180:
                 return 180;
             case ExifInterface.ORIENTATION_ROTATE_270:
                 return 270;
             default:
                 return 0;
         }
     }

     private void saveBitmapToFile(Bitmap bitmap, File file) {
         try {
             OutputStream os = new FileOutputStream(file);
             bitmap.compress(Bitmap.CompressFormat.PNG, 100, os);
             os.flush();
             os.close();
         } catch (IOException e) {
             Log.e(TAG, "Cannot create temp file", e);
         }
     }

     static class AvatarUiImpl implements AvatarUi {
         private final AvatarPickerActivity mActivity;

         AvatarUiImpl(AvatarPickerActivity activity) {
             mActivity = activity;
         }

         @Override
         public boolean isFinishing() {
             return mActivity.isFinishing() || mActivity.isDestroyed();
         }

         @Override
         public void returnUriResult(Uri uri) {
             mActivity.returnUriResult(uri);
         }

         @Override
         public void startActivityForResult(Intent intent, int resultCode) {
             mActivity.startActivityForResult(intent, resultCode);
         }

         @Override
         public boolean startSystemActivityForResult(Intent intent, int code) {
             List<ResolveInfo> resolveInfos = mActivity.getPackageManager()
                     .queryIntentActivities(intent, PackageManager.MATCH_SYSTEM_ONLY);
             if (resolveInfos.isEmpty()) {
                 Log.w(TAG, "No system package activity could be found for code " + code);
                 return false;
             }
             intent.setPackage(resolveInfos.get(0).activityInfo.packageName);
             mActivity.startActivityForResult(intent, code);
             return true;
         }

         @Override
         public int getPhotoSize() {
             return mActivity.getResources()
                     .getDimensionPixelSize(com.android.internal.R.dimen.user_icon_size);
         }
     }

     static class ContextInjectorImpl implements ContextInjector {
         private final Context mContext;
         private final String mFileAuthority;

         ContextInjectorImpl(Context context, String fileAuthority) {
             mContext = context;
             mFileAuthority = fileAuthority;
         }

         @Override
         public File getCacheDir() {
             return mContext.getCacheDir();
         }

         @Override
         public Uri createTempImageUri(File parentDir, String fileName, boolean purge) {
             final File fullPath = new File(parentDir, fileName);
             if (purge) {
                 fullPath.delete();
             }
             return FileProvider.getUriForFile(mContext, mFileAuthority, fullPath);
         }

         @Override
         public ContentResolver getContentResolver() {
             return mContext.getContentResolver();
         }

         @Override
         public Context getContext() {
             return mContext;
         }
     }
 }
	/*
	* Copyright (C) 2022 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.settingslib.avatarpicker;

	import android.app.Activity;
	import android.content.ClipData;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.PackageManager;
	import android.content.pm.ResolveInfo;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Canvas;
	import android.graphics.Matrix;
	import android.graphics.Paint;
	import android.graphics.RectF;
	import android.media.ExifInterface;
	import android.net.Uri;
	import android.os.StrictMode;
	import android.provider.MediaStore;
	import android.util.EventLog;
	import android.util.Log;

	import androidx.annotation.Nullable;
	import androidx.core.content.FileProvider;

	import com.google.common.util.concurrent.FutureCallback;
	import com.google.common.util.concurrent.Futures;
	import com.google.common.util.concurrent.ListenableFuture;

	import libcore.io.Streams;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.List;

	class AvatarPhotoController {

	interface AvatarUi {
	boolean isFinishing();

	void returnUriResult(Uri uri);

	void startActivityForResult(Intent intent, int resultCode);

	boolean startSystemActivityForResult(Intent intent, int resultCode);

	int getPhotoSize();
	}

	interface ContextInjector {
	File getCacheDir();

	Uri createTempImageUri(File parentDir, String fileName, boolean purge);

	ContentResolver getContentResolver();

	Context getContext();
	}

	private static final String TAG = "AvatarPhotoController";

	static final int REQUEST_CODE_CHOOSE_PHOTO = 1001;
	static final int REQUEST_CODE_TAKE_PHOTO = 1002;
	static final int REQUEST_CODE_CROP_PHOTO = 1003;

	/**
	* Delay to allow the photo picker exit animation to complete before the crop activity opens.
	*/
	private static final long DELAY_BEFORE_CROP_MILLIS = 150;

	private static final String IMAGES_DIR = "multi_user";
	private static final String PRE_CROP_PICTURE_FILE_NAME = "PreCropEditUserPhoto.jpg";
	private static final String CROP_PICTURE_FILE_NAME = "CropEditUserPhoto.jpg";
	private static final String TAKE_PICTURE_FILE_NAME = "TakeEditUserPhoto.jpg";

	private final int mPhotoSize;

	private final AvatarUi mAvatarUi;
	private final ContextInjector mContextInjector;

	private final File mImagesDir;
	private final Uri mPreCropPictureUri;
	private final Uri mCropPictureUri;
	private final Uri mTakePictureUri;

	AvatarPhotoController(AvatarUi avatarUi, ContextInjector contextInjector, boolean waiting) {
	mAvatarUi = avatarUi;
	mContextInjector = contextInjector;

	mImagesDir = new File(mContextInjector.getCacheDir(), IMAGES_DIR);
	mImagesDir.mkdir();
	mPreCropPictureUri = mContextInjector
	.createTempImageUri(mImagesDir, PRE_CROP_PICTURE_FILE_NAME, !waiting);
	mCropPictureUri =
	mContextInjector.createTempImageUri(mImagesDir, CROP_PICTURE_FILE_NAME, !waiting);
	mTakePictureUri =
	mContextInjector.createTempImageUri(mImagesDir, TAKE_PICTURE_FILE_NAME, !waiting);
	mPhotoSize = mAvatarUi.getPhotoSize();
	}

	/**
	* Handles activity result from containing activity/fragment after a take/choose/crop photo
	* action result is received.
	*/
	public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
	if (resultCode != Activity.RESULT_OK) {
	return false;
	}
	final Uri pictureUri = data != null && data.getData() != null
	? data.getData() : mTakePictureUri;

	// Check if the result is a content uri
	if (!ContentResolver.SCHEME_CONTENT.equals(pictureUri.getScheme())) {
	Log.e(TAG, "Invalid pictureUri scheme: " + pictureUri.getScheme());
	EventLog.writeEvent(0x534e4554, "172939189", -1, pictureUri.getPath());
	return false;
	}

	switch (requestCode) {
	case REQUEST_CODE_CROP_PHOTO:
	mAvatarUi.returnUriResult(pictureUri);
	return true;
	case REQUEST_CODE_TAKE_PHOTO:
	if (mTakePictureUri.equals(pictureUri)) {
	cropPhoto(pictureUri);
	} else {
	copyAndCropPhoto(pictureUri, false);
	}
	return true;
	case REQUEST_CODE_CHOOSE_PHOTO:
	copyAndCropPhoto(pictureUri, true);
	return true;
	}
	return false;
	}

	void takePhoto() {
	Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE_SECURE);
	appendOutputExtra(intent, mTakePictureUri);
	mAvatarUi.startActivityForResult(intent, REQUEST_CODE_TAKE_PHOTO);
	}

	void choosePhoto() {
	Intent intent = new Intent(MediaStore.ACTION_PICK_IMAGES, null);
	intent.setType("image/*");
	mAvatarUi.startActivityForResult(intent, REQUEST_CODE_CHOOSE_PHOTO);
	}

	private void copyAndCropPhoto(final Uri pictureUri, boolean delayBeforeCrop) {
	ListenableFuture<Uri> future = ThreadUtils.getBackgroundExecutor().submit(() -> {
	final ContentResolver cr = mContextInjector.getContentResolver();
	try {
	InputStream in = cr.openInputStream(pictureUri);
	OutputStream out = cr.openOutputStream(mPreCropPictureUri);
	Streams.copy(in, out);
	return mPreCropPictureUri;
	} catch (IOException e) {
	Log.w(TAG, "Failed to copy photo", e);
	return null;
	}
	});
	Futures.addCallback(future, new FutureCallback<>() {
	@Override
	public void onSuccess(@Nullable Uri result) {
	if (result == null) {
	return;
	}
	Runnable cropRunnable = () -> {
	if (!mAvatarUi.isFinishing()) {
	cropPhoto(mPreCropPictureUri);
	}
	};
	if (delayBeforeCrop) {
	mContextInjector.getContext().getMainThreadHandler()
	.postDelayed(cropRunnable, DELAY_BEFORE_CROP_MILLIS);
	} else {
	cropRunnable.run();
	}
	}

	@Override
	public void onFailure(Throwable t) {
	Log.e(TAG, "Error performing copy-and-crop", t);
	}
	}, mContextInjector.getContext().getMainExecutor());
	}

	private void cropPhoto(final Uri pictureUri) {
	// TODO: Use a public intent, when there is one.
	Intent intent = new Intent("com.android.camera.action.CROP");
	intent.setDataAndType(pictureUri, "image/*");
	appendOutputExtra(intent, mCropPictureUri);
	appendCropExtras(intent);
	try {
	StrictMode.disableDeathOnFileUriExposure();
	if (mAvatarUi.startSystemActivityForResult(intent, REQUEST_CODE_CROP_PHOTO)) {
	return;
	}
	} finally {
	StrictMode.enableDeathOnFileUriExposure();
	}
	onPhotoNotCropped(pictureUri);
	}

	private void appendOutputExtra(Intent intent, Uri pictureUri) {
	intent.putExtra(MediaStore.EXTRA_OUTPUT, pictureUri);
	intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION
	\| Intent.FLAG_GRANT_READ_URI_PERMISSION);
	intent.setClipData(ClipData.newRawUri(MediaStore.EXTRA_OUTPUT, pictureUri));
	}

	private void appendCropExtras(Intent intent) {
	intent.putExtra("crop", "true");
	intent.putExtra("scale", true);
	intent.putExtra("scaleUpIfNeeded", true);
	intent.putExtra("aspectX", 1);
	intent.putExtra("aspectY", 1);
	intent.putExtra("outputX", mPhotoSize);
	intent.putExtra("outputY", mPhotoSize);
	}

	private void onPhotoNotCropped(final Uri data) {
	ListenableFuture<Bitmap> future = ThreadUtils.getBackgroundExecutor().submit(() -> {
	// Scale and crop to a square aspect ratio
	Bitmap croppedImage = Bitmap.createBitmap(mPhotoSize, mPhotoSize,
	Bitmap.Config.ARGB_8888);
	Canvas canvas = new Canvas(croppedImage);
	Bitmap fullImage;
	try (InputStream imageStream = mContextInjector.getContentResolver()
	.openInputStream(data)) {
	fullImage = BitmapFactory.decodeStream(imageStream);
	}
	if (fullImage == null) {
	Log.e(TAG, "Image data could not be decoded");
	return null;
	}
	int rotation = getRotation(data);
	final int squareSize = Math.min(fullImage.getWidth(),
	fullImage.getHeight());
	final int left = (fullImage.getWidth() - squareSize) / 2;
	final int top = (fullImage.getHeight() - squareSize) / 2;

	Matrix matrix = new Matrix();
	RectF rectSource = new RectF(left, top,
	left + squareSize, top + squareSize);
	RectF rectDest = new RectF(0, 0, mPhotoSize, mPhotoSize);
	matrix.setRectToRect(rectSource, rectDest, Matrix.ScaleToFit.CENTER);
	matrix.postRotate(rotation, mPhotoSize / 2f, mPhotoSize / 2f);
	canvas.drawBitmap(fullImage, matrix, new Paint());
	saveBitmapToFile(croppedImage, new File(mImagesDir, CROP_PICTURE_FILE_NAME));
	return croppedImage;
	});
	Futures.addCallback(future, new FutureCallback<>() {
	@Override
	public void onSuccess(@Nullable Bitmap result) {
	if (result != null) {
	mAvatarUi.returnUriResult(mCropPictureUri);
	}
	}

	@Override
	public void onFailure(Throwable t) {
	Log.e(TAG, "Error performing internal crop", t);
	}
	}, mContextInjector.getContext().getMainExecutor());
	}

	/**
	* Reads the image's exif data and determines the rotation degree needed to display the image
	* in portrait mode.
	*/
	private int getRotation(Uri selectedImage) {
	int rotation = -1;
	try {
	InputStream imageStream =
	mContextInjector.getContentResolver().openInputStream(selectedImage);
	ExifInterface exif = new ExifInterface(imageStream);
	rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
	} catch (IOException exception) {
	Log.e(TAG, "Error while getting rotation", exception);
	}

	switch (rotation) {
	case ExifInterface.ORIENTATION_ROTATE_90:
	return 90;
	case ExifInterface.ORIENTATION_ROTATE_180:
	return 180;
	case ExifInterface.ORIENTATION_ROTATE_270:
	return 270;
	default:
	return 0;
	}
	}

	private void saveBitmapToFile(Bitmap bitmap, File file) {
	try {
	OutputStream os = new FileOutputStream(file);
	bitmap.compress(Bitmap.CompressFormat.PNG, 100, os);
	os.flush();
	os.close();
	} catch (IOException e) {
	Log.e(TAG, "Cannot create temp file", e);
	}
	}

	static class AvatarUiImpl implements AvatarUi {
	private final AvatarPickerActivity mActivity;

	AvatarUiImpl(AvatarPickerActivity activity) {
	mActivity = activity;
	}

	@Override
	public boolean isFinishing() {
	return mActivity.isFinishing() \|\| mActivity.isDestroyed();
	}

	@Override
	public void returnUriResult(Uri uri) {
	mActivity.returnUriResult(uri);
	}

	@Override
	public void startActivityForResult(Intent intent, int resultCode) {
	mActivity.startActivityForResult(intent, resultCode);
	}

	@Override
	public boolean startSystemActivityForResult(Intent intent, int code) {
	List<ResolveInfo> resolveInfos = mActivity.getPackageManager()
	.queryIntentActivities(intent, PackageManager.MATCH_SYSTEM_ONLY);
	if (resolveInfos.isEmpty()) {
	Log.w(TAG, "No system package activity could be found for code " + code);
	return false;
	}
	intent.setPackage(resolveInfos.get(0).activityInfo.packageName);
	mActivity.startActivityForResult(intent, code);
	return true;
	}

	@Override
	public int getPhotoSize() {
	return mActivity.getResources()
	.getDimensionPixelSize(com.android.internal.R.dimen.user_icon_size);
	}
	}

	static class ContextInjectorImpl implements ContextInjector {
	private final Context mContext;
	private final String mFileAuthority;

	ContextInjectorImpl(Context context, String fileAuthority) {
	mContext = context;
	mFileAuthority = fileAuthority;
	}

	@Override
	public File getCacheDir() {
	return mContext.getCacheDir();
	}

	@Override
	public Uri createTempImageUri(File parentDir, String fileName, boolean purge) {
	final File fullPath = new File(parentDir, fileName);
	if (purge) {
	fullPath.delete();
	}
	return FileProvider.getUriForFile(mContext, mFileAuthority, fullPath);
	}

	@Override
	public ContentResolver getContentResolver() {
	return mContext.getContentResolver();
	}

	@Override
	public Context getContext() {
	return mContext;
	}
	}
	}