packages/DocumentsUI/src/com/android/documentsui/OpenExternalDirectoryActivity.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 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.documentsui;

 import static android.os.Environment.isStandardDirectory;
 import static android.os.Environment.STANDARD_DIRECTORIES;
 import static android.os.storage.StorageVolume.EXTRA_DIRECTORY_NAME;
 import static android.os.storage.StorageVolume.EXTRA_STORAGE_VOLUME;

 import static com.android.documentsui.LocalPreferences.getScopedAccessPermissionStatus;
 import static com.android.documentsui.LocalPreferences.PERMISSION_ASK;
 import static com.android.documentsui.LocalPreferences.PERMISSION_ASK_AGAIN;
 import static com.android.documentsui.LocalPreferences.PERMISSION_NEVER_ASK;
 import static com.android.documentsui.LocalPreferences.setScopedAccessPermissionStatus;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_DENIED;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ERROR;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_GRANTED;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS;
 import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY;
 import static com.android.documentsui.Metrics.logInvalidScopedAccessRequest;
 import static com.android.documentsui.Metrics.logValidScopedAccessRequest;
 import static com.android.documentsui.Shared.DEBUG;

 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.app.DialogFragment;
 import android.app.FragmentManager;
 import android.app.FragmentTransaction;
 import android.content.ContentProviderClient;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnClickListener;
 import android.content.Intent;
 import android.content.UriPermission;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.os.RemoteException;
 import android.os.UserHandle;
 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 android.view.View;
 import android.widget.CheckBox;
 import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
 import android.widget.TextView;

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

 /**
  * Activity responsible for handling {@link Intent#ACTION_OPEN_EXTERNAL_DOCUMENT}.
  */
 public class OpenExternalDirectoryActivity extends Activity {
     private static final String TAG = "OpenExternalDirectory";
     private static final String FM_TAG = "open_external_directory";
     private static final String EXTERNAL_STORAGE_AUTH = "com.android.externalstorage.documents";
     private static final String EXTRA_FILE = "com.android.documentsui.FILE";
     private static final String EXTRA_APP_LABEL = "com.android.documentsui.APP_LABEL";
     private static final String EXTRA_VOLUME_LABEL = "com.android.documentsui.VOLUME_LABEL";
     private static final String EXTRA_VOLUME_UUID = "com.android.documentsui.VOLUME_UUID";
     private static final String EXTRA_IS_ROOT = "com.android.documentsui.IS_ROOT";
     private static final String EXTRA_IS_PRIMARY = "com.android.documentsui.IS_PRIMARY";
     // Special directory name representing the full volume
     static final String DIRECTORY_ROOT = "ROOT_DIRECTORY";

     private ContentProviderClient mExternalStorageClient;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         if (savedInstanceState != null) {
             if (DEBUG) Log.d(TAG, "activity.onCreateDialog(): reusing instance");
             return;
         }

         final Intent intent = getIntent();
         if (intent == null) {
             if (DEBUG) Log.d(TAG, "missing intent");
             logInvalidScopedAccessRequest(this, SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS);
             setResult(RESULT_CANCELED);
             finish();
             return;
         }
         final Parcelable storageVolume = intent.getParcelableExtra(EXTRA_STORAGE_VOLUME);
         if (!(storageVolume instanceof StorageVolume)) {
             if (DEBUG)
                 Log.d(TAG, "extra " + EXTRA_STORAGE_VOLUME + " is not a StorageVolume: "
                         + storageVolume);
             logInvalidScopedAccessRequest(this, SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS);
             setResult(RESULT_CANCELED);
             finish();
             return;
         }
         String directoryName = intent.getStringExtra(EXTRA_DIRECTORY_NAME );
         if (directoryName == null) {
             directoryName = DIRECTORY_ROOT;
         }
         final StorageVolume volume = (StorageVolume) storageVolume;
         if (getScopedAccessPermissionStatus(getApplicationContext(), getCallingPackage(),
                 volume.getUuid(), directoryName) == PERMISSION_NEVER_ASK) {
             logValidScopedAccessRequest(this, directoryName,
                     SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED);
             setResult(RESULT_CANCELED);
             finish();
             return;
         }

         final int userId = UserHandle.myUserId();
         if (!showFragment(this, userId, volume, directoryName)) {
             setResult(RESULT_CANCELED);
             finish();
             return;
         }
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         if (mExternalStorageClient != null) {
             mExternalStorageClient.close();
         }
     }

     /**
      * Validates the given path (volume + directory) and display the appropriate dialog asking the
      * user to grant access to it.
      */
     private static boolean showFragment(OpenExternalDirectoryActivity activity, int userId,
             StorageVolume storageVolume, String directoryName) {
         if (DEBUG)
             Log.d(TAG, "showFragment() 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);
             logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
             return false;
         }
         final StorageManager sm =
                 (StorageManager) activity.getSystemService(Context.STORAGE_SERVICE);

         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() + "')");
                 logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY);
                 return false;
             }
         }

         // Gets volume label and converted path.
         String volumeLabel = null;
         String volumeUuid = null;
         final List<VolumeInfo> volumes = sm.getVolumes();
         if (DEBUG) Log.d(TAG, "Number of volumes: " + volumes.size());
         File internalRoot = null;
         boolean found = true;
         for (VolumeInfo volume : volumes) {
             if (isRightVolume(volume, root, userId)) {
                 found = true;
                 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);
                 volumeUuid = storageVolume.getUuid();
                 volumeLabel = sm.getBestVolumeDescription(volume);
                 if (TextUtils.isEmpty(volumeLabel)) {
                     volumeLabel = storageVolume.getDescription(activity);
                 }
                 if (TextUtils.isEmpty(volumeLabel)) {
                     volumeLabel = activity.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;
         }

         // Checks if the user has granted the permission already.
         final Intent intent = getIntentForExistingPermission(activity, isRoot, internalRoot, file);
         if (intent != null) {
             logValidScopedAccessRequest(activity, directory,
                     SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED);
             activity.setResult(RESULT_OK, intent);
             activity.finish();
             return true;
         }

         if (!found) {
             Log.e(TAG, "Could not get volume for " + file);
             logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
             return false;
         }

         // Gets the package label.
         final String appLabel = getAppLabel(activity);
         if (appLabel == null) {
             // Error already logged.
             return false;
         }

         // Sets args that will be retrieve on onCreate()
         final Bundle args = new Bundle();
         args.putString(EXTRA_FILE, file.getAbsolutePath());
         args.putString(EXTRA_VOLUME_LABEL, volumeLabel);
         args.putString(EXTRA_VOLUME_UUID, volumeUuid);
         args.putString(EXTRA_APP_LABEL, appLabel);
         args.putBoolean(EXTRA_IS_ROOT, isRoot);
         args.putBoolean(EXTRA_IS_PRIMARY, isPrimary);

         final FragmentManager fm = activity.getFragmentManager();
         final FragmentTransaction ft = fm.beginTransaction();
         final OpenExternalDirectoryDialogFragment fragment =
                 new OpenExternalDirectoryDialogFragment();
         fragment.setArguments(args);
         ft.add(fragment, FM_TAG);
         ft.commitAllowingStateLoss();

         return true;
     }

     private static String getAppLabel(Activity activity) {
         final String packageName = activity.getCallingPackage();
         final PackageManager pm = activity.getPackageManager();
         try {
             return pm.getApplicationLabel(pm.getApplicationInfo(packageName, 0)).toString();
         } catch (NameNotFoundException e) {
             logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
             Log.w(TAG, "Could not get label for package " + packageName);
             return null;
         }
     }

     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 static Uri getGrantedUriPermission(Context context, ContentProviderClient provider,
             File file) {
         // Calls ExternalStorageProvider to get the doc id for the file
         final Bundle bundle;
         try {
             bundle = provider.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(EXTERNAL_STORAGE_AUTH, 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 Intent createGrantedUriPermissionsIntent(Context context,
             ContentProviderClient provider, File file) {
         final Uri uri = getGrantedUriPermission(context, provider, file);
         return createGrantedUriPermissionsIntent(uri);
     }

     private static Intent createGrantedUriPermissionsIntent(Uri uri) {
         final Intent intent = new Intent();
         intent.setData(uri);
         intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
                 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
                 | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
                 | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION);
         return intent;
     }

     private static Intent getIntentForExistingPermission(OpenExternalDirectoryActivity activity,
             boolean isRoot, File root, File file) {
         final String packageName = activity.getCallingPackage();
         final ContentProviderClient storageClient = activity.getExternalStorageClient();
         final Uri grantedUri = getGrantedUriPermission(activity, storageClient, file);
         final Uri rootUri = root.equals(file) ? grantedUri
                 : getGrantedUriPermission(activity, storageClient, root);

         if (DEBUG)
             Log.d(TAG, "checking if " + packageName + " already has permission for " + grantedUri
                     + " or its root (" + rootUri + ")");
         final ActivityManager am =
                 (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);
         for (UriPermission uriPermission : am.getGrantedUriPermissions(packageName).getList()) {
             final Uri uri = uriPermission.getUri();
             if (uri == null) {
                 Log.w(TAG, "null URI for " + uriPermission);
                 continue;
             }
             if (uri.equals(grantedUri) || uri.equals(rootUri)) {
                 if (DEBUG) Log.d(TAG, packageName + " already has permission: " + uriPermission);
                 return createGrantedUriPermissionsIntent(grantedUri);
             }
         }
         if (DEBUG) Log.d(TAG, packageName + " does not have permission for " + grantedUri);
         return null;
     }

     public static class OpenExternalDirectoryDialogFragment extends DialogFragment {

         private File mFile;
         private String mVolumeUuid;
         private String mVolumeLabel;
         private String mAppLabel;
         private boolean mIsRoot;
         private boolean mIsPrimary;
         private CheckBox mDontAskAgain;
         private OpenExternalDirectoryActivity mActivity;
         private AlertDialog mDialog;

         @Override
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
             setRetainInstance(true);
             final Bundle args = getArguments();
             if (args != null) {
                 mFile = new File(args.getString(EXTRA_FILE));
                 mVolumeUuid = args.getString(EXTRA_VOLUME_UUID);
                 mVolumeLabel = args.getString(EXTRA_VOLUME_LABEL);
                 mAppLabel = args.getString(EXTRA_APP_LABEL);
                 mIsRoot = args.getBoolean(EXTRA_IS_ROOT);
                 mIsPrimary= args.getBoolean(EXTRA_IS_PRIMARY);
             }
             mActivity = (OpenExternalDirectoryActivity) getActivity();
         }

         @Override
         public void onDestroyView() {
             // Workaround for https://code.google.com/p/android/issues/detail?id=17423
             if (mDialog != null && getRetainInstance()) {
                 mDialog.setDismissMessage(null);
             }
             super.onDestroyView();
         }

         @Override
         public Dialog onCreateDialog(Bundle savedInstanceState) {
             if (mDialog != null) {
                 if (DEBUG) Log.d(TAG, "fragment.onCreateDialog(): reusing dialog");
                 return mDialog;
             }
             if (mActivity != getActivity()) {
                 // Sanity check.
                 Log.wtf(TAG, "activity references don't match on onCreateDialog(): mActivity = "
                         + mActivity + " , getActivity() = " + getActivity());
                 mActivity = (OpenExternalDirectoryActivity) getActivity();
             }
             final String directory = mFile.getName();
             final String directoryName = mIsRoot ? DIRECTORY_ROOT : directory;
             final Context context = mActivity.getApplicationContext();
             final OnClickListener listener = new OnClickListener() {

                 @Override
                 public void onClick(DialogInterface dialog, int which) {
                     Intent intent = null;
                     if (which == DialogInterface.BUTTON_POSITIVE) {
                         intent = createGrantedUriPermissionsIntent(mActivity,
                                 mActivity.getExternalStorageClient(), mFile);
                     }
                     if (which == DialogInterface.BUTTON_NEGATIVE || intent == null) {
                         logValidScopedAccessRequest(mActivity, directoryName,
                                 SCOPED_DIRECTORY_ACCESS_DENIED);
                         final boolean checked = mDontAskAgain.isChecked();
                         if (checked) {
                             logValidScopedAccessRequest(mActivity, directory,
                                     SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST);
                             setScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
                                     mVolumeUuid, directoryName, PERMISSION_NEVER_ASK);
                         } else {
                             setScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
                                     mVolumeUuid, directoryName, PERMISSION_ASK_AGAIN);
                         }
                         mActivity.setResult(RESULT_CANCELED);
                     } else {
                         logValidScopedAccessRequest(mActivity, directory,
                                 SCOPED_DIRECTORY_ACCESS_GRANTED);
                         mActivity.setResult(RESULT_OK, intent);
                     }
                     mActivity.finish();
                 }
             };

             @SuppressLint("InflateParams")
             // It's ok pass null ViewRoot on AlertDialogs.
             final View view = View.inflate(mActivity, R.layout.dialog_open_scoped_directory, null);
             final CharSequence message;
             if (mIsRoot) {
                 message = TextUtils.expandTemplate(getText(
                         R.string.open_external_dialog_root_request), mAppLabel, mVolumeLabel);
             } else {
                 message = TextUtils.expandTemplate(
                         getText(mIsPrimary ? R.string.open_external_dialog_request_primary_volume
                                 : R.string.open_external_dialog_request),
                                 mAppLabel, directory, mVolumeLabel);
             }
             final TextView messageField = (TextView) view.findViewById(R.id.message);
             messageField.setText(message);
             mDialog = new AlertDialog.Builder(mActivity, R.style.Theme_AppCompat_Light_Dialog_Alert)
                     .setView(view)
                     .setPositiveButton(R.string.allow, listener)
                     .setNegativeButton(R.string.deny, listener)
                     .create();

             mDontAskAgain = (CheckBox) view.findViewById(R.id.do_not_ask_checkbox);
             if (getScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
                     mVolumeUuid, directoryName) == PERMISSION_ASK_AGAIN) {
                 mDontAskAgain.setVisibility(View.VISIBLE);
                 mDontAskAgain.setOnCheckedChangeListener(new OnCheckedChangeListener() {

                     @Override
                     public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                         mDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(!isChecked);
                     }
                 });
             }

             return mDialog;
         }

         @Override
         public void onCancel(DialogInterface dialog) {
             super.onCancel(dialog);
             final Activity activity = getActivity();
             logValidScopedAccessRequest(activity, mFile.getName(), SCOPED_DIRECTORY_ACCESS_DENIED);
             activity.setResult(RESULT_CANCELED);
             activity.finish();
         }
     }

     private synchronized ContentProviderClient getExternalStorageClient() {
         if (mExternalStorageClient == null) {
             mExternalStorageClient =
                     getContentResolver().acquireContentProviderClient(EXTERNAL_STORAGE_AUTH);
         }
         return mExternalStorageClient;
     }
 }
	/*
	* Copyright (C) 2016 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.documentsui;

	import static android.os.Environment.isStandardDirectory;
	import static android.os.Environment.STANDARD_DIRECTORIES;
	import static android.os.storage.StorageVolume.EXTRA_DIRECTORY_NAME;
	import static android.os.storage.StorageVolume.EXTRA_STORAGE_VOLUME;

	import static com.android.documentsui.LocalPreferences.getScopedAccessPermissionStatus;
	import static com.android.documentsui.LocalPreferences.PERMISSION_ASK;
	import static com.android.documentsui.LocalPreferences.PERMISSION_ASK_AGAIN;
	import static com.android.documentsui.LocalPreferences.PERMISSION_NEVER_ASK;
	import static com.android.documentsui.LocalPreferences.setScopedAccessPermissionStatus;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_DENIED;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_ERROR;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_GRANTED;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS;
	import static com.android.documentsui.Metrics.SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY;
	import static com.android.documentsui.Metrics.logInvalidScopedAccessRequest;
	import static com.android.documentsui.Metrics.logValidScopedAccessRequest;
	import static com.android.documentsui.Shared.DEBUG;

	import android.annotation.SuppressLint;
	import android.app.Activity;
	import android.app.ActivityManager;
	import android.app.AlertDialog;
	import android.app.Dialog;
	import android.app.DialogFragment;
	import android.app.FragmentManager;
	import android.app.FragmentTransaction;
	import android.content.ContentProviderClient;
	import android.content.Context;
	import android.content.DialogInterface;
	import android.content.DialogInterface.OnClickListener;
	import android.content.Intent;
	import android.content.UriPermission;
	import android.content.pm.PackageManager;
	import android.content.pm.PackageManager.NameNotFoundException;
	import android.net.Uri;
	import android.os.Bundle;
	import android.os.Parcelable;
	import android.os.RemoteException;
	import android.os.UserHandle;
	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 android.view.View;
	import android.widget.CheckBox;
	import android.widget.CompoundButton;
	import android.widget.CompoundButton.OnCheckedChangeListener;
	import android.widget.TextView;

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

	/**
	* Activity responsible for handling {@link Intent#ACTION_OPEN_EXTERNAL_DOCUMENT}.
	*/
	public class OpenExternalDirectoryActivity extends Activity {
	private static final String TAG = "OpenExternalDirectory";
	private static final String FM_TAG = "open_external_directory";
	private static final String EXTERNAL_STORAGE_AUTH = "com.android.externalstorage.documents";
	private static final String EXTRA_FILE = "com.android.documentsui.FILE";
	private static final String EXTRA_APP_LABEL = "com.android.documentsui.APP_LABEL";
	private static final String EXTRA_VOLUME_LABEL = "com.android.documentsui.VOLUME_LABEL";
	private static final String EXTRA_VOLUME_UUID = "com.android.documentsui.VOLUME_UUID";
	private static final String EXTRA_IS_ROOT = "com.android.documentsui.IS_ROOT";
	private static final String EXTRA_IS_PRIMARY = "com.android.documentsui.IS_PRIMARY";
	// Special directory name representing the full volume
	static final String DIRECTORY_ROOT = "ROOT_DIRECTORY";

	private ContentProviderClient mExternalStorageClient;

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	if (savedInstanceState != null) {
	if (DEBUG) Log.d(TAG, "activity.onCreateDialog(): reusing instance");
	return;
	}

	final Intent intent = getIntent();
	if (intent == null) {
	if (DEBUG) Log.d(TAG, "missing intent");
	logInvalidScopedAccessRequest(this, SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS);
	setResult(RESULT_CANCELED);
	finish();
	return;
	}
	final Parcelable storageVolume = intent.getParcelableExtra(EXTRA_STORAGE_VOLUME);
	if (!(storageVolume instanceof StorageVolume)) {
	if (DEBUG)
	Log.d(TAG, "extra " + EXTRA_STORAGE_VOLUME + " is not a StorageVolume: "
	+ storageVolume);
	logInvalidScopedAccessRequest(this, SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS);
	setResult(RESULT_CANCELED);
	finish();
	return;
	}
	String directoryName = intent.getStringExtra(EXTRA_DIRECTORY_NAME );
	if (directoryName == null) {
	directoryName = DIRECTORY_ROOT;
	}
	final StorageVolume volume = (StorageVolume) storageVolume;
	if (getScopedAccessPermissionStatus(getApplicationContext(), getCallingPackage(),
	volume.getUuid(), directoryName) == PERMISSION_NEVER_ASK) {
	logValidScopedAccessRequest(this, directoryName,
	SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED);
	setResult(RESULT_CANCELED);
	finish();
	return;
	}

	final int userId = UserHandle.myUserId();
	if (!showFragment(this, userId, volume, directoryName)) {
	setResult(RESULT_CANCELED);
	finish();
	return;
	}
	}

	@Override
	public void onDestroy() {
	super.onDestroy();
	if (mExternalStorageClient != null) {
	mExternalStorageClient.close();
	}
	}

	/**
	* Validates the given path (volume + directory) and display the appropriate dialog asking the
	* user to grant access to it.
	*/
	private static boolean showFragment(OpenExternalDirectoryActivity activity, int userId,
	StorageVolume storageVolume, String directoryName) {
	if (DEBUG)
	Log.d(TAG, "showFragment() 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);
	logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
	return false;
	}
	final StorageManager sm =
	(StorageManager) activity.getSystemService(Context.STORAGE_SERVICE);

	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() + "')");
	logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY);
	return false;
	}
	}

	// Gets volume label and converted path.
	String volumeLabel = null;
	String volumeUuid = null;
	final List<VolumeInfo> volumes = sm.getVolumes();
	if (DEBUG) Log.d(TAG, "Number of volumes: " + volumes.size());
	File internalRoot = null;
	boolean found = true;
	for (VolumeInfo volume : volumes) {
	if (isRightVolume(volume, root, userId)) {
	found = true;
	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);
	volumeUuid = storageVolume.getUuid();
	volumeLabel = sm.getBestVolumeDescription(volume);
	if (TextUtils.isEmpty(volumeLabel)) {
	volumeLabel = storageVolume.getDescription(activity);
	}
	if (TextUtils.isEmpty(volumeLabel)) {
	volumeLabel = activity.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;
	}

	// Checks if the user has granted the permission already.
	final Intent intent = getIntentForExistingPermission(activity, isRoot, internalRoot, file);
	if (intent != null) {
	logValidScopedAccessRequest(activity, directory,
	SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED);
	activity.setResult(RESULT_OK, intent);
	activity.finish();
	return true;
	}

	if (!found) {
	Log.e(TAG, "Could not get volume for " + file);
	logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
	return false;
	}

	// Gets the package label.
	final String appLabel = getAppLabel(activity);
	if (appLabel == null) {
	// Error already logged.
	return false;
	}

	// Sets args that will be retrieve on onCreate()
	final Bundle args = new Bundle();
	args.putString(EXTRA_FILE, file.getAbsolutePath());
	args.putString(EXTRA_VOLUME_LABEL, volumeLabel);
	args.putString(EXTRA_VOLUME_UUID, volumeUuid);
	args.putString(EXTRA_APP_LABEL, appLabel);
	args.putBoolean(EXTRA_IS_ROOT, isRoot);
	args.putBoolean(EXTRA_IS_PRIMARY, isPrimary);

	final FragmentManager fm = activity.getFragmentManager();
	final FragmentTransaction ft = fm.beginTransaction();
	final OpenExternalDirectoryDialogFragment fragment =
	new OpenExternalDirectoryDialogFragment();
	fragment.setArguments(args);
	ft.add(fragment, FM_TAG);
	ft.commitAllowingStateLoss();

	return true;
	}

	private static String getAppLabel(Activity activity) {
	final String packageName = activity.getCallingPackage();
	final PackageManager pm = activity.getPackageManager();
	try {
	return pm.getApplicationLabel(pm.getApplicationInfo(packageName, 0)).toString();
	} catch (NameNotFoundException e) {
	logInvalidScopedAccessRequest(activity, SCOPED_DIRECTORY_ACCESS_ERROR);
	Log.w(TAG, "Could not get label for package " + packageName);
	return null;
	}
	}

	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 static Uri getGrantedUriPermission(Context context, ContentProviderClient provider,
	File file) {
	// Calls ExternalStorageProvider to get the doc id for the file
	final Bundle bundle;
	try {
	bundle = provider.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(EXTERNAL_STORAGE_AUTH, 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 Intent createGrantedUriPermissionsIntent(Context context,
	ContentProviderClient provider, File file) {
	final Uri uri = getGrantedUriPermission(context, provider, file);
	return createGrantedUriPermissionsIntent(uri);
	}

	private static Intent createGrantedUriPermissionsIntent(Uri uri) {
	final Intent intent = new Intent();
	intent.setData(uri);
	intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
	\| Intent.FLAG_GRANT_WRITE_URI_PERMISSION
	\| Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
	\| Intent.FLAG_GRANT_PREFIX_URI_PERMISSION);
	return intent;
	}

	private static Intent getIntentForExistingPermission(OpenExternalDirectoryActivity activity,
	boolean isRoot, File root, File file) {
	final String packageName = activity.getCallingPackage();
	final ContentProviderClient storageClient = activity.getExternalStorageClient();
	final Uri grantedUri = getGrantedUriPermission(activity, storageClient, file);
	final Uri rootUri = root.equals(file) ? grantedUri
	: getGrantedUriPermission(activity, storageClient, root);

	if (DEBUG)
	Log.d(TAG, "checking if " + packageName + " already has permission for " + grantedUri
	+ " or its root (" + rootUri + ")");
	final ActivityManager am =
	(ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);
	for (UriPermission uriPermission : am.getGrantedUriPermissions(packageName).getList()) {
	final Uri uri = uriPermission.getUri();
	if (uri == null) {
	Log.w(TAG, "null URI for " + uriPermission);
	continue;
	}
	if (uri.equals(grantedUri) \|\| uri.equals(rootUri)) {
	if (DEBUG) Log.d(TAG, packageName + " already has permission: " + uriPermission);
	return createGrantedUriPermissionsIntent(grantedUri);
	}
	}
	if (DEBUG) Log.d(TAG, packageName + " does not have permission for " + grantedUri);
	return null;
	}

	public static class OpenExternalDirectoryDialogFragment extends DialogFragment {

	private File mFile;
	private String mVolumeUuid;
	private String mVolumeLabel;
	private String mAppLabel;
	private boolean mIsRoot;
	private boolean mIsPrimary;
	private CheckBox mDontAskAgain;
	private OpenExternalDirectoryActivity mActivity;
	private AlertDialog mDialog;

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setRetainInstance(true);
	final Bundle args = getArguments();
	if (args != null) {
	mFile = new File(args.getString(EXTRA_FILE));
	mVolumeUuid = args.getString(EXTRA_VOLUME_UUID);
	mVolumeLabel = args.getString(EXTRA_VOLUME_LABEL);
	mAppLabel = args.getString(EXTRA_APP_LABEL);
	mIsRoot = args.getBoolean(EXTRA_IS_ROOT);
	mIsPrimary= args.getBoolean(EXTRA_IS_PRIMARY);
	}
	mActivity = (OpenExternalDirectoryActivity) getActivity();
	}

	@Override
	public void onDestroyView() {
	// Workaround for https://code.google.com/p/android/issues/detail?id=17423
	if (mDialog != null && getRetainInstance()) {
	mDialog.setDismissMessage(null);
	}
	super.onDestroyView();
	}

	@Override
	public Dialog onCreateDialog(Bundle savedInstanceState) {
	if (mDialog != null) {
	if (DEBUG) Log.d(TAG, "fragment.onCreateDialog(): reusing dialog");
	return mDialog;
	}
	if (mActivity != getActivity()) {
	// Sanity check.
	Log.wtf(TAG, "activity references don't match on onCreateDialog(): mActivity = "
	+ mActivity + " , getActivity() = " + getActivity());
	mActivity = (OpenExternalDirectoryActivity) getActivity();
	}
	final String directory = mFile.getName();
	final String directoryName = mIsRoot ? DIRECTORY_ROOT : directory;
	final Context context = mActivity.getApplicationContext();
	final OnClickListener listener = new OnClickListener() {

	@Override
	public void onClick(DialogInterface dialog, int which) {
	Intent intent = null;
	if (which == DialogInterface.BUTTON_POSITIVE) {
	intent = createGrantedUriPermissionsIntent(mActivity,
	mActivity.getExternalStorageClient(), mFile);
	}
	if (which == DialogInterface.BUTTON_NEGATIVE \|\| intent == null) {
	logValidScopedAccessRequest(mActivity, directoryName,
	SCOPED_DIRECTORY_ACCESS_DENIED);
	final boolean checked = mDontAskAgain.isChecked();
	if (checked) {
	logValidScopedAccessRequest(mActivity, directory,
	SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST);
	setScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
	mVolumeUuid, directoryName, PERMISSION_NEVER_ASK);
	} else {
	setScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
	mVolumeUuid, directoryName, PERMISSION_ASK_AGAIN);
	}
	mActivity.setResult(RESULT_CANCELED);
	} else {
	logValidScopedAccessRequest(mActivity, directory,
	SCOPED_DIRECTORY_ACCESS_GRANTED);
	mActivity.setResult(RESULT_OK, intent);
	}
	mActivity.finish();
	}
	};

	@SuppressLint("InflateParams")
	// It's ok pass null ViewRoot on AlertDialogs.
	final View view = View.inflate(mActivity, R.layout.dialog_open_scoped_directory, null);
	final CharSequence message;
	if (mIsRoot) {
	message = TextUtils.expandTemplate(getText(
	R.string.open_external_dialog_root_request), mAppLabel, mVolumeLabel);
	} else {
	message = TextUtils.expandTemplate(
	getText(mIsPrimary ? R.string.open_external_dialog_request_primary_volume
	: R.string.open_external_dialog_request),
	mAppLabel, directory, mVolumeLabel);
	}
	final TextView messageField = (TextView) view.findViewById(R.id.message);
	messageField.setText(message);
	mDialog = new AlertDialog.Builder(mActivity, R.style.Theme_AppCompat_Light_Dialog_Alert)
	.setView(view)
	.setPositiveButton(R.string.allow, listener)
	.setNegativeButton(R.string.deny, listener)
	.create();

	mDontAskAgain = (CheckBox) view.findViewById(R.id.do_not_ask_checkbox);
	if (getScopedAccessPermissionStatus(context, mActivity.getCallingPackage(),
	mVolumeUuid, directoryName) == PERMISSION_ASK_AGAIN) {
	mDontAskAgain.setVisibility(View.VISIBLE);
	mDontAskAgain.setOnCheckedChangeListener(new OnCheckedChangeListener() {

	@Override
	public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
	mDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(!isChecked);
	}
	});
	}

	return mDialog;
	}

	@Override
	public void onCancel(DialogInterface dialog) {
	super.onCancel(dialog);
	final Activity activity = getActivity();
	logValidScopedAccessRequest(activity, mFile.getName(), SCOPED_DIRECTORY_ACCESS_DENIED);
	activity.setResult(RESULT_CANCELED);
	activity.finish();
	}
	}

	private synchronized ContentProviderClient getExternalStorageClient() {
	if (mExternalStorageClient == null) {
	mExternalStorageClient =
	getContentResolver().acquireContentProviderClient(EXTERNAL_STORAGE_AUTH);
	}
	return mExternalStorageClient;
	}
	}