Refactor SettingsLib to remove redundant resources conditionally
Bug: 320878675
Test: manual
Change-Id: I77b3eb4cc2edbbfa6788e53004e370d49da0c0c0
diff --git a/packages/SettingsLib/AvatarPicker/src/AvatarPhotoController.java b/packages/SettingsLib/AvatarPicker/src/AvatarPhotoController.java
new file mode 100644
index 0000000..c20392a
--- /dev/null
+++ b/packages/SettingsLib/AvatarPicker/src/AvatarPhotoController.java
@@ -0,0 +1,400 @@
+/*
+ * 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;
+ }
+ }
+}