Unbundling task for SharedMinimal.java (0bd7736c) · Commits · e / os / android_packages_apps_DocumentsUI

src/com/android/documentsui/base/SharedMinimal.java

+0 −210

Original line number	Diff line number	Diff line
		@@ -16,31 +16,9 @@

		package com.android.documentsui.base;

		import static android.os.Environment.isStandardDirectory;

		import static com.android.documentsui.ScopedAccessMetrics.SCOPED_DIRECTORY_ACCESS_ERROR;
		import static com.android.documentsui.ScopedAccessMetrics.SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY;
		import static com.android.documentsui.ScopedAccessMetrics.logInvalidScopedAccessRequest;

		import android.content.ContentProviderClient;
		import android.content.Context;
		import android.net.Uri;
		import android.os.Build;
		import android.os.Bundle;
		import android.os.RemoteException;
		import android.os.storage.StorageManager;
		import android.os.storage.StorageVolume;
		import android.os.storage.VolumeInfo;
		import android.provider.DocumentsContract;
		import android.text.TextUtils;
		import android.util.Log;

		import java.io.File;
		import java.io.IOException;
		import java.util.List;

		import androidx.annotation.Nullable;

		/**
		* Contains the minimum number of utilities (contants, helpers, etc...) that can be used by both the
		* main package and the minimal APK that's used by Android TV (and other devices).
		@@ -55,194 +33,6 @@ public final class SharedMinimal {
		public static final boolean DEBUG = !"user".equals(Build.TYPE);
		public static final boolean VERBOSE = DEBUG && Log.isLoggable(TAG, Log.VERBOSE);

		/**
		* Special directory name representing the full volume of a scoped directory request.
		*/
		public static final String DIRECTORY_ROOT = "ROOT_DIRECTORY";

		/**
		* Callback for {@link SharedMinimal#getUriPermission(Context, ContentProviderClient,
		* StorageVolume, String, int, boolean, GetUriPermissionCallback)}.
		*/
		public static interface GetUriPermissionCallback {

		/**
		* Evaluates the result of the request.
		*
		* @param file the path of the requested URI.
		* @param volumeLabel user-friendly label of the volume.
		* @param isRoot whether the requested directory is the root directory.
		* @param isPrimary whether the requested volume is the primary storage volume.
		* @param requestedUri the requested URI.
		* @param rootUri the URI for the volume's root directory.
		* @return whethe the result was sucessfully.
		*/
		boolean onResult(File file, String volumeLabel, boolean isRoot, boolean isPrimary,
		Uri requestedUri, Uri rootUri);
		}

		/**
		* Gets the name of a directory name in the format that's used internally by the app
		* (i.e., mapping {@code null} to {@link #DIRECTORY_ROOT});
		* if necessary.
		*/
		public static String getInternalDirectoryName(@Nullable String name) {
		return name == null ? DIRECTORY_ROOT : name;
		}

		/**
		* Gets the name of a directory name in the format that is used externally
		* (i.e., mapping {@link #DIRECTORY_ROOT} to {@code null} if necessary);
		*/
		@Nullable
		public static String getExternalDirectoryName(String name) {
		return name.equals(DIRECTORY_ROOT) ? null : name;
		}

		/**
		* Gets the URI permission for the given volume and directory.
		*
		* @param context caller's context.
		* @param storageClient storage provider client.
		* @param storageVolume volume.
		* @param directoryName directory name, or {@link #DIRECTORY_ROOT} for full volume.
		* @param userId caller's user handle.
		* @param logMetrics whether intermediate errors should be logged.
		* @param callback callback that receives the results.
		*
		* @return whether the call was succesfull or not.
		*/
		public static boolean getUriPermission(Context context,
		ContentProviderClient storageClient, StorageVolume storageVolume,
		String directoryName, int userId, boolean logMetrics,
		GetUriPermissionCallback callback) {
		if (DEBUG) {
		Log.d(TAG, "getUriPermission() for volume " + storageVolume.dump() + ", directory "
		+ directoryName + ", and user " + userId);
		}
		final boolean isRoot = directoryName.equals(DIRECTORY_ROOT);
		final boolean isPrimary = storageVolume.isPrimary();

		if (isRoot && isPrimary) {
		if (DEBUG) Log.d(TAG, "root access requested on primary volume");
		return false;
		}

		final File volumeRoot = storageVolume.getPathFile();
		File file;
		try {
		file = isRoot ? volumeRoot : new File(volumeRoot, directoryName).getCanonicalFile();
		} catch (IOException e) {
		Log.e(TAG, "Could not get canonical file for volume " + storageVolume.dump()
		+ " and directory " + directoryName);
		if (logMetrics) logInvalidScopedAccessRequest(context, SCOPED_DIRECTORY_ACCESS_ERROR);
		return false;
		}
		final StorageManager sm = context.getSystemService(StorageManager.class);

		final String root, directory;
		if (isRoot) {
		root = volumeRoot.getAbsolutePath();
		directory = ".";
		} else {
		root = file.getParent();
		directory = file.getName();
		// Verify directory is valid.
		if (TextUtils.isEmpty(directory) \|\| !isStandardDirectory(directory)) {
		if (DEBUG) {
		Log.d(TAG, "Directory '" + directory + "' is not standard (full path: '"
		+ file.getAbsolutePath() + "')");
		}
		if (logMetrics) {
		logInvalidScopedAccessRequest(context,
		SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY);
		}
		return false;
		}
		}

		// Gets volume label and converted path.
		String volumeLabel = null;
		final List<VolumeInfo> volumes = sm.getVolumes();
		if (DEBUG) Log.d(TAG, "Number of volumes: " + volumes.size());
		File internalRoot = null;
		for (VolumeInfo volume : volumes) {
		if (isRightVolume(volume, root, userId)) {
		internalRoot = volume.getInternalPathForUser(userId);
		// Must convert path before calling getDocIdForFileCreateNewDir()
		if (DEBUG) Log.d(TAG, "Converting " + root + " to " + internalRoot);
		file = isRoot ? internalRoot : new File(internalRoot, directory);
		volumeLabel = sm.getBestVolumeDescription(volume);
		if (TextUtils.isEmpty(volumeLabel)) {
		volumeLabel = storageVolume.getDescription(context);
		}
		if (TextUtils.isEmpty(volumeLabel)) {
		volumeLabel = context.getString(android.R.string.unknownName);
		Log.w(TAG, "No volume description for " + volume + "; using " + volumeLabel);
		}
		break;
		}
		}
		if (internalRoot == null) {
		// Should not happen on normal circumstances, unless app crafted an invalid volume
		// using reflection or the list of mounted volumes changed.
		Log.e(TAG, "Didn't find right volume for '" + storageVolume.dump() + "' on " + volumes);
		return false;
		}

		final Uri requestedUri = getUriPermission(context, storageClient, file);
		final Uri rootUri = internalRoot.equals(file) ? requestedUri
		: getUriPermission(context, storageClient, internalRoot);

		return callback.onResult(file, volumeLabel, isRoot, isPrimary, requestedUri, rootUri);
		}

		/**
		* Creates an URI permission for the given file.
		*/
		public static Uri getUriPermission(Context context, ContentProviderClient storageProvider,
		File file) {
		// Calls ExternalStorageProvider to get the doc id for the file
		final Bundle bundle;
		try {
		bundle = storageProvider.call("getDocIdForFileCreateNewDir", file.getPath(), null);
		} catch (RemoteException e) {
		Log.e(TAG, "Did not get doc id from External Storage provider for " + file, e);
		logInvalidScopedAccessRequest(context, SCOPED_DIRECTORY_ACCESS_ERROR);
		return null;
		}
		final String docId = bundle == null ? null : bundle.getString("DOC_ID");
		if (docId == null) {
		Log.e(TAG, "Did not get doc id from External Storage provider for " + file);
		logInvalidScopedAccessRequest(context, SCOPED_DIRECTORY_ACCESS_ERROR);
		return null;
		}
		if (DEBUG) Log.d(TAG, "doc id for " + file + ": " + docId);

		final Uri uri = DocumentsContract.buildTreeDocumentUri(Providers.AUTHORITY_STORAGE, docId);
		if (uri == null) {
		Log.e(TAG, "Could not get URI for doc id " + docId);
		return null;
		}
		if (DEBUG) Log.d(TAG, "URI for " + file + ": " + uri);
		return uri;
		}

		private static boolean isRightVolume(VolumeInfo volume, String root, int userId) {
		final File userPath = volume.getPathForUser(userId);
		final String path = userPath == null ? null : volume.getPathForUser(userId).getPath();
		final boolean isMounted = volume.isMountedReadable();
		if (DEBUG)
		Log.d(TAG, "Volume: " + volume
		+ "\n\tuserId: " + userId
		+ "\n\tuserPath: " + userPath
		+ "\n\troot: " + root
		+ "\n\tpath: " + path
		+ "\n\tisMounted: " + isMounted);

		return isMounted && root.equals(path);
		}

		private SharedMinimal() {
		throw new UnsupportedOperationException("provides static fields only");
		}