src/com/android/car/settings/enterprise/DeviceAdminAddFragment.java - platform/packages/apps/Car/Settings - Git at Google

 /*
  * Copyright (C) 2021 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.car.settings.enterprise;

 import static android.app.Activity.RESULT_OK;
 import static android.os.Process.myUserHandle;

 import static com.android.car.settings.enterprise.EnterpriseUtils.getAdminWithinPackage;
 import static com.android.car.settings.enterprise.EnterpriseUtils.getDeviceAdminInfo;

 import android.app.Activity;
 import android.app.admin.DeviceAdminInfo;
 import android.app.admin.DeviceAdminReceiver;
 import android.app.admin.DevicePolicyManager;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.net.Uri;
 import android.text.TextUtils;

 import androidx.annotation.VisibleForTesting;
 import androidx.preference.PreferenceScreen;

 import com.android.car.settings.R;
 import com.android.car.settings.common.Logger;
 import com.android.car.settings.common.PreferenceController;
 import com.android.car.settings.common.SettingsFragment;
 import com.android.car.ui.toolbar.MenuItem;
 import com.android.car.ui.toolbar.ToolbarController;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 /**
  * A screen that shows details about a device administrator.
  */
 public final class DeviceAdminAddFragment extends SettingsFragment {

     private static final Logger LOG = new Logger(DeviceAdminAddFragment.class);

     @VisibleForTesting
     static final int UNINSTALL_DEVICE_ADMIN_REQUEST_CODE = 12;

     private CharSequence mAppName;
     private DevicePolicyManager mDpm;
     private String mPackageToUninstall;
     private ComponentName mAdminComponentToUninstall;
     private boolean mIsActive;
     private MenuItem mUninstallButton;

     @VisibleForTesting
     void setDevicePolicyManager(DevicePolicyManager dpm) {
         mDpm = dpm;
     }

     @Override
     protected int getPreferenceScreenResId() {
         return R.xml.device_admin_add;
     }

     @Override
     public List<MenuItem> getToolbarMenuItems() {
         return Collections.singletonList(mUninstallButton);
     }

     @Override
     public void onAttach(Context context) {
         super.onAttach(context);

         // Split in 2 as it would be hard to mock requireActivity();
         onAttach(context, requireActivity());
     }

     @VisibleForTesting
     void onAttach(Context context, Activity activity) {
         setDevicePolicyManager(context.getSystemService(DevicePolicyManager.class));
         Intent intent = activity.getIntent();
         if (intent == null) {
             LOG.e("no intent on " + activity);
             activity.finish();
             return;
         }

         ComponentName admin = (ComponentName)
                 intent.getParcelableExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN);
         LOG.d("Admin using " + DevicePolicyManager.EXTRA_DEVICE_ADMIN + ": " + admin);
         if (admin == null) {
             String adminPackage = intent
                     .getStringExtra(DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME);
             LOG.d("Admin package using " + DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME
                     + ": " + adminPackage);
             if (adminPackage == null) {
                 LOG.w("Finishing " + activity + " as its intent doesn't have "
                         +  DevicePolicyManager.EXTRA_DEVICE_ADMIN + " or "
                         + DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME);
                 activity.finish();
                 return;
             }
             admin = getAdminWithinPackage(context, adminPackage);
             if (admin == null) {
                 LOG.w("Finishing " + activity + " as there is no active admin for " + adminPackage);
                 activity.finish();
                 return;
             }
             // DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME is set only when DeviceAdmin
             // is called via Apps -> Uninstall for an active device admin. Set the package name to
             // uninstall, which will enable and show the "Deactivate & uninstall" button.
             setPackageToUninstall(adminPackage, admin);
         } else {
             // When activating, make sure the given component name is actually a valid device admin.
             // No need to check this when deactivating, because it is safe to deactivate an active
             // invalid device admin.
             if (!isValidAdmin(context, admin)) {
                 LOG.w("Request to add invalid device admin: " + admin.flattenToShortString());
                 activity.finish();
                 return;
             }
         }

         // TODO(b/202342351): both this method and isValidAdmin() call PM to get the ActivityInfo;
         // they should be refactored so it's called just onces; similarly, isValidAdmin()
         // also create a DeviceAdminInfo
         DeviceAdminInfo deviceAdminInfo = getDeviceAdminInfo(context, admin);
         LOG.d("Admin: " + admin + " DeviceAdminInfo: " + deviceAdminInfo);

         if (deviceAdminInfo == null) {
             LOG.w("Finishing " + activity + " as it could not get DeviceAdminInfo for "
                     + admin.flattenToShortString());
             activity.finish();
             return;
         }

         // This admin already exists, and we have two options at this point:
         // 1. If new policy bits are set, show the user the new list.
         // 2. If nothing has changed, simply return "OK" immediately.
         if (isActionAddDeviceAdminActivity(activity)) {
             boolean refreshing = false;
             if (mDpm.isAdminActive(admin)) {
                 if (mDpm.isRemovingAdmin(admin, myUserHandle().getIdentifier())) {
                     LOG.w("Requested admin is already being removed: " + admin);
                     activity.finish();
                     return;
                 }
                 ArrayList<DeviceAdminInfo.PolicyInfo> policies = deviceAdminInfo.getUsedPolicies();
                 for (int i = 0, size = policies.size(); i < size; i++) {
                     DeviceAdminInfo.PolicyInfo pi = policies.get(i);
                     if (!mDpm.hasGrantedPolicy(admin, pi.ident)) {
                         refreshing = true;
                         break;
                     }
                 }
                 LOG.i("Try to add device admin for " + admin + ", refreshing=" + refreshing);
                 if (!refreshing) {
                     // Nothing changed (or policies were removed) - return immediately
                     activity.setResult(Activity.RESULT_OK);
                     activity.finish();
                     return;
                 }
                 // Update the active admin with the refreshed policies.
                 mDpm.setActiveAdmin(admin, refreshing);
             }
         }

         mAppName = deviceAdminInfo.loadLabel(context.getPackageManager());

         boolean showUninstallButton =
                 (mPackageToUninstall != null) && (mAdminComponentToUninstall != null);
         setUninstallButton(context, showUninstallButton);

         ((DeviceAdminAddHeaderPreferenceController) use(
                 DeviceAdminAddHeaderPreferenceController.class,
                 R.string.pk_device_admin_add_header).setDeviceAdmin(deviceAdminInfo))
                         .setActivationListener((value) -> onActivation(value));
         ((DeviceAdminAddExplanationPreferenceController) use(
                 DeviceAdminAddExplanationPreferenceController.class,
                 R.string.pk_device_admin_add_explanation).setDeviceAdmin(deviceAdminInfo))
                         .setExplanation(intent
                                 .getCharSequenceExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION));
         use(DeviceAdminAddWarningPreferenceController.class,
                 R.string.pk_device_admin_add_warning).setDeviceAdmin(deviceAdminInfo);
         use(DeviceAdminAddPoliciesPreferenceController.class,
                 R.string.pk_device_admin_add_policies).setDeviceAdmin(deviceAdminInfo);
         use(DeviceAdminAddSupportPreferenceController.class,
                 R.string.pk_device_admin_add_support).setDeviceAdmin(deviceAdminInfo);
     }

     private void onActivation(boolean value) {
         Activity activity = requireActivity();
         if (!isActionAddDeviceAdminActivity(activity)) {
             return;
         }

         int result = value ? Activity.RESULT_OK : Activity.RESULT_CANCELED;
         LOG.d("Setting " + activity + " result to " + result);
         activity.setResult(result);
     }

     @VisibleForTesting
     void setPackageToUninstall(String packageName, ComponentName componentName) {
         mPackageToUninstall = packageName;
         mAdminComponentToUninstall = componentName;
     }

     @VisibleForTesting
     void setUninstallButton(Context context, boolean showButton) {
         mUninstallButton = new MenuItem.Builder(context)
                 .setTitle(R.string.deactivate_and_uninstall_device_admin)
                 .setEnabled(showButton)
                 .setVisible(showButton)
                 .setOnClickListener(i -> startUninstall())
                 .build();
     }

     @VisibleForTesting
     void startUninstall() {
         mIsActive = mDpm.isAdminActive(mAdminComponentToUninstall);
         if (mIsActive) {
             LOG.i("Deactivating device admin: " + mAdminComponentToUninstall);
             mDpm.removeActiveAdmin(mAdminComponentToUninstall);
         }
         LOG.i("Uninstalling package: " + mPackageToUninstall);
         Uri packageUri = Uri.parse("package:" + mPackageToUninstall);
         Intent uninstallIntent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE, packageUri);
         uninstallIntent.putExtra(Intent.EXTRA_RETURN_RESULT, true);
         startActivityForResult(uninstallIntent, UNINSTALL_DEVICE_ADMIN_REQUEST_CODE);
     }

     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
         // Call super method to handle callback.
         super.onActivityResult(requestCode, resultCode, data);
         if (requestCode != UNINSTALL_DEVICE_ADMIN_REQUEST_CODE) {
             return;
         }
         if (resultCode == RESULT_OK) {
             Activity activity = requireActivity();
             // On successful uninstalling, sets the results and finish the activity.
             activity.setResult(RESULT_OK);
             activity.finish();
         } else {
             if (mIsActive) {
                 // Set active admin back when uninstalling was failed/canceled.
                 mDpm.setActiveAdmin(mAdminComponentToUninstall, /* refreshing= */ false);
             }
             LOG.e("Uninstall failed with result " + resultCode);
         }
     }

     @Override
     public void setPreferenceScreen(PreferenceScreen preferenceScreen) {
         super.setPreferenceScreen(preferenceScreen);

         // Split for testing, to avoid calling super.setPreferenceScreen() in tests.
         setPreferenceScreenTitle(preferenceScreen);
     }

     @VisibleForTesting
     void setPreferenceScreenTitle(PreferenceScreen preferenceScreen) {
         if (!TextUtils.isEmpty(mAppName)) {
             preferenceScreen.setTitle(mAppName);
         }
     }

     @Override
     protected void setupToolbar(ToolbarController toolbar) {
         super.setupToolbar(toolbar);

         // Must split in 2, otherwise tests would need to mock what's needed by super.setupToolbar()
         setToolbarTitle(toolbar);
     }

     @VisibleForTesting
     void setToolbarTitle(ToolbarController toolbar) {
         if (isActionAddDeviceAdminActivity(requireActivity())) {
             toolbar.setTitle(R.string.add_device_admin_msg);
         }
     }

     private boolean isActionAddDeviceAdminActivity(Activity activity) {
         Intent intent = activity.getIntent();
         String action = intent == null ? null : intent.getAction();
         return DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN.equals(action);
     }

     // Must override so it can be spied (it's the exact same signature and modifier access, but it
     // works now because the test class is in the same package).
     @Override
     protected <T extends PreferenceController> T use(Class<T> clazz, int preferenceKeyResId) {
         return super.use(clazz, preferenceKeyResId);
     }

     private boolean isValidAdmin(Context context, ComponentName who) {
         PackageManager pm = context.getPackageManager();
         ActivityInfo ai;
         try {
             ai = pm.getReceiverInfo(who, PackageManager.GET_META_DATA);
         } catch (PackageManager.NameNotFoundException e) {
             LOG.w("Unable to retrieve device policy " + who, e);
             return false;
         }

         if (mDpm.isAdminActive(who)) {
             return true;
         }
         List<ResolveInfo> avail = pm.queryBroadcastReceivers(
                 new Intent(DeviceAdminReceiver.ACTION_DEVICE_ADMIN_ENABLED),
                 PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS);
         int count = avail == null ? 0 : avail.size();
         boolean found = false;
         for (int i = 0; i < count; i++) {
             ResolveInfo ri = avail.get(i);
             if (ai.packageName.equals(ri.activityInfo.packageName)
                     && ai.name.equals(ri.activityInfo.name)) {
                 try {
                     // We didn't retrieve the meta data for all possible matches, so
                     // need to use the activity info of this specific one that was retrieved.
                     ri.activityInfo = ai;
                     new DeviceAdminInfo(context, ri);
                     found = true;
                 } catch (Exception e) {
                     LOG.w("Bad " + ri.activityInfo, e);
                 }
                 break;
             }
         }
         if (!found) {
             LOG.d("didn't find enabled admin receiver for " + who.flattenToShortString());
         }
         return found;
     }
 }
	/*
	* Copyright (C) 2021 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.car.settings.enterprise;

	import static android.app.Activity.RESULT_OK;
	import static android.os.Process.myUserHandle;

	import static com.android.car.settings.enterprise.EnterpriseUtils.getAdminWithinPackage;
	import static com.android.car.settings.enterprise.EnterpriseUtils.getDeviceAdminInfo;

	import android.app.Activity;
	import android.app.admin.DeviceAdminInfo;
	import android.app.admin.DeviceAdminReceiver;
	import android.app.admin.DevicePolicyManager;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.ActivityInfo;
	import android.content.pm.PackageManager;
	import android.content.pm.ResolveInfo;
	import android.net.Uri;
	import android.text.TextUtils;

	import androidx.annotation.VisibleForTesting;
	import androidx.preference.PreferenceScreen;

	import com.android.car.settings.R;
	import com.android.car.settings.common.Logger;
	import com.android.car.settings.common.PreferenceController;
	import com.android.car.settings.common.SettingsFragment;
	import com.android.car.ui.toolbar.MenuItem;
	import com.android.car.ui.toolbar.ToolbarController;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	/**
	* A screen that shows details about a device administrator.
	*/
	public final class DeviceAdminAddFragment extends SettingsFragment {

	private static final Logger LOG = new Logger(DeviceAdminAddFragment.class);

	@VisibleForTesting
	static final int UNINSTALL_DEVICE_ADMIN_REQUEST_CODE = 12;

	private CharSequence mAppName;
	private DevicePolicyManager mDpm;
	private String mPackageToUninstall;
	private ComponentName mAdminComponentToUninstall;
	private boolean mIsActive;
	private MenuItem mUninstallButton;

	@VisibleForTesting
	void setDevicePolicyManager(DevicePolicyManager dpm) {
	mDpm = dpm;
	}

	@Override
	protected int getPreferenceScreenResId() {
	return R.xml.device_admin_add;
	}

	@Override
	public List<MenuItem> getToolbarMenuItems() {
	return Collections.singletonList(mUninstallButton);
	}

	@Override
	public void onAttach(Context context) {
	super.onAttach(context);

	// Split in 2 as it would be hard to mock requireActivity();
	onAttach(context, requireActivity());
	}

	@VisibleForTesting
	void onAttach(Context context, Activity activity) {
	setDevicePolicyManager(context.getSystemService(DevicePolicyManager.class));
	Intent intent = activity.getIntent();
	if (intent == null) {
	LOG.e("no intent on " + activity);
	activity.finish();
	return;
	}

	ComponentName admin = (ComponentName)
	intent.getParcelableExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN);
	LOG.d("Admin using " + DevicePolicyManager.EXTRA_DEVICE_ADMIN + ": " + admin);
	if (admin == null) {
	String adminPackage = intent
	.getStringExtra(DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME);
	LOG.d("Admin package using " + DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME
	+ ": " + adminPackage);
	if (adminPackage == null) {
	LOG.w("Finishing " + activity + " as its intent doesn't have "
	+ DevicePolicyManager.EXTRA_DEVICE_ADMIN + " or "
	+ DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME);
	activity.finish();
	return;
	}
	admin = getAdminWithinPackage(context, adminPackage);
	if (admin == null) {
	LOG.w("Finishing " + activity + " as there is no active admin for " + adminPackage);
	activity.finish();
	return;
	}
	// DeviceAdminAddActivity.EXTRA_DEVICE_ADMIN_PACKAGE_NAME is set only when DeviceAdmin
	// is called via Apps -> Uninstall for an active device admin. Set the package name to
	// uninstall, which will enable and show the "Deactivate & uninstall" button.
	setPackageToUninstall(adminPackage, admin);
	} else {
	// When activating, make sure the given component name is actually a valid device admin.
	// No need to check this when deactivating, because it is safe to deactivate an active
	// invalid device admin.
	if (!isValidAdmin(context, admin)) {
	LOG.w("Request to add invalid device admin: " + admin.flattenToShortString());
	activity.finish();
	return;
	}
	}

	// TODO(b/202342351): both this method and isValidAdmin() call PM to get the ActivityInfo;
	// they should be refactored so it's called just onces; similarly, isValidAdmin()
	// also create a DeviceAdminInfo
	DeviceAdminInfo deviceAdminInfo = getDeviceAdminInfo(context, admin);
	LOG.d("Admin: " + admin + " DeviceAdminInfo: " + deviceAdminInfo);

	if (deviceAdminInfo == null) {
	LOG.w("Finishing " + activity + " as it could not get DeviceAdminInfo for "
	+ admin.flattenToShortString());
	activity.finish();
	return;
	}

	// This admin already exists, and we have two options at this point:
	// 1. If new policy bits are set, show the user the new list.
	// 2. If nothing has changed, simply return "OK" immediately.
	if (isActionAddDeviceAdminActivity(activity)) {
	boolean refreshing = false;
	if (mDpm.isAdminActive(admin)) {
	if (mDpm.isRemovingAdmin(admin, myUserHandle().getIdentifier())) {
	LOG.w("Requested admin is already being removed: " + admin);
	activity.finish();
	return;
	}
	ArrayList<DeviceAdminInfo.PolicyInfo> policies = deviceAdminInfo.getUsedPolicies();
	for (int i = 0, size = policies.size(); i < size; i++) {
	DeviceAdminInfo.PolicyInfo pi = policies.get(i);
	if (!mDpm.hasGrantedPolicy(admin, pi.ident)) {
	refreshing = true;
	break;
	}
	}
	LOG.i("Try to add device admin for " + admin + ", refreshing=" + refreshing);
	if (!refreshing) {
	// Nothing changed (or policies were removed) - return immediately
	activity.setResult(Activity.RESULT_OK);
	activity.finish();
	return;
	}
	// Update the active admin with the refreshed policies.
	mDpm.setActiveAdmin(admin, refreshing);
	}
	}

	mAppName = deviceAdminInfo.loadLabel(context.getPackageManager());

	boolean showUninstallButton =
	(mPackageToUninstall != null) && (mAdminComponentToUninstall != null);
	setUninstallButton(context, showUninstallButton);

	((DeviceAdminAddHeaderPreferenceController) use(
	DeviceAdminAddHeaderPreferenceController.class,
	R.string.pk_device_admin_add_header).setDeviceAdmin(deviceAdminInfo))
	.setActivationListener((value) -> onActivation(value));
	((DeviceAdminAddExplanationPreferenceController) use(
	DeviceAdminAddExplanationPreferenceController.class,
	R.string.pk_device_admin_add_explanation).setDeviceAdmin(deviceAdminInfo))
	.setExplanation(intent
	.getCharSequenceExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION));
	use(DeviceAdminAddWarningPreferenceController.class,
	R.string.pk_device_admin_add_warning).setDeviceAdmin(deviceAdminInfo);
	use(DeviceAdminAddPoliciesPreferenceController.class,
	R.string.pk_device_admin_add_policies).setDeviceAdmin(deviceAdminInfo);
	use(DeviceAdminAddSupportPreferenceController.class,
	R.string.pk_device_admin_add_support).setDeviceAdmin(deviceAdminInfo);
	}

	private void onActivation(boolean value) {
	Activity activity = requireActivity();
	if (!isActionAddDeviceAdminActivity(activity)) {
	return;
	}

	int result = value ? Activity.RESULT_OK : Activity.RESULT_CANCELED;
	LOG.d("Setting " + activity + " result to " + result);
	activity.setResult(result);
	}

	@VisibleForTesting
	void setPackageToUninstall(String packageName, ComponentName componentName) {
	mPackageToUninstall = packageName;
	mAdminComponentToUninstall = componentName;
	}

	@VisibleForTesting
	void setUninstallButton(Context context, boolean showButton) {
	mUninstallButton = new MenuItem.Builder(context)
	.setTitle(R.string.deactivate_and_uninstall_device_admin)
	.setEnabled(showButton)
	.setVisible(showButton)
	.setOnClickListener(i -> startUninstall())
	.build();
	}

	@VisibleForTesting
	void startUninstall() {
	mIsActive = mDpm.isAdminActive(mAdminComponentToUninstall);
	if (mIsActive) {
	LOG.i("Deactivating device admin: " + mAdminComponentToUninstall);
	mDpm.removeActiveAdmin(mAdminComponentToUninstall);
	}
	LOG.i("Uninstalling package: " + mPackageToUninstall);
	Uri packageUri = Uri.parse("package:" + mPackageToUninstall);
	Intent uninstallIntent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE, packageUri);
	uninstallIntent.putExtra(Intent.EXTRA_RETURN_RESULT, true);
	startActivityForResult(uninstallIntent, UNINSTALL_DEVICE_ADMIN_REQUEST_CODE);
	}

	@Override
	public void onActivityResult(int requestCode, int resultCode, Intent data) {
	// Call super method to handle callback.
	super.onActivityResult(requestCode, resultCode, data);
	if (requestCode != UNINSTALL_DEVICE_ADMIN_REQUEST_CODE) {
	return;
	}
	if (resultCode == RESULT_OK) {
	Activity activity = requireActivity();
	// On successful uninstalling, sets the results and finish the activity.
	activity.setResult(RESULT_OK);
	activity.finish();
	} else {
	if (mIsActive) {
	// Set active admin back when uninstalling was failed/canceled.
	mDpm.setActiveAdmin(mAdminComponentToUninstall, /* refreshing= */ false);
	}
	LOG.e("Uninstall failed with result " + resultCode);
	}
	}

	@Override
	public void setPreferenceScreen(PreferenceScreen preferenceScreen) {
	super.setPreferenceScreen(preferenceScreen);

	// Split for testing, to avoid calling super.setPreferenceScreen() in tests.
	setPreferenceScreenTitle(preferenceScreen);
	}

	@VisibleForTesting
	void setPreferenceScreenTitle(PreferenceScreen preferenceScreen) {
	if (!TextUtils.isEmpty(mAppName)) {
	preferenceScreen.setTitle(mAppName);
	}
	}

	@Override
	protected void setupToolbar(ToolbarController toolbar) {
	super.setupToolbar(toolbar);

	// Must split in 2, otherwise tests would need to mock what's needed by super.setupToolbar()
	setToolbarTitle(toolbar);
	}

	@VisibleForTesting
	void setToolbarTitle(ToolbarController toolbar) {
	if (isActionAddDeviceAdminActivity(requireActivity())) {
	toolbar.setTitle(R.string.add_device_admin_msg);
	}
	}

	private boolean isActionAddDeviceAdminActivity(Activity activity) {
	Intent intent = activity.getIntent();
	String action = intent == null ? null : intent.getAction();
	return DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN.equals(action);
	}

	// Must override so it can be spied (it's the exact same signature and modifier access, but it
	// works now because the test class is in the same package).
	@Override
	protected <T extends PreferenceController> T use(Class<T> clazz, int preferenceKeyResId) {
	return super.use(clazz, preferenceKeyResId);
	}

	private boolean isValidAdmin(Context context, ComponentName who) {
	PackageManager pm = context.getPackageManager();
	ActivityInfo ai;
	try {
	ai = pm.getReceiverInfo(who, PackageManager.GET_META_DATA);
	} catch (PackageManager.NameNotFoundException e) {
	LOG.w("Unable to retrieve device policy " + who, e);
	return false;
	}

	if (mDpm.isAdminActive(who)) {
	return true;
	}
	List<ResolveInfo> avail = pm.queryBroadcastReceivers(
	new Intent(DeviceAdminReceiver.ACTION_DEVICE_ADMIN_ENABLED),
	PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS);
	int count = avail == null ? 0 : avail.size();
	boolean found = false;
	for (int i = 0; i < count; i++) {
	ResolveInfo ri = avail.get(i);
	if (ai.packageName.equals(ri.activityInfo.packageName)
	&& ai.name.equals(ri.activityInfo.name)) {
	try {
	// We didn't retrieve the meta data for all possible matches, so
	// need to use the activity info of this specific one that was retrieved.
	ri.activityInfo = ai;
	new DeviceAdminInfo(context, ri);
	found = true;
	} catch (Exception e) {
	LOG.w("Bad " + ri.activityInfo, e);
	}
	break;
	}
	}
	if (!found) {
	LOG.d("didn't find enabled admin receiver for " + who.flattenToShortString());
	}
	return found;
	}
	}