tests/tests/voiceRecognition/src/android/voicerecognition/cts/RecognitionServiceMicIndicatorTest.java - platform/cts - 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 android.voicerecognition.cts;

 import static com.android.compatibility.common.util.ShellUtils.runShellCommand;
 import static com.android.compatibility.common.util.SystemUtil.callWithShellPermissionIdentity;
 import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;

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

 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;

 import android.Manifest;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.provider.DeviceConfig;
 import android.provider.Settings;
 import android.safetycenter.SafetyCenterManager;
 import android.server.wm.WindowManagerStateHelper;
 import android.support.test.uiautomator.By;
 import android.support.test.uiautomator.BySelector;
 import android.support.test.uiautomator.UiDevice;
 import android.support.test.uiautomator.UiObject2;
 import android.util.Log;

 import androidx.annotation.NonNull;
 import androidx.test.platform.app.InstrumentationRegistry;
 import androidx.test.rule.ActivityTestRule;
 import androidx.test.runner.AndroidJUnit4;

 import com.android.compatibility.common.util.CddTest;
 import com.android.compatibility.common.util.SettingsStateChangerRule;
 import com.android.compatibility.common.util.SystemUtil;

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

 import java.util.List;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;

 @RunWith(AndroidJUnit4.class)
 public final class RecognitionServiceMicIndicatorTest {

     private static final String TAG = "RecognitionServiceMicIndicatorTest";
     // same as Settings.Secure.VOICE_RECOGNITION_SERVICE
     private static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service";
     private static final String INDICATORS_FLAG = "camera_mic_icons_enabled";
     // Same as PrivacyItemController DEFAULT_MIC_CAMERA
     private static final boolean DEFAULT_MIC_CAMERA = true;
     // Th notification privacy indicator
     private static final String PRIVACY_CHIP_PACKAGE_NAME = "com.android.systemui";
     private static final String PRIVACY_CHIP_ID = "privacy_chip";
     private static final String CAR_MIC_PRIVACY_CHIP_ID = "mic_privacy_chip";
     private static final String PRIVACY_DIALOG_PACKAGE_NAME = "com.android.systemui";
     private static final String PRIVACY_DIALOG_CONTENT_ID = "text";
     private static final String PRIVACY_DIALOG_CONTENT_V2_ID = "privacy_dialog_item_header_summary";
     private static final String CAR_PRIVACY_DIALOG_CONTENT_ID = "qc_title";
     private static final String TV_MIC_INDICATOR_WINDOW_TITLE = "MicrophoneCaptureIndicator";
     private static final String SC_PRIVACY_DIALOG_PACKAGE_NAME = "com.android.permissioncontroller";
     private static final String SC_PRIVACY_DIALOG_CONTENT_ID = "indicator_label";
     // The cts app label
     private static final String APP_LABEL = "CtsVoiceRecognitionTestCases";
     // A simple test voice recognition service implementation
     private static final String CTS_VOICE_RECOGNITION_SERVICE =
             "android.recognitionservice.service/android.recognitionservice.service"
                     + ".CtsVoiceRecognitionService";
     private static final long LONGER_TIMEOUT = 30000L;
     protected final Context mContext =
             InstrumentationRegistry.getInstrumentation().getTargetContext();
     private final String mOriginalVoiceRecognizer = Settings.Secure.getString(
             mContext.getContentResolver(), VOICE_RECOGNITION_SERVICE);
     private UiDevice mUiDevice;
     private SpeechRecognitionActivity mActivity;
     private String mCameraLabel;
     private String mOriginalIndicatorsState;
     private boolean mSafetyCenterEnabled;

     @Rule
     public ActivityTestRule<SpeechRecognitionActivity> mActivityTestRule =
             new ActivityTestRule<>(SpeechRecognitionActivity.class);

     @Rule
     public final SettingsStateChangerRule mVoiceRecognitionServiceSetterRule =
             new SettingsStateChangerRule(mContext, VOICE_RECOGNITION_SERVICE,
                     mOriginalVoiceRecognizer);

     @Before
     public void setup() {
         prepareDevice();
         mUiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
         mActivity = mActivityTestRule.getActivity();
         mActivity.initDefault(false, null);

         final PackageManager pm = mContext.getPackageManager();
         try {
             mCameraLabel = pm.getPermissionGroupInfo(Manifest.permission_group.CAMERA, 0).loadLabel(
                     pm).toString();
         } catch (PackageManager.NameNotFoundException e) {
         }
         runWithShellPermissionIdentity(() -> {
             mOriginalIndicatorsState =
                     DeviceConfig.getProperty(DeviceConfig.NAMESPACE_PRIVACY, INDICATORS_FLAG);
             Log.v(TAG, "setup(): mOriginalIndicatorsState=" + mOriginalIndicatorsState);
         });

         // TODO(http://b/259941077): Remove once privacy indicators are implemented.
         assumeFalse("Privacy indicators not supported", isWatch());

         try {
             mSafetyCenterEnabled = callWithShellPermissionIdentity(
                 () -> mContext.getSystemService(SafetyCenterManager.class).isSafetyCenterEnabled());
         } catch (Exception e) {
             throw new IllegalStateException(e);
         }

         setIndicatorsEnabledState(Boolean.toString(true));
         // Wait for any privacy indicator to disappear to avoid the test becoming flaky.
         waitForNoIndicator(chipId());
     }

     @After
     public void teardown() {
         // press back to close the dialog
         mUiDevice.pressHome();
         // Restore original value.
         setIndicatorsEnabledState(mOriginalIndicatorsState);
         waitForNoIndicator(chipId());
     }

     private void prepareDevice() {
         // Unlock screen.
         runShellCommand("input keyevent KEYCODE_WAKEUP");
         // Dismiss keyguard, in case it's set as "Swipe to unlock".
         runShellCommand("wm dismiss-keyguard");
     }

     private void setCurrentRecognizer(String recognizer) {
         runWithShellPermissionIdentity(
                 () -> Settings.Secure.putString(mContext.getContentResolver(),
                         VOICE_RECOGNITION_SERVICE, recognizer));
         mUiDevice.waitForIdle();
     }

     private String getCurrentRecognizer() {
         return Settings.Secure.getString(mContext.getContentResolver(), VOICE_RECOGNITION_SERVICE);
     }

     private void setIndicatorsEnabledState(String enabled) {
         runWithShellPermissionIdentity(
                 () -> DeviceConfig.setProperty(DeviceConfig.NAMESPACE_PRIVACY, INDICATORS_FLAG,
                         enabled, false));
         mUiDevice.waitForIdle();
     }

     private boolean hasPreInstalledRecognizer(String packageName) {
         Log.v(TAG, "hasPreInstalledRecognizer package=" + packageName);
         try {
             final PackageManager pm = mContext.getPackageManager();
             final ApplicationInfo info = pm.getApplicationInfo(packageName, 0);
             return ((info.flags & ApplicationInfo.FLAG_SYSTEM) != 0);
         } catch (PackageManager.NameNotFoundException e) {
             return false;
         }
     }

     private static String getComponentPackageNameFromString(String from) {
         ComponentName componentName = from != null ? ComponentName.unflattenFromString(from) : null;
         return componentName != null ? componentName.getPackageName() : "";
     }

     @Test
     @CddTest(requirements = {"9.8.2/H-4-1"})
     public void testNonTrustedRecognitionServiceCanBlameCallingApp() throws Throwable {
         // Save currently selected recognition service.
         String previousRecognizer = getCurrentRecognizer();

         // We treat trusted if the current voice recognizer is also a preinstalled app.
         // This is an untrusted case.
         setCurrentRecognizer(CTS_VOICE_RECOGNITION_SERVICE);

         try {
             // Verify that the untrusted app cannot blame the calling app mic access.
             testVoiceRecognitionServiceBlameCallingApp(/* trustVoiceService */ false);
         } finally {
             // Reinstate previously selected recognition service.
             setCurrentRecognizer(previousRecognizer);
         }
     }

     @Test
     @CddTest(requirements = {"9.8.2/H-4-1"})
     public void testTrustedRecognitionServiceCanBlameCallingApp() throws Throwable {
         // We treat trusted if the current voice recognizer is also a preinstalled app. This is a
         // trusted case.
         boolean hasPreInstalledRecognizer = hasPreInstalledRecognizer(
                 getComponentPackageNameFromString(mOriginalVoiceRecognizer));
         assumeTrue("No preinstalled recognizer.", hasPreInstalledRecognizer);

         // verify that the trusted app can blame the calling app mic access
         testVoiceRecognitionServiceBlameCallingApp(/* trustVoiceService */ true);
     }

     private void testVoiceRecognitionServiceBlameCallingApp(boolean trustVoiceService)
             throws Throwable {
         // Start SpeechRecognition
         mActivity.startListeningDefault();

         if (isTv()) {
             assertTvIndicatorsShown(trustVoiceService);
         } else {
             assertPrivacyChipAndIndicatorsPresent(trustVoiceService);
         }
     }

     private void assertTvIndicatorsShown(boolean trustVoiceService) {
         Log.v(TAG, "assertTvIndicatorsShown");
         final WindowManagerStateHelper wmState = new WindowManagerStateHelper();
         wmState.waitFor(
                 state -> {
                     if (trustVoiceService) {
                         return state.containsWindow(TV_MIC_INDICATOR_WINDOW_TITLE)
                                 && state.isWindowVisible(TV_MIC_INDICATOR_WINDOW_TITLE);
                     } else {
                         return !state.containsWindow(TV_MIC_INDICATOR_WINDOW_TITLE);
                     }
                 },
                 "Waiting for the mic indicator window to come up");
     }

     private void assertPrivacyChipAndIndicatorsPresent(boolean trustVoiceService) throws Exception {
         // Open notification and verify the privacy indicator is shown
         mUiDevice.openQuickSettings();

         String chipId = chipId();
         final UiObject2 privacyChip =
                 SystemUtil.getEventually(() -> {
                     final UiObject2 foundChip =
                             mUiDevice.findObject(By.res(PRIVACY_CHIP_PACKAGE_NAME, chipId));
                     assertWithMessage("Can not find mic indicator").that(foundChip).isNotNull();
                     return foundChip;
                 });

         // Make sure dialog is shown
         BySelector selector;
         if (isCar()) {
             selector = By.res(PRIVACY_DIALOG_PACKAGE_NAME, CAR_PRIVACY_DIALOG_CONTENT_ID);
         } else if (mSafetyCenterEnabled) {
             selector =
                     byEitherRes(
                             SC_PRIVACY_DIALOG_PACKAGE_NAME,
                             SC_PRIVACY_DIALOG_CONTENT_ID,
                             PRIVACY_DIALOG_PACKAGE_NAME,
                             PRIVACY_DIALOG_CONTENT_V2_ID);
         } else {
             selector = By.res(PRIVACY_DIALOG_PACKAGE_NAME, PRIVACY_DIALOG_CONTENT_ID);
         }

         // Click the privacy indicator and verify the calling app name display status in the dialog.
         privacyChip.click();
         List<UiObject2> recognitionCallingAppLabels =
                 SystemUtil.getEventually(() -> {
                     List<UiObject2> labels = mUiDevice.findObjects(selector);
                     assertWithMessage("No permission dialog shown after clicking privacy chip.")
                             .that(labels).isNotEmpty();
                     return labels;
                 });

         // get dialog content
         String dialogDescription = recognitionCallingAppLabels
                             .stream()
                             .map(UiObject2::getText)
                             .collect(Collectors.joining("\n"));
         Log.i(TAG, "Retrieved dialog description " + dialogDescription);

         if (trustVoiceService) {
             // Check trust recognizer can blame calling apmic permission
             assertWithMessage(
                     "Trusted voice recognition service can blame the calling app name " + APP_LABEL
                             + ", but does not find it.")
                     .that(dialogDescription)
                     .contains(APP_LABEL);

             // Check trust recognizer cannot blame non-mic permission
             assertWithMessage("Trusted voice recognition service cannot blame non-mic permission")
                     .that(dialogDescription)
                     .doesNotContain(mCameraLabel);
         } else {
             assertWithMessage(
                     "Untrusted voice recognition service cannot blame the calling app name "
                             + APP_LABEL)
                     .that(dialogDescription)
                     .doesNotContain(APP_LABEL);
         }

         if (isCar()) {
             // In cars the privacy chip will continue showing while the recognizer still has a
             // session in progress
             mActivity.destroyRecognizerDefault();
             privacyChip.click();
         }
         // Wait for the privacy indicator to disappear to avoid the test becoming flaky.
         waitForNoIndicator(chipId);
     }

     @NonNull
     private String chipId() {
         return isCar() ? CAR_MIC_PRIVACY_CHIP_ID : PRIVACY_CHIP_ID;
     }

     private void waitForNoIndicator(String chipId) {
         SystemUtil.eventually(() -> {
             final UiObject2 foundChip =
                     mUiDevice.findObject(By.res(PRIVACY_CHIP_PACKAGE_NAME, chipId));
             assertWithMessage("Chip still visible.").that(foundChip).isNull();
         }, LONGER_TIMEOUT);
     }


     private boolean isTv() {
         PackageManager pm = mContext.getPackageManager();
         return pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK);
     }

     private boolean isCar() {
         PackageManager pm = mContext.getPackageManager();
         return pm.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE);
     }

     private boolean isWatch() {
         PackageManager pm = mContext.getPackageManager();
         return pm.hasSystemFeature(PackageManager.FEATURE_WATCH);
     }

     private static BySelector byEitherRes(
             String resourcePackageA,
             String resourceIdA,
             String resourcePackageB,
             String resourceIdB) {
         return By.res(
                 Pattern.compile(
                         String.format(
                                 "%s|%s",
                                 resourceNameLiteral(resourcePackageA, resourceIdA),
                                 resourceNameLiteral(resourcePackageB, resourceIdB))));
     }

     private static String resourceNameLiteral(String resourcePackage, String resourceId) {
         return Pattern.quote(String.format("%s:id/%s", resourcePackage, resourceId));
     }
 }
	/*
	* 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 android.voicerecognition.cts;

	import static com.android.compatibility.common.util.ShellUtils.runShellCommand;
	import static com.android.compatibility.common.util.SystemUtil.callWithShellPermissionIdentity;
	import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;

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

	import static org.junit.Assume.assumeFalse;
	import static org.junit.Assume.assumeTrue;

	import android.Manifest;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.pm.ApplicationInfo;
	import android.content.pm.PackageManager;
	import android.provider.DeviceConfig;
	import android.provider.Settings;
	import android.safetycenter.SafetyCenterManager;
	import android.server.wm.WindowManagerStateHelper;
	import android.support.test.uiautomator.By;
	import android.support.test.uiautomator.BySelector;
	import android.support.test.uiautomator.UiDevice;
	import android.support.test.uiautomator.UiObject2;
	import android.util.Log;

	import androidx.annotation.NonNull;
	import androidx.test.platform.app.InstrumentationRegistry;
	import androidx.test.rule.ActivityTestRule;
	import androidx.test.runner.AndroidJUnit4;

	import com.android.compatibility.common.util.CddTest;
	import com.android.compatibility.common.util.SettingsStateChangerRule;
	import com.android.compatibility.common.util.SystemUtil;

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

	import java.util.List;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;

	@RunWith(AndroidJUnit4.class)
	public final class RecognitionServiceMicIndicatorTest {

	private static final String TAG = "RecognitionServiceMicIndicatorTest";
	// same as Settings.Secure.VOICE_RECOGNITION_SERVICE
	private static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service";
	private static final String INDICATORS_FLAG = "camera_mic_icons_enabled";
	// Same as PrivacyItemController DEFAULT_MIC_CAMERA
	private static final boolean DEFAULT_MIC_CAMERA = true;
	// Th notification privacy indicator
	private static final String PRIVACY_CHIP_PACKAGE_NAME = "com.android.systemui";
	private static final String PRIVACY_CHIP_ID = "privacy_chip";
	private static final String CAR_MIC_PRIVACY_CHIP_ID = "mic_privacy_chip";
	private static final String PRIVACY_DIALOG_PACKAGE_NAME = "com.android.systemui";
	private static final String PRIVACY_DIALOG_CONTENT_ID = "text";
	private static final String PRIVACY_DIALOG_CONTENT_V2_ID = "privacy_dialog_item_header_summary";
	private static final String CAR_PRIVACY_DIALOG_CONTENT_ID = "qc_title";
	private static final String TV_MIC_INDICATOR_WINDOW_TITLE = "MicrophoneCaptureIndicator";
	private static final String SC_PRIVACY_DIALOG_PACKAGE_NAME = "com.android.permissioncontroller";
	private static final String SC_PRIVACY_DIALOG_CONTENT_ID = "indicator_label";
	// The cts app label
	private static final String APP_LABEL = "CtsVoiceRecognitionTestCases";
	// A simple test voice recognition service implementation
	private static final String CTS_VOICE_RECOGNITION_SERVICE =
	"android.recognitionservice.service/android.recognitionservice.service"
	+ ".CtsVoiceRecognitionService";
	private static final long LONGER_TIMEOUT = 30000L;
	protected final Context mContext =
	InstrumentationRegistry.getInstrumentation().getTargetContext();
	private final String mOriginalVoiceRecognizer = Settings.Secure.getString(
	mContext.getContentResolver(), VOICE_RECOGNITION_SERVICE);
	private UiDevice mUiDevice;
	private SpeechRecognitionActivity mActivity;
	private String mCameraLabel;
	private String mOriginalIndicatorsState;
	private boolean mSafetyCenterEnabled;

	@Rule
	public ActivityTestRule<SpeechRecognitionActivity> mActivityTestRule =
	new ActivityTestRule<>(SpeechRecognitionActivity.class);

	@Rule
	public final SettingsStateChangerRule mVoiceRecognitionServiceSetterRule =
	new SettingsStateChangerRule(mContext, VOICE_RECOGNITION_SERVICE,
	mOriginalVoiceRecognizer);

	@Before
	public void setup() {
	prepareDevice();
	mUiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
	mActivity = mActivityTestRule.getActivity();
	mActivity.initDefault(false, null);

	final PackageManager pm = mContext.getPackageManager();
	try {
	mCameraLabel = pm.getPermissionGroupInfo(Manifest.permission_group.CAMERA, 0).loadLabel(
	pm).toString();
	} catch (PackageManager.NameNotFoundException e) {
	}
	runWithShellPermissionIdentity(() -> {
	mOriginalIndicatorsState =
	DeviceConfig.getProperty(DeviceConfig.NAMESPACE_PRIVACY, INDICATORS_FLAG);
	Log.v(TAG, "setup(): mOriginalIndicatorsState=" + mOriginalIndicatorsState);
	});

	// TODO(http://b/259941077): Remove once privacy indicators are implemented.
	assumeFalse("Privacy indicators not supported", isWatch());

	try {
	mSafetyCenterEnabled = callWithShellPermissionIdentity(
	() -> mContext.getSystemService(SafetyCenterManager.class).isSafetyCenterEnabled());
	} catch (Exception e) {
	throw new IllegalStateException(e);
	}

	setIndicatorsEnabledState(Boolean.toString(true));
	// Wait for any privacy indicator to disappear to avoid the test becoming flaky.
	waitForNoIndicator(chipId());
	}

	@After
	public void teardown() {
	// press back to close the dialog
	mUiDevice.pressHome();
	// Restore original value.
	setIndicatorsEnabledState(mOriginalIndicatorsState);
	waitForNoIndicator(chipId());
	}

	private void prepareDevice() {
	// Unlock screen.
	runShellCommand("input keyevent KEYCODE_WAKEUP");
	// Dismiss keyguard, in case it's set as "Swipe to unlock".
	runShellCommand("wm dismiss-keyguard");
	}

	private void setCurrentRecognizer(String recognizer) {
	runWithShellPermissionIdentity(
	() -> Settings.Secure.putString(mContext.getContentResolver(),
	VOICE_RECOGNITION_SERVICE, recognizer));
	mUiDevice.waitForIdle();
	}

	private String getCurrentRecognizer() {
	return Settings.Secure.getString(mContext.getContentResolver(), VOICE_RECOGNITION_SERVICE);
	}

	private void setIndicatorsEnabledState(String enabled) {
	runWithShellPermissionIdentity(
	() -> DeviceConfig.setProperty(DeviceConfig.NAMESPACE_PRIVACY, INDICATORS_FLAG,
	enabled, false));
	mUiDevice.waitForIdle();
	}

	private boolean hasPreInstalledRecognizer(String packageName) {
	Log.v(TAG, "hasPreInstalledRecognizer package=" + packageName);
	try {
	final PackageManager pm = mContext.getPackageManager();
	final ApplicationInfo info = pm.getApplicationInfo(packageName, 0);
	return ((info.flags & ApplicationInfo.FLAG_SYSTEM) != 0);
	} catch (PackageManager.NameNotFoundException e) {
	return false;
	}
	}

	private static String getComponentPackageNameFromString(String from) {
	ComponentName componentName = from != null ? ComponentName.unflattenFromString(from) : null;
	return componentName != null ? componentName.getPackageName() : "";
	}

	@Test
	@CddTest(requirements = {"9.8.2/H-4-1"})
	public void testNonTrustedRecognitionServiceCanBlameCallingApp() throws Throwable {
	// Save currently selected recognition service.
	String previousRecognizer = getCurrentRecognizer();

	// We treat trusted if the current voice recognizer is also a preinstalled app.
	// This is an untrusted case.
	setCurrentRecognizer(CTS_VOICE_RECOGNITION_SERVICE);

	try {
	// Verify that the untrusted app cannot blame the calling app mic access.
	testVoiceRecognitionServiceBlameCallingApp(/* trustVoiceService */ false);
	} finally {
	// Reinstate previously selected recognition service.
	setCurrentRecognizer(previousRecognizer);
	}
	}

	@Test
	@CddTest(requirements = {"9.8.2/H-4-1"})
	public void testTrustedRecognitionServiceCanBlameCallingApp() throws Throwable {
	// We treat trusted if the current voice recognizer is also a preinstalled app. This is a
	// trusted case.
	boolean hasPreInstalledRecognizer = hasPreInstalledRecognizer(
	getComponentPackageNameFromString(mOriginalVoiceRecognizer));
	assumeTrue("No preinstalled recognizer.", hasPreInstalledRecognizer);

	// verify that the trusted app can blame the calling app mic access
	testVoiceRecognitionServiceBlameCallingApp(/* trustVoiceService */ true);
	}

	private void testVoiceRecognitionServiceBlameCallingApp(boolean trustVoiceService)
	throws Throwable {
	// Start SpeechRecognition
	mActivity.startListeningDefault();

	if (isTv()) {
	assertTvIndicatorsShown(trustVoiceService);
	} else {
	assertPrivacyChipAndIndicatorsPresent(trustVoiceService);
	}
	}

	private void assertTvIndicatorsShown(boolean trustVoiceService) {
	Log.v(TAG, "assertTvIndicatorsShown");
	final WindowManagerStateHelper wmState = new WindowManagerStateHelper();
	wmState.waitFor(
	state -> {
	if (trustVoiceService) {
	return state.containsWindow(TV_MIC_INDICATOR_WINDOW_TITLE)
	&& state.isWindowVisible(TV_MIC_INDICATOR_WINDOW_TITLE);
	} else {
	return !state.containsWindow(TV_MIC_INDICATOR_WINDOW_TITLE);
	}
	},
	"Waiting for the mic indicator window to come up");
	}

	private void assertPrivacyChipAndIndicatorsPresent(boolean trustVoiceService) throws Exception {
	// Open notification and verify the privacy indicator is shown
	mUiDevice.openQuickSettings();

	String chipId = chipId();
	final UiObject2 privacyChip =
	SystemUtil.getEventually(() -> {
	final UiObject2 foundChip =
	mUiDevice.findObject(By.res(PRIVACY_CHIP_PACKAGE_NAME, chipId));
	assertWithMessage("Can not find mic indicator").that(foundChip).isNotNull();
	return foundChip;
	});

	// Make sure dialog is shown
	BySelector selector;
	if (isCar()) {
	selector = By.res(PRIVACY_DIALOG_PACKAGE_NAME, CAR_PRIVACY_DIALOG_CONTENT_ID);
	} else if (mSafetyCenterEnabled) {
	selector =
	byEitherRes(
	SC_PRIVACY_DIALOG_PACKAGE_NAME,
	SC_PRIVACY_DIALOG_CONTENT_ID,
	PRIVACY_DIALOG_PACKAGE_NAME,
	PRIVACY_DIALOG_CONTENT_V2_ID);
	} else {
	selector = By.res(PRIVACY_DIALOG_PACKAGE_NAME, PRIVACY_DIALOG_CONTENT_ID);
	}

	// Click the privacy indicator and verify the calling app name display status in the dialog.
	privacyChip.click();
	List<UiObject2> recognitionCallingAppLabels =
	SystemUtil.getEventually(() -> {
	List<UiObject2> labels = mUiDevice.findObjects(selector);
	assertWithMessage("No permission dialog shown after clicking privacy chip.")
	.that(labels).isNotEmpty();
	return labels;
	});

	// get dialog content
	String dialogDescription = recognitionCallingAppLabels
	.stream()
	.map(UiObject2::getText)
	.collect(Collectors.joining("\n"));
	Log.i(TAG, "Retrieved dialog description " + dialogDescription);

	if (trustVoiceService) {
	// Check trust recognizer can blame calling apmic permission
	assertWithMessage(
	"Trusted voice recognition service can blame the calling app name " + APP_LABEL
	+ ", but does not find it.")
	.that(dialogDescription)
	.contains(APP_LABEL);

	// Check trust recognizer cannot blame non-mic permission
	assertWithMessage("Trusted voice recognition service cannot blame non-mic permission")
	.that(dialogDescription)
	.doesNotContain(mCameraLabel);
	} else {
	assertWithMessage(
	"Untrusted voice recognition service cannot blame the calling app name "
	+ APP_LABEL)
	.that(dialogDescription)
	.doesNotContain(APP_LABEL);
	}

	if (isCar()) {
	// In cars the privacy chip will continue showing while the recognizer still has a
	// session in progress
	mActivity.destroyRecognizerDefault();
	privacyChip.click();
	}
	// Wait for the privacy indicator to disappear to avoid the test becoming flaky.
	waitForNoIndicator(chipId);
	}

	@NonNull
	private String chipId() {
	return isCar() ? CAR_MIC_PRIVACY_CHIP_ID : PRIVACY_CHIP_ID;
	}

	private void waitForNoIndicator(String chipId) {
	SystemUtil.eventually(() -> {
	final UiObject2 foundChip =
	mUiDevice.findObject(By.res(PRIVACY_CHIP_PACKAGE_NAME, chipId));
	assertWithMessage("Chip still visible.").that(foundChip).isNull();
	}, LONGER_TIMEOUT);
	}


	private boolean isTv() {
	PackageManager pm = mContext.getPackageManager();
	return pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK);
	}

	private boolean isCar() {
	PackageManager pm = mContext.getPackageManager();
	return pm.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE);
	}

	private boolean isWatch() {
	PackageManager pm = mContext.getPackageManager();
	return pm.hasSystemFeature(PackageManager.FEATURE_WATCH);
	}

	private static BySelector byEitherRes(
	String resourcePackageA,
	String resourceIdA,
	String resourcePackageB,
	String resourceIdB) {
	return By.res(
	Pattern.compile(
	String.format(
	"%s\|%s",
	resourceNameLiteral(resourcePackageA, resourceIdA),
	resourceNameLiteral(resourcePackageB, resourceIdB))));
	}

	private static String resourceNameLiteral(String resourcePackage, String resourceId) {
	return Pattern.quote(String.format("%s:id/%s", resourcePackage, resourceId));
	}
	}