tests/src/com/android/providers/media/PermissionActivityTest.java - platform/packages/providers/MediaProvider - Git at Google

 /*
  * Copyright (C) 2020 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.providers.media;

 import static android.Manifest.permission.ACCESS_MEDIA_LOCATION;
 import static android.Manifest.permission.MANAGE_APP_OPS_MODES;
 import static android.Manifest.permission.MANAGE_EXTERNAL_STORAGE;
 import static android.Manifest.permission.MANAGE_MEDIA;
 import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
 import static android.Manifest.permission.UPDATE_APP_OPS_STATS;

 import static androidx.test.InstrumentationRegistry.getContext;

 import static com.android.providers.media.PermissionActivity.VERB_FAVORITE;
 import static com.android.providers.media.PermissionActivity.VERB_TRASH;
 import static com.android.providers.media.PermissionActivity.VERB_UNFAVORITE;
 import static com.android.providers.media.PermissionActivity.VERB_WRITE;
 import static com.android.providers.media.PermissionActivity.shouldShowActionDialog;
 import static com.android.providers.media.util.PermissionUtils.checkPermissionAccessMediaLocation;
 import static com.android.providers.media.util.PermissionUtils.checkPermissionManageMedia;
 import static com.android.providers.media.util.PermissionUtils.checkPermissionManager;
 import static com.android.providers.media.util.PermissionUtils.checkPermissionReadStorage;
 import static com.android.providers.media.util.TestUtils.adoptShellPermission;
 import static com.android.providers.media.util.TestUtils.dropShellPermission;

 import static com.google.common.truth.Truth.assertThat;

 import android.app.AppOpsManager;
 import android.app.Instrumentation;
 import android.content.ClipData;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Environment;
 import android.provider.MediaStore;
 import android.text.TextUtils;

 import androidx.annotation.NonNull;
 import androidx.test.InstrumentationRegistry;
 import androidx.test.filters.SdkSuppress;
 import androidx.test.runner.AndroidJUnit4;

 import com.android.providers.media.scan.MediaScannerTest;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.io.File;
 import java.util.HashSet;
 import java.util.concurrent.TimeoutException;

 /**
  * We already have solid coverage of this logic in {@code CtsProviderTestCases},
  * but the coverage system currently doesn't measure that, so we add the bare
  * minimum local testing here to convince the tooling that it's covered.
  */
 @RunWith(AndroidJUnit4.class)
 public class PermissionActivityTest {
     private static final String TEST_APP_PACKAGE_NAME =
             "com.android.providers.media.testapp.permission";

     private static final String OP_ACCESS_MEDIA_LOCATION =
             AppOpsManager.permissionToOp(ACCESS_MEDIA_LOCATION);
     private static final String OP_MANAGE_MEDIA =
             AppOpsManager.permissionToOp(MANAGE_MEDIA);
     private static final String OP_MANAGE_EXTERNAL_STORAGE =
             AppOpsManager.permissionToOp(MANAGE_EXTERNAL_STORAGE);
     private static final String OP_READ_EXTERNAL_STORAGE =
             AppOpsManager.permissionToOp(READ_EXTERNAL_STORAGE);

     // The list is used to restore the permissions after the test is finished.
     // The default value for these app ops is {@link AppOpsManager#MODE_DEFAULT}
     private static final String[] DEFAULT_OP_PERMISSION_LIST = new String[] {
             OP_MANAGE_EXTERNAL_STORAGE,
             OP_MANAGE_MEDIA
     };

     // The list is used to restore the permissions after the test is finished.
     // The default value for these app ops is {@link AppOpsManager#MODE_ALLOWED}
     private static final String[] ALLOWED_OP_PERMISSION_LIST = new String[] {
             OP_ACCESS_MEDIA_LOCATION,
             OP_READ_EXTERNAL_STORAGE
     };

     private static final long TIMEOUT_MILLIS = 3000;
     private static final long SLEEP_MILLIS = 30;

     private static final int TEST_APP_PID = -1;
     private int mTestAppUid = -1;

     @Before
     public void setUp() throws Exception {
         mTestAppUid = getContext().getPackageManager().getPackageUid(TEST_APP_PACKAGE_NAME, 0);
     }

     @Test
     public void testSimple() throws Exception {
         final Instrumentation inst = InstrumentationRegistry.getInstrumentation();
         final Intent intent = new Intent(inst.getContext(), GetResultActivity.class);
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

         final GetResultActivity activity = (GetResultActivity) inst.startActivitySync(intent);
         activity.startActivityForResult(createIntent(), 42);
     }

     @Test
     public void testShouldShowActionDialog_favorite_false() throws Exception {
         assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                 TEST_APP_PACKAGE_NAME, null, VERB_FAVORITE)).isFalse();
     }

     @Test
     public void testShouldShowActionDialog_unfavorite_false() throws Exception {
         assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                 TEST_APP_PACKAGE_NAME, null, VERB_UNFAVORITE)).isFalse();
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_noRESAndMES_true() throws Exception {
         final String[] enableAppOpsList = {OP_MANAGE_MEDIA};
         final String[] disableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_READ_EXTERNAL_STORAGE};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isTrue();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_noMANAGE_MEDIA_true() throws Exception {
         final String[] enableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_READ_EXTERNAL_STORAGE};
         final String[] disableAppOpsList = {OP_MANAGE_MEDIA};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isTrue();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_hasPermissionWithRES_false() throws Exception {
         final String[] enableAppOpsList = {OP_MANAGE_MEDIA, OP_READ_EXTERNAL_STORAGE};
         final String[] disableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isFalse();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_hasPermissionWithMES_false() throws Exception {
         final String[] enableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_MANAGE_MEDIA};
         final String[] disableAppOpsList = {OP_READ_EXTERNAL_STORAGE};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isFalse();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_writeNoACCESS_MEDIA_LOCATION_true() throws Exception {
         final String[] enableAppOpsList =
                 {OP_MANAGE_EXTERNAL_STORAGE, OP_MANAGE_MEDIA, OP_READ_EXTERNAL_STORAGE};
         final String[] disableAppOpsList = {OP_ACCESS_MEDIA_LOCATION};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_WRITE)).isTrue();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     @Test
     @SdkSuppress(minSdkVersion = 31, codeName = "S")
     public void testShouldShowActionDialog_writeHasACCESS_MEDIA_LOCATION_false() throws Exception {
         final String[] enableAppOpsList = {
                 OP_ACCESS_MEDIA_LOCATION,
                 OP_MANAGE_EXTERNAL_STORAGE,
                 OP_MANAGE_MEDIA,
                 OP_READ_EXTERNAL_STORAGE};
         final String[] disableAppOpsList = new String[]{};
         adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

         try {
             setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

             assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
                     TEST_APP_PACKAGE_NAME, null, VERB_WRITE)).isFalse();
         } finally {
             restoreDefaultAppOpPermissions(mTestAppUid);
             dropShellPermission();
         }
     }

     private static void setupPermissions(int uid, @NonNull String[] enableAppOpsList,
             @NonNull String[] disableAppOpsList) throws Exception {
         for (String op : enableAppOpsList) {
             modifyAppOp(uid, op, AppOpsManager.MODE_ALLOWED);
         }

         for (String op : disableAppOpsList) {
             modifyAppOp(uid, op, AppOpsManager.MODE_ERRORED);
         }

         pollForAppOpPermissions(TEST_APP_PID, uid, enableAppOpsList, /* hasPermission= */ true);
         pollForAppOpPermissions(TEST_APP_PID, uid, disableAppOpsList, /* hasPermission= */ false);
     }

     private static void restoreDefaultAppOpPermissions(int uid) {
         for (String op : DEFAULT_OP_PERMISSION_LIST) {
             modifyAppOp(uid, op, AppOpsManager.MODE_DEFAULT);
         }

         for (String op : ALLOWED_OP_PERMISSION_LIST) {
             modifyAppOp(uid, op, AppOpsManager.MODE_ALLOWED);
         }
     }

     private static Intent createIntent() throws Exception {
         final Context context = InstrumentationRegistry.getContext();

         final File dir = Environment
                 .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
         final File file = MediaScannerTest.stage(R.raw.test_image,
                 new File(dir, "test" + System.nanoTime() + ".jpg"));
         final Uri uri = MediaStore.scanFile(context.getContentResolver(), file);

         final Intent intent = new Intent(MediaStore.CREATE_WRITE_REQUEST_CALL, null,
                 context, PermissionActivity.class);
         intent.putExtra(MediaStore.EXTRA_CLIP_DATA, ClipData.newRawUri("", uri));
         intent.putExtra(MediaStore.EXTRA_CONTENT_VALUES, new ContentValues());
         return intent;
     }

     private static void modifyAppOp(int uid, @NonNull String op, int mode) {
         getContext().getSystemService(AppOpsManager.class).setUidMode(op, uid, mode);
     }

     private static void pollForAppOpPermissions(int pid, int uid, String[] opList,
             boolean hasPermission) throws Exception {
         long current = System.currentTimeMillis();
         final long timeout = current + TIMEOUT_MILLIS;
         final HashSet<String> checkedOpSet = new HashSet<>();

         while (current < timeout && checkedOpSet.size() < opList.length) {
             for (String op : opList) {
                 if (!checkedOpSet.contains(op) && checkPermission(op, pid, uid,
                         TEST_APP_PACKAGE_NAME, hasPermission)) {
                     checkedOpSet.add(op);
                     continue;
                 }
             }
             Thread.sleep(SLEEP_MILLIS);
             current = System.currentTimeMillis();
         }

         if (checkedOpSet.size() != opList.length) {
             throw new TimeoutException("Check AppOp permissions with " + uid + " timeout");
         }
     }

     private static boolean checkPermission(@NonNull String op, int pid, int uid,
             @NonNull String packageName, boolean expected) {
         final Context context = getContext();

         if (TextUtils.equals(op, OP_READ_EXTERNAL_STORAGE)) {
             return expected == checkPermissionReadStorage(context, pid, uid, packageName,
                     /* attributionTag= */ null);
         } else if (TextUtils.equals(op, OP_MANAGE_EXTERNAL_STORAGE)) {
             return expected == checkPermissionManager(context, pid, uid, packageName,
                     /* attributionTag= */ null);
         } else if (TextUtils.equals(op, OP_MANAGE_MEDIA)) {
             return expected == checkPermissionManageMedia(context, pid, uid, packageName,
                     /* attributionTag= */ null);
         } else if (TextUtils.equals(op, OP_ACCESS_MEDIA_LOCATION)) {
             return expected == checkPermissionAccessMediaLocation(context, pid, uid,
                     packageName, /* attributionTag= */ null);
         } else {
             throw new IllegalArgumentException("checkPermission is not supported for op: " + op);
         }
     }
 }
	/*
	* Copyright (C) 2020 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.providers.media;

	import static android.Manifest.permission.ACCESS_MEDIA_LOCATION;
	import static android.Manifest.permission.MANAGE_APP_OPS_MODES;
	import static android.Manifest.permission.MANAGE_EXTERNAL_STORAGE;
	import static android.Manifest.permission.MANAGE_MEDIA;
	import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
	import static android.Manifest.permission.UPDATE_APP_OPS_STATS;

	import static androidx.test.InstrumentationRegistry.getContext;

	import static com.android.providers.media.PermissionActivity.VERB_FAVORITE;
	import static com.android.providers.media.PermissionActivity.VERB_TRASH;
	import static com.android.providers.media.PermissionActivity.VERB_UNFAVORITE;
	import static com.android.providers.media.PermissionActivity.VERB_WRITE;
	import static com.android.providers.media.PermissionActivity.shouldShowActionDialog;
	import static com.android.providers.media.util.PermissionUtils.checkPermissionAccessMediaLocation;
	import static com.android.providers.media.util.PermissionUtils.checkPermissionManageMedia;
	import static com.android.providers.media.util.PermissionUtils.checkPermissionManager;
	import static com.android.providers.media.util.PermissionUtils.checkPermissionReadStorage;
	import static com.android.providers.media.util.TestUtils.adoptShellPermission;
	import static com.android.providers.media.util.TestUtils.dropShellPermission;

	import static com.google.common.truth.Truth.assertThat;

	import android.app.AppOpsManager;
	import android.app.Instrumentation;
	import android.content.ClipData;
	import android.content.ContentValues;
	import android.content.Context;
	import android.content.Intent;
	import android.net.Uri;
	import android.os.Environment;
	import android.provider.MediaStore;
	import android.text.TextUtils;

	import androidx.annotation.NonNull;
	import androidx.test.InstrumentationRegistry;
	import androidx.test.filters.SdkSuppress;
	import androidx.test.runner.AndroidJUnit4;

	import com.android.providers.media.scan.MediaScannerTest;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.io.File;
	import java.util.HashSet;
	import java.util.concurrent.TimeoutException;

	/**
	* We already have solid coverage of this logic in {@code CtsProviderTestCases},
	* but the coverage system currently doesn't measure that, so we add the bare
	* minimum local testing here to convince the tooling that it's covered.
	*/
	@RunWith(AndroidJUnit4.class)
	public class PermissionActivityTest {
	private static final String TEST_APP_PACKAGE_NAME =
	"com.android.providers.media.testapp.permission";

	private static final String OP_ACCESS_MEDIA_LOCATION =
	AppOpsManager.permissionToOp(ACCESS_MEDIA_LOCATION);
	private static final String OP_MANAGE_MEDIA =
	AppOpsManager.permissionToOp(MANAGE_MEDIA);
	private static final String OP_MANAGE_EXTERNAL_STORAGE =
	AppOpsManager.permissionToOp(MANAGE_EXTERNAL_STORAGE);
	private static final String OP_READ_EXTERNAL_STORAGE =
	AppOpsManager.permissionToOp(READ_EXTERNAL_STORAGE);

	// The list is used to restore the permissions after the test is finished.
	// The default value for these app ops is {@link AppOpsManager#MODE_DEFAULT}
	private static final String[] DEFAULT_OP_PERMISSION_LIST = new String[] {
	OP_MANAGE_EXTERNAL_STORAGE,
	OP_MANAGE_MEDIA
	};

	// The list is used to restore the permissions after the test is finished.
	// The default value for these app ops is {@link AppOpsManager#MODE_ALLOWED}
	private static final String[] ALLOWED_OP_PERMISSION_LIST = new String[] {
	OP_ACCESS_MEDIA_LOCATION,
	OP_READ_EXTERNAL_STORAGE
	};

	private static final long TIMEOUT_MILLIS = 3000;
	private static final long SLEEP_MILLIS = 30;

	private static final int TEST_APP_PID = -1;
	private int mTestAppUid = -1;

	@Before
	public void setUp() throws Exception {
	mTestAppUid = getContext().getPackageManager().getPackageUid(TEST_APP_PACKAGE_NAME, 0);
	}

	@Test
	public void testSimple() throws Exception {
	final Instrumentation inst = InstrumentationRegistry.getInstrumentation();
	final Intent intent = new Intent(inst.getContext(), GetResultActivity.class);
	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

	final GetResultActivity activity = (GetResultActivity) inst.startActivitySync(intent);
	activity.startActivityForResult(createIntent(), 42);
	}

	@Test
	public void testShouldShowActionDialog_favorite_false() throws Exception {
	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_FAVORITE)).isFalse();
	}

	@Test
	public void testShouldShowActionDialog_unfavorite_false() throws Exception {
	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_UNFAVORITE)).isFalse();
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_noRESAndMES_true() throws Exception {
	final String[] enableAppOpsList = {OP_MANAGE_MEDIA};
	final String[] disableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_READ_EXTERNAL_STORAGE};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isTrue();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_noMANAGE_MEDIA_true() throws Exception {
	final String[] enableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_READ_EXTERNAL_STORAGE};
	final String[] disableAppOpsList = {OP_MANAGE_MEDIA};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isTrue();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_hasPermissionWithRES_false() throws Exception {
	final String[] enableAppOpsList = {OP_MANAGE_MEDIA, OP_READ_EXTERNAL_STORAGE};
	final String[] disableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isFalse();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_hasPermissionWithMES_false() throws Exception {
	final String[] enableAppOpsList = {OP_MANAGE_EXTERNAL_STORAGE, OP_MANAGE_MEDIA};
	final String[] disableAppOpsList = {OP_READ_EXTERNAL_STORAGE};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_TRASH)).isFalse();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_writeNoACCESS_MEDIA_LOCATION_true() throws Exception {
	final String[] enableAppOpsList =
	{OP_MANAGE_EXTERNAL_STORAGE, OP_MANAGE_MEDIA, OP_READ_EXTERNAL_STORAGE};
	final String[] disableAppOpsList = {OP_ACCESS_MEDIA_LOCATION};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_WRITE)).isTrue();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	@Test
	@SdkSuppress(minSdkVersion = 31, codeName = "S")
	public void testShouldShowActionDialog_writeHasACCESS_MEDIA_LOCATION_false() throws Exception {
	final String[] enableAppOpsList = {
	OP_ACCESS_MEDIA_LOCATION,
	OP_MANAGE_EXTERNAL_STORAGE,
	OP_MANAGE_MEDIA,
	OP_READ_EXTERNAL_STORAGE};
	final String[] disableAppOpsList = new String[]{};
	adoptShellPermission(UPDATE_APP_OPS_STATS, MANAGE_APP_OPS_MODES);

	try {
	setupPermissions(mTestAppUid, enableAppOpsList, disableAppOpsList);

	assertThat(shouldShowActionDialog(getContext(), TEST_APP_PID, mTestAppUid,
	TEST_APP_PACKAGE_NAME, null, VERB_WRITE)).isFalse();
	} finally {
	restoreDefaultAppOpPermissions(mTestAppUid);
	dropShellPermission();
	}
	}

	private static void setupPermissions(int uid, @NonNull String[] enableAppOpsList,
	@NonNull String[] disableAppOpsList) throws Exception {
	for (String op : enableAppOpsList) {
	modifyAppOp(uid, op, AppOpsManager.MODE_ALLOWED);
	}

	for (String op : disableAppOpsList) {
	modifyAppOp(uid, op, AppOpsManager.MODE_ERRORED);
	}

	pollForAppOpPermissions(TEST_APP_PID, uid, enableAppOpsList, /* hasPermission= */ true);
	pollForAppOpPermissions(TEST_APP_PID, uid, disableAppOpsList, /* hasPermission= */ false);
	}

	private static void restoreDefaultAppOpPermissions(int uid) {
	for (String op : DEFAULT_OP_PERMISSION_LIST) {
	modifyAppOp(uid, op, AppOpsManager.MODE_DEFAULT);
	}

	for (String op : ALLOWED_OP_PERMISSION_LIST) {
	modifyAppOp(uid, op, AppOpsManager.MODE_ALLOWED);
	}
	}

	private static Intent createIntent() throws Exception {
	final Context context = InstrumentationRegistry.getContext();

	final File dir = Environment
	.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
	final File file = MediaScannerTest.stage(R.raw.test_image,
	new File(dir, "test" + System.nanoTime() + ".jpg"));
	final Uri uri = MediaStore.scanFile(context.getContentResolver(), file);

	final Intent intent = new Intent(MediaStore.CREATE_WRITE_REQUEST_CALL, null,
	context, PermissionActivity.class);
	intent.putExtra(MediaStore.EXTRA_CLIP_DATA, ClipData.newRawUri("", uri));
	intent.putExtra(MediaStore.EXTRA_CONTENT_VALUES, new ContentValues());
	return intent;
	}

	private static void modifyAppOp(int uid, @NonNull String op, int mode) {
	getContext().getSystemService(AppOpsManager.class).setUidMode(op, uid, mode);
	}

	private static void pollForAppOpPermissions(int pid, int uid, String[] opList,
	boolean hasPermission) throws Exception {
	long current = System.currentTimeMillis();
	final long timeout = current + TIMEOUT_MILLIS;
	final HashSet<String> checkedOpSet = new HashSet<>();

	while (current < timeout && checkedOpSet.size() < opList.length) {
	for (String op : opList) {
	if (!checkedOpSet.contains(op) && checkPermission(op, pid, uid,
	TEST_APP_PACKAGE_NAME, hasPermission)) {
	checkedOpSet.add(op);
	continue;
	}
	}
	Thread.sleep(SLEEP_MILLIS);
	current = System.currentTimeMillis();
	}

	if (checkedOpSet.size() != opList.length) {
	throw new TimeoutException("Check AppOp permissions with " + uid + " timeout");
	}
	}

	private static boolean checkPermission(@NonNull String op, int pid, int uid,
	@NonNull String packageName, boolean expected) {
	final Context context = getContext();

	if (TextUtils.equals(op, OP_READ_EXTERNAL_STORAGE)) {
	return expected == checkPermissionReadStorage(context, pid, uid, packageName,
	/* attributionTag= */ null);
	} else if (TextUtils.equals(op, OP_MANAGE_EXTERNAL_STORAGE)) {
	return expected == checkPermissionManager(context, pid, uid, packageName,
	/* attributionTag= */ null);
	} else if (TextUtils.equals(op, OP_MANAGE_MEDIA)) {
	return expected == checkPermissionManageMedia(context, pid, uid, packageName,
	/* attributionTag= */ null);
	} else if (TextUtils.equals(op, OP_ACCESS_MEDIA_LOCATION)) {
	return expected == checkPermissionAccessMediaLocation(context, pid, uid,
	packageName, /* attributionTag= */ null);
	} else {
	throw new IllegalArgumentException("checkPermission is not supported for op: " + op);
	}
	}
	}