+As an IT administrator, you can configure Android 6.0 Marshmallow and later +devices as corporate-owned, single-use (COSU) devices. These are Android +devices used for a single purpose, such as digital signage, ticket printing, +point of sale, or inventory management. To use Android devices as COSU devices, +you need to develop Android apps that your customers can manage. +
+ ++Your customers can configure COSU devices: +
+Android 5.0 Lollipop introduced two new ways to configure Android devices +for a single purpose: +
+ ++This graphic compares the features of app pinning and lock task mode: +
+ +
+
+ + Figure 1. Comparing the features of app pinning in Lollipop + vs. Lock task mode in Marshmallow and later +
+ ++In Lollipop, you can pin a single application to cover the full screen, but +only apps whitelisted by the device policy controller (DPC) can be locked. +
+ ++ To use LockTask mode, and the APIs that manage COSU devices, there must be + a device owner application installed on the device. Device owners are a + type of device policy controller (DPC) that manages the whole device. For + more information about DPCs, see the + EMM Developer’s Overview. +
+ ++If you’re creating a new COSU app, we recommend you develop it for +Marshmallow or later, which includes the following COSU features: +
+ ++ Note: If you develop COSU features targeted for + Marshmallow devices, your app can still be compatible with prior + versions of Android. +
+ ++Additional COSU management features launched with Marshmallow make it easier to +develop and deploy Android devices as a single-use device. If you want to +enforce server-side app restrictions or server-side profile policy controls, +you need to use an EMM or make your application a DPC. Follow the instructions +below as you create your application. +
+ ++ There are two different ways to manage COSU devices: +
+ ++In this section, you’ll need to do a small amount of development to +have your device work with a third-party EMM. +
+ ++If you need to add COSU functionality to an existing app, make sure that +the customer’s EMM supports {@link android.R.attr#lockTaskMode}. +
+ ++Starting from Marshmallow, if your app is whitelisted by an EMM using {@link +android.app.admin.DevicePolicyManager#setLockTaskPackages setLockTaskPackages}, +your activities can automatically start lock task mode when the app is +launched. +
+ ++ The {@link android.R.attr#lockTaskMode} attribute allows you to define + your app’s lock task mode behavior in the AndroidManifest.xml file: +
+ +if_whitelisted,
+you don’t need to call {@link android.app.Activity#startLockTask()}, and the
+app automatically enters into lock task mode.
+To have your activity automatically enter {@link android.R.attr#lockTaskMode},
+change the value of this attribute to if_whitelisted.
+Doing so causes your app to behave in this manner:
+
+Example XML as follows: +
+ +<activity android:name=".MainActivity" android:lockTaskMode="if_whitelisted">+ +
+Given either of these options, you still need to create a mechanism for +calling {@link android.app.Activity#stopLockTask()} so that users can +exit {@link android.R.attr#lockTaskMode}. +
+ ++To manage applications in COSU, you need a DPC running as device +owner to set several policies on the device. +
+ ++Note: This setup is advanced, and requires +a thorough understanding of the EMM concepts described in the +EMM developer overview. +For more information about building a DPC, see +Provision Customer Devices. +
+ ++To create a DPC app that can manage COSU device configuration, +the DPC needs to: +
+ ++Here’s an example of how to implement an activity that starts lock task mode +and implements the relevant COSU device management APIs: +
+ +
+public class CosuActivity extends Activity {
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ mAdminComponentName = DeviceAdminReceiver.getComponentName(this);
+ mDevicePolicyManager = (DevicePolicyManager) getSystemService(
+ Context.DEVICE_POLICY_SERVICE);
+ mPackageManager = getPackageManager();
+ setDefaultCosuPolicies(true);
+ }
+
+ @Override
+ protected void onStart() {
+ super.onStart();
+
+ // start lock task mode if it's not already active
+ ActivityManager am = (ActivityManager) getSystemService(
+ Context.ACTIVITY_SERVICE);
+ // ActivityManager.getLockTaskModeState api is not available in pre-M.
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ if (!am.isInLockTaskMode()) {
+ startLockTask();
+ }
+ } else {
+ if (am.getLockTaskModeState() ==
+ ActivityManager.LOCK_TASK_MODE_NONE) {
+ startLockTask();
+ }
+ }
+ }
+
+ private void setDefaultCosuPolicies(boolean active) {
+ // set user restrictions
+ setUserRestriction(DISALLOW_SAFE_BOOT, active);
+ setUserRestriction(DISALLOW_FACTORY_RESET, active);
+ setUserRestriction(DISALLOW_ADD_USER, active);
+ setUserRestriction(DISALLOW_MOUNT_PHYSICAL_MEDIA, active);
+ setUserRestriction(DISALLOW_ADJUST_VOLUME, active);
+
+ // disable keyguard and status bar
+ mDevicePolicyManager.setKeyguardDisabled(mAdminComponentName, active);
+ mDevicePolicyManager.setStatusBarDisabled(mAdminComponentName, active);
+
+ // enable STAY_ON_WHILE_PLUGGED_IN
+ enableStayOnWhilePluggedIn(active);
+
+ // set System Update policy
+
+ if (active){
+ mDevicePolicyManager.setSystemUpdatePolicy(mAdminComponentName,
+ SystemUpdatePolicy.createWindowedInstallPolicy(60,120));
+ }
+ else
+
+
+ // set this Activity as a lock task package
+
+ mDevicePolicyManager.setLockTaskPackages(mAdminComponentName,
+ active ? new String[]{getPackageName()} : new String[]{});
+
+ IntentFilter intentFilter = new IntentFilter(Intent.ACTION_MAIN);
+ intentFilter.addCategory(Intent.CATEGORY_HOME);
+ intentFilter.addCategory(Intent.CATEGORY_DEFAULT);
+
+ if (active) {
+ // set Cosu activity as home intent receiver so that it is started
+ // on reboot
+ mDevicePolicyManager.addPersistentPreferredActivity(
+ mAdminComponentName, intentFilter, new ComponentName(
+ getPackageName(), CosuModeActivity.class.getName()))
+ } else {
+ mDevicePolicyManager.clearPackagePersistentPreferredActivities(
+ mAdminComponentName, getPackageName());
+ }
+ }
+
+ private void setUserRestriction(String restriction, boolean disallow) {
+ if (disallow) {
+ mDevicePolicyManager.addUserRestriction(mAdminComponentName,
+ restriction);
+ } else {
+ mDevicePolicyManager.clearUserRestriction(mAdminComponentName,
+ restriction);
+ }
+ }
+
+ private void enableStayOnWhilePluggedIn(boolean enabled) {
+ if (enabled) {
+ mDevicePolicyManager.setGlobalSetting(
+ mAdminComponentName,
+ Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+ BatteryManager.BATTERY_PLUGGED_AC
+ | BatteryManager.BATTERY_PLUGGED_USB
+ | BatteryManager.BATTERY_PLUGGED_WIRELESS);
+ } else {
+ mDevicePolicyManager.setGlobalSetting(
+ mAdminComponentName,
+ Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
+ }
+
+ }
+
+ // TODO: Implement the rest of the Activity
+}
+
+
+
++ If you’re planning to support a third-party EMM, develop an end-to-end + testing plan utilizing the EMM’s app. We also provide testing resources, + which you can use to create your own Test Device Policy Client (Test DPC): +
+ +