An administrator can use this API to blacklist third-party applications (applications that are not part of the system image) based on the application package name. An application with a matching application package name cannot be installed. If the application package is already installed, the API does not affect the existing installation. If the application package is uninstalled, the package cannot be installed until the application package name is either removed from the blacklist or added to the whitelist.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

Installing via ADB installs package to all users by default in multi user enabled devices. So if administrator has disabled the package installation for any user then for all users installations will be blocked via ADB.

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ApplicationPolicy appPolicy = edm.getApplicationPolicy();
  try {
      boolean result = appPolicy.addAppPackageNameToBlackList("com.test.app");
      if( true == result){
          Log.d(TAG,"  add a application  package name to the application"
               +"Package name has been added to blacklist successfully!");
      }else{
          Log.w(TAG," add a application  package name to the application"
              +"Addition of package name to blacklist failed.");
      }
   }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
   }
 

  // When you create container successfully, containerID will be returned via intent.
  // Use this containerID in below API.
  EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
  KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
  ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

  try {
      boolean result = appPolicy.addAppPackageNameToBlackList("com.test.app");
      if( true == result){
          Log.d(TAG,"  add a application  package name to the application"
               +"Package name has been added to blacklist successfully!");
      }else{
          Log.w(TAG," add a application  package name to the application"
              +"Addition of package name to blacklist failed.");
      }
   }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
   }
 

An application package name added to the application package name whitelist using addAppPackageNameToWhiteList(String) can still be installed. The whitelist is the exception to the blacklist. If the package name of an application currently being installed matches a package name pattern in both the blacklist and whitelist, the whitelist takes priority and the application is installed.

An administrator can use this API to add to the whitelist a third-party application (application that is not part of system image) based on the application package name. An application with a matching package name in the whitelist is an exception to the configured blacklist and allows the application to be installed.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ApplicationPolicy appPolicy = edm.getApplicationPolicy();
  try {
      boolean result = appPolicy.addAppPackageNameToWhiteList("com.test.app");
      if( true == result){
          Log.d(TAG,"add a package name to the application package name"
              +"whitelist has been successful!");
      }else{
          Log.w(TAG,"add a package name to the application package name"
                +"whitelist has failed.");
      }
  }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
  }
 

  // When you create container successfully, containerID will be returned via intent.
  // Use this containerID in below API.
  EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
  KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
  ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

  try {
      boolean result = appPolicy.addAppPackageNameToWhiteList("com.test.app");
      if( true == result){
          Log.d(TAG,"add a package name to the application package name"
              +"whitelist has been successful!");
      }else{
          Log.w(TAG,"add a package name to the application package name"
                +"whitelist has failed.");
      }
  }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
  }
 

This whitelist is an exception to the blacklist, which is created using addAppPackageNameToBlackList(String). If the package name of an application currently being installed matches the application package name pattern in both the blacklist and whitelist, the whitelist takes priority and the application is installed.

An administrator can use this API to add to the whitelist a third-party application (application that is not part of system image) based on the application package name and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages. An application with a matching package name in the whitelist is an exception to the configured blacklist and allows the application to be installed.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ApplicationPolicy appPolicy = edm.getApplicationPolicy();
  try {
      boolean result = appPolicy.addAppPackageNameToWhiteList("com.test.app",true);
      if( true == result){
          Log.d(TAG,"add a package name to the application package name"
              +"whitelist has been successful!");
      }else{
          Log.w(TAG,"add a package name to the application package name"
                +"whitelist has failed.");
      }
  }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
  }
 

  // When you create container successfully, containerID will be returned via intent.
  // Use this containerID in below API.
  EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
  KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
  ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

  try {
      boolean result = appPolicy.addAppPackageNameToWhiteList("com.test.app",true);
      if( true == result){
          Log.d(TAG,"add a package name to the application package name"
              +"whitelist has been successful!");
      }else{
          Log.w(TAG,"add a package name to the application package name"
                +"whitelist has failed.");
      }
  }catch(SecurityException e) {
         Log.w(TAG,"SecurityException: "+e);
  }
 

This whitelist is an exception to the blacklist, which is created using addAppPackageNameToBlackList(String). If the package name of an application currently being installed matches the application package name pattern in both the blacklist and whitelist, the whitelist takes priority and the application is installed.

For example, a new downloaded application that has the permission android.permission.BLUETOOTH is not allowed to install.

Installing via ADB installs package to all users by default in multi user enabled devices. So if administrator has disabled the package installation for any user then for all users installations will be blocked via ADB.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 //permission to be added to blacklist.
 String permission = "android.permission.BLUETOOTH";
 try {
     boolean result = appPolicy.addAppPermissionToBlackList(permission);
     if (true == result) {
         //permission added to blacklist
     } else {
         //permission not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 //permission to be added to blacklist.
 String permission = "android.permission.BLUETOOTH";
 try {
     boolean result = appPolicy.addAppPermissionToBlackList(permission);
     if (true == result) {
         //permission added to blacklist
     } else {
         //permission not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Installing via ADB installs package to all users by default in multi user enabled devices. So if administrator has disabled the package installation for any user then for all users installations will be blocked via ADB.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 //try to get signature of the apk to be installed
 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToBlackList(signature);
     if (true == result) {
         //signature added to blacklist
     } else {
         //signature not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 //try to get signature of the apk to be installed
 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToBlackList(signature);
     if (true == result) {
         //signature added to blacklist
     } else {
         //signature not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to whitelist a third-party application (an application that is not part of the system image) based on the signature used by the application. The administrator can use the wildcard character "*" instead of specifying a signature.

The whitelist is an exception to the blacklist that is created using addAppSignatureToBlackList(String). If the signature of an application currently being installed matches the signature in both the blacklist and whitelist, the whitelist, as an exception to the blacklist, takes priority, and the application is installed.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToWhiteList(signature);
     if (true == result) {
         // signature added to whitelist
     } else {
         // signature not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToWhiteList(signature);
     if (true == result) {
         // signature added to whitelist
     } else {
         // signature not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to whitelist a third-party application (an application that is not part of the system image) based on the signature used by the application and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages. The administrator can use the wildcard character "*" instead of specifying a signature.

The whitelist is an exception to the blacklist that is created using addAppSignatureToBlackList(String). If the signature of an application currently being installed matches the signature in both the blacklist and whitelist, the whitelist, as an exception to the blacklist, takes priority, and the application is installed.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToWhiteList(signature,true);
     if (true == result) {
         // signature added to whitelist
     } else {
         // signature not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 String signature = "3082024d308201b6a00302010202044dc96abf30...";
 try {
     boolean result = appPolicy.addAppSignatureToWhiteList(signature,true);
     if (true == result) {
         // signature added to whitelist
     } else {
         // signature not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTES:

- Since Android O, the homePkgName parameter should be null and the shortcut is added only in current launcher.
- Since Android O, this API is not supported in third party launchers.

 // administrator wants to add a browser shortcut on the home screen
 String packageName = "com.android.browser";
 String homePkgName = null;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 try {
     boolean result = applicationPolicy.addHomeShortcut(packageName, homePkgName);

     if (result == true) {
         Log.d(TAG, "addHomeShortcut has succeeded!");
     } else {
         Log.d(TAG, "addHomeShortcut has failed.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // administrator wants to add a browser shortcut on the home screen
 String packageName = "com.android.browser";
 String homePkgName = null;
 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     boolean result = applicationPolicy.addHomeShortcut(packageName, homePkgName);

     if (result == true) {
         Log.d(TAG, "addHomeShortcut has succeeded!");
     } else {
         Log.d(TAG, "addHomeShortcut has failed.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 try {
     List packageList = new ArrayList();
     packageList.add("com.android.email");

     if (appPolicy.addNewAdminActivationAppWhiteList(packageList)) {
         Log.w(TAG, " Add new administrator activation whitelist allowed");
     } else {
         Log.w(TAG, "Failed to set the policy.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "Exception" + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     List packageList = new ArrayList();
     packageList.add("com.android.email");
     if (appPolicy.addNewAdminActivationAppWhiteList(packageList)) {
         Log.w(TAG, " Add administrator activation whitelist allowed");
     } else {
         Log.w(TAG, "Failed to set the policy.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "Exception" + e);
 }
 

An administrator can use this API to add a package to whitelist it from Google's Doze mode, app standby and power saving mode. In case of smart manager application, Administrator can use addPackagesToForceStopBlackList(List) to prevent it from force stop.

NOTE: The package will be whitelisted for device wide if it is presented in other user space too.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 AppIdentity appIdentity = new AppIdentity("com.abc.xyz", "appSignature");
 try {
     boolean result = appPolicy.addPackageToBatteryOptimizationWhiteList(appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 AppIdentity appIdentity = new AppIdentity("com.abc.xyz", "appSignature");
 try {
     boolean result = appPolicy.addPackageToBatteryOptimizationWhiteList(appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add package to a given type of blacklist.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageYouWantedBlocked is standard java.lang.String object.

NOTE: TYPE_EXTERNAL_STORAGE_ACCESS is not available since API level 33.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToBlackList(ApplicationPolicy.TYPE_APPROVED_APP_INSTALLER, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToBlackList(ApplicationPolicy.TYPE_EXTERNAL_STORAGE_ACCESS, appIdentity);

 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToBlackList(ApplicationPolicy.TYPE_APPROVED_APP_INSTALLER, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToBlackList(ApplicationPolicy.TYPE_EXTERNAL_STORAGE_ACCESS, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add package to a given type of whitelist.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

NOTE: TYPE_EXTERNAL_STORAGE_ACCESS is not available since API level 33.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToWhiteList(ApplicationPolicy.TYPE_APPROVED_APP_INSTALLER, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToWhiteList(ApplicationPolicy.TYPE_EXTERNAL_STORAGE_ACCESS, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToWhiteList(ApplicationPolicy.TYPE_CALL_RECORDING, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToWhiteList(ApplicationPolicy.TYPE_APPROVED_APP_INSTALLER, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 String pkgName = "com.android.settings";
 String pkgSignature = "iuwueyhfbdigerbhfdfb";
 AppIdentity appIdentity = new AppIdentity(pkgName, pkgSignature);
 try {
     int result = appPolicy.addPackageToWhiteList(ApplicationPolicy.TYPE_EXTERNAL_STORAGE_ACCESS, appIdentity);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent the user from clearing cache for certain applications. The actions include clear cache in Settings app, clearing cache through third- party applications, and clearing service cache from the application. The user can still clear cache the application through its interface or back key. The administrator provides a list of packages that are added to the blacklist. For any package added on the whitelist using addPackagesToClearCacheWhiteList(List) , then that application cache can be cleared. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearCacheBlackList(list);
     if (true == result) {
         // user is not allowed to clear cache the blacklisted application
         // packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearCacheBlackList(list);
     if (true == result) {
         // user is not allowed to clear cache the blacklisted application
         // packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let users clear cache for certain packages. An administrator provides a list of packages that are to be added to the clear cache whitelist. The whitelist is the exception to the blacklist. If a package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearCacheWhiteList(list);
     if (true == result) {
         // application clear cache is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean result = appPolicy.addPackagesToClearCacheWhiteList(list);
     if (true == result) {
         // application clear cache is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent the user from clearing data for certain applications. The actions include clear data in Settings app, clearing data through third- party applications, and clearing service data from the application. The user can still clear data the application through its interface or back key. The administrator provides a list of packages that are added to the blacklist. For any package added on the whitelist using addPackagesToClearDataWhiteList(List) , then that application data can be cleared. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearDataBlackList(list);
     if (true == result) {
         // user is not allowed to clear data the blacklisted application
         // packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearDataBlackList(list);
     if (true == result) {
         // user is not allowed to clear data the blacklisted application
         // packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let users clear data for certain packages. An administrator provides a list of packages that are to be added to the clear data whitelist. The whitelist is the exception to the blacklist. If a package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearDataWhiteList(list);
     if (true == result) {
         // application clear data is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToClearDataWhiteList(list);
     if (true == result) {
         // application clear data is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

An administrator can use this API to prevent user from using clipboard in application(s) of the provided package(s). The administrator provides a list of packages that should be added to the blacklist. In case a package has already been added to the blacklist by other administrator, that package will not be added to the blacklist.

Once a package is added to the blacklist, the user will no longer be able to use the clipboard in the application related to that package.

NOTES:

- This policy only take effect over native android clipboard.
- When a blacklisted application tries to use the clipboard, the content of the clipboard is deleted.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardBlackList(list);
     if (result) {
         // user will not be able to use clipboard from the appplication(s) of
         // the provided package(s)
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardBlackList(list);
     if (result) {
         // user will not be able to use clipboard from the appplication(s) of
         // the provided package(s)
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to allow the user of using clipboard in application(s) of the provided package(s) even if these packages are added in the disable application clipboard blacklist. Administrator could use this one to blacklist everything except the whitelisted packages. The administrator provides a list of packages that should be added to the white list. In case a package has already been added to the white list by other administrator, that package will not be added to the white list.

Once a package is added to the white list, the user will be able to use the clipboard in that application independently if the package has been already added in blacklist or not.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardWhiteList(list,true);
     if (result) {
         // user will be able to use clipboard from the appplication(s) of the
         // provided package(s) even if they are also inserted in clipboard blacklist
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardWhiteList(list,true);
     if (result) {
         // user will be able to use clipboard from the appplication(s) of the
         // provided package(s) even if they are also inserted in clipboard blacklist
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to allow the user of using clipboard in application(s) of the provided package(s) even if these packages are added in the disable application clipboard blacklist. The administrator provides a list of packages that should be added to the white list. In case a package has already been added to the white list by other administrator, that package will not be added to the white list.

Once a package is added to the white list, the user will be able to use the clipboard in that application independently if the package has been already added in blacklist or not.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardWhiteList(list);
     if (result) {
         // user will be able to use clipboard from the appplication(s) of the
         // provided package(s) even if they are also inserted in clipboard blacklist
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.chrome");
 list.add("com.samsung.android.snote");
 try {
     boolean result = appPolicy.addPackagesToDisableClipboardWhiteList(list);
     if (result) {
         // user will be able to use clipboard from the appplication(s) of the
         // provided package(s) even if they are also inserted in clipboard blacklist
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent certain applications from being updated. It also prevents the application from being downgraded (installing an older version) or being replaced (installing another apk with same version number). If a package on the blacklist is also added to the whitelist using addPackagesToDisableUpdateWhiteList(List), then that application can still be updated. The whitelist is the exception to the blacklist of the same administrator. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority. The whitelist has no priority over blacklists of other administrators and it has no effect if blacklist is empty.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToDisableUpdateBlackList(list);
     if (true == result) {
         // applications are not allowed to be updated
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let certain packages be updated. The administrator provides a list of packages to be added to the disable update whitelist. The whitelist is the exception to the blacklist of the same administrator. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority. The whitelist has no priority over blacklists of other administrators and it has no effect if blacklist is empty.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToDisableUpdateWhiteList(list);
     if (true == result) {
         // application update is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let certain packages be updated. The administrator provides a list of packages to be added to the disable update whitelist and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages.The whitelist is the exception to the blacklist of the same administrator. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority. The whitelist has no priority over blacklists of other administrators and it has no effect if blacklist is empty.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToDisableUpdateWhiteList(list,true);
     if (true == result) {
         // application update is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to start monitoring focus changes of activities which pertain to the provided package(s). The administrator provides a list of packages that are added to the list. Once a package has been added to the list, that application is monitored for focus changes. Whenever an activity from that package gains or loses focus (comes to foreground or leave it), ACTION_APPLICATION_FOCUS_CHANGE intent is broadcasted.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToFocusMonitoringList(list);
     if (true == result) {
         // listed packages will be monitored for focus changes
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToFocusMonitoringList(list);
     if (true == result) {
         // listed packages will be monitored for focus changes
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent the user from stopping certain applications. The stop actions include force stop in Settings app, stopping through third- party applications, stopping any background process by system and stopping any service from the application. The user can still stop the application through its interface or back key. The administrator provides a list of packages that are added to the blacklist. For any package added on the whitelist using addPackagesToForceStopWhiteList(List), then that application can still be stopped. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

NOTE: Since MDM 5.3, in case user tries to stop a package that is at prevent stop blacklist, ACTION_PREVENT_APPLICATION_STOP intent is broadcasted. Administrator can stop a package which has been added to the prevent stop blacklist by calling stopApp(String).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopBlackList(list);
     if (true == result) {
         // user is not allowed to stop the blacklisted application packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopBlackList(list);
     if (true == result) {
         // user is not allowed to stop the blacklisted application packages
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let users stop certain packages. An administrator provides a list of packages that are to be added to the force stop whitelist. The whitelist is the exception to the blacklist. If a package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopWhiteList(list);
     if (true == result) {
         // application force stop is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopWhiteList(list);
     if (true == result) {
         // application force stop is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to let users stop certain packages. An administrator provides a list of packages that are to be added to the force stop whitelist and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages. The whitelist is the exception to the blacklist. If a package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopWhiteList(list,true);
     if (true == result) {
         // application force stop is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     boolean result = appPolicy.addPackagesToForceStopWhiteList(list,true);
     if (true == result) {
         // application force stop is allowed
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent an application notification based on the package name. An application with a matching package name is prevented from showing status bar notifications. An administrator can choose the prevention mode for the notifications (see setApplicationNotificationMode(int)). Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object. If a package name matches the package name pattern in both the blacklist and whitelist, the whitelist takes priority, and the application notification can be shown.

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationBlackList(packageList);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationBlackList(packageList);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to allow application notifications based on the package name and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages. An applications with a matching package name is an exception from the blacklist. Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object. If the package name of an application matches the package name pattern in both the blacklist and whitelist, the whitelist takes priority, and the application can show status bar notifications.

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationWhiteList(packageList,true);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationWhiteList(packageList,true);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to allow application notifications based on the package name. An applications with a matching package name is an exception from the blacklist. Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object. If the package name of an application matches the package name pattern in both the blacklist and whitelist, the whitelist takes priority, and the application can show status bar notifications.

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationWhiteList(packageList);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean status = appPolicy.addPackagesToNotificationWhiteList(packageList);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to prevent user (or another administrator) from launching activities which pertain to the provided package(s). The administrator provides a list of packages that should be added to the blacklist. Package name specifications containing wildcard characters (e.g., "com.xyz.*" or "*") will not be added to blacklist. In case a package has already been added to the blacklist by other administrator, that package will also not be added to the blacklist.

Once a package has been added to the blacklist, that application is force stopped. Only activities pertaining to a specific package are prevented from starting, not other application components (Services, Broadcast receivers and Content providers). In case user tries to start an activity from a package that is at prevent start blacklist, ACTION_PREVENT_APPLICATION_START intent is broadcasted. Administrator can launch an activity which has been added to the prevent start blacklist by calling startApp(String, String). Once an activity from that package is running, user will be able to start other activities from that same package.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     List<String> addedList = appPolicy.addPackagesToPreventStartBlackList(list);
     if (!addedList.isEmpty()) {
         // user will not be able to start activites from the provided package(s)
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 List<String> list = new ArrayList<String>();
 list.add("com.android.settings");
 list.add("com.rovio.angrybirdsrio");
 try {
     List<String> addedList = appPolicy.addPackagesToPreventStartBlackList(list);
     if (!addedList.isEmpty()) {
         // user will not be able to start activites from the provided package(s)
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add a list of packages to the list of blocked widget packages. A user cannot add widgets with package names that match the list, and existent widgets are removed from the launcher home screen. The whitelist is the exception to the blacklist. For any package added to the whitelist using addPackagesToWidgetWhiteList(List), the corresponding widget can still be used. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetBlackList(packageList);
     if (addList) {
         // widget blacklist set with packages calendar and camera
     } else {
         // widget blacklist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetBlackList(packageList);
     if (addList) {
         // widget blacklist set with packages calendar and camera
     } else {
         // widget blacklist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add a list of packages to the list of allowed widget packages and blacklist all other packages by adding * in blacklist as well. Administrator could use this one to blacklist everything except the whitelisted packages. The user can add widgets with package names that match the list. The administrator provides a list of packages that are added to the whitelist. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist will takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetWhiteList(packageList,true);
     if (addList) {
         // widget whitelist is set with packages calendar and camera
     } else {
         // widget whitelist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetWhiteList(packageList,true);
     if (addList) {
         // widget whitelist is set with packages calendar and camera
     } else {
         // widget whitelist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add a list of packages to the list of allowed widget packages. The user can add widgets with package names that match the list. The administrator provides a list of packages that are added to the whitelist. The whitelist is the exception to the blacklist. If the package name matches the pattern in both the blacklist and whitelist, the whitelist will takes priority.

Wildcard characters like "com.xyz.*"can be used to specify multiple application package names. The wildcards "*" and "?" have the same meaning as these would have in a regular expression i.e. "*" means that the character preeceding it can be used any number of times. When ".*" is used this translates to using any character or characters. "?" means that the character before it will be used exactly zero or 1 time. "*" and ".*" mean the same thing i.e. all the packages. All the app package names that match the regular expression set by the admin will be affected. Run a quick test using packageName.matches(patternSetByAdmin) to see if this package will be affected where packageName is standard java.lang.String object.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetWhiteList(packageList);
     if (addList) {
         // widget whitelist is set with packages calendar and camera
     } else {
         // widget whitelist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     List<String> packageList = new ArrayList<String>();
     packageList.add("com.android.calendar");
     packageList.add("com.android.camera");
     boolean addList = appPolicy.addPackagesToWidgetWhiteList(packageList);
     if (addList) {
         // widget whitelist is set with packages calendar and camera
     } else {
         // widget whitelist is disabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
   List <UsbDeviceConfig> devices = new ArrayList<UsbDeviceConfig>();
   UsbDeviceConfig usbDeviceConfig = new UsbDeviceConfig();

   usbDeviceConfig.productId = 20;
   usbDeviceConfig.vendorId = 20;
   devices.add(usbDeviceConfig);

   boolean result  = appPolicy.addUsbDevicesForDefaultAccess(packageName, devices);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     List<UsbDeviceConfig> devices = new ArrayList<UsbDeviceConfig>();
     UsbDeviceConfig usbDeviceConfig = new UsbDeviceConfig();

     usbDeviceConfig.productId = 20;
     usbDeviceConfig.vendorId = 20;
     devices.add(usbDeviceConfig);

     boolean result = appPolicy.addUsbDevicesForDefaultAccess(packageName, devices);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 List<String> runtimePermissions = new ArrayList<String>();
 runtimePermissions.add("android.permission.ACCESS_COARSE_LOCATION");
 runtimePermissions.add("android.permission.CALL_PHONE");

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     int ret = appPolicy.applyRuntimePermissions(appIdentity, runtimePermissions, PERMISSION_POLICY_STATE_GRANT);
     if (ret == ApplicationPolicy.ERROR_NONE) {
         Log.w(TAG, "Granted runtime permissions " + runtimePermissions + " to package "com.sta.test" successfully");
     } else {
         Log.d(TAG, "Failed to grant runtime permissions " + runtimePermissions + " to package "com.sta.test"");
     }

 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 List<String> runtimePermissions = new ArrayList<String>();
 runtimePermissions.add("android.permission.ACCESS_COARSE_LOCATION");
 runtimePermissions.add("android.permission.CALL_PHONE");

 AppIdentity appIdentity = new AppIdentity("com.sta.test", null);
 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     int ret = appPolicy.applyRuntimePermissions(appIdentity, runtimePermissions, PERMISSION_POLICY_STATE_GRANT);
     if (ret == ApplicationPolicy.ERROR_NONE) {
         Log.w(TAG, "Granted runtime permissions " + runtimePermissions + " to package "com.sta.test" successfully");
     } else {
         Log.d(TAG, "Failed to grant runtime permissions " + runtimePermissions + " to package "com.sta.test"");
     }

 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 String iconPath = "/sdcard/icon.jpg";
 File file = null;
 FileInputStream is = null;
 byte[] bytes = null;
 try {
     file = new File(iconPath);
     is = new FileInputStream(file);
 } catch (Exception e) {
     e.printStackTrace();
 }
 if (null != is) {
     // Get the size of the file
     long length = file.length();
     if (length > Integer.MAX_VALUE) {
         throw new IOException("The file is too big");
     }

     // Create the byte array to hold the data
     bytes = new byte[(int) length];
     // Read in the bytes
     int offset = 0;
     int numRead = 0;
     while (offset < bytes.length
             && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
         offset += numRead;
     }
     // Ensure all the bytes have been read in
     if (offset < bytes.length) {
         throw new IOException("The file is not completely read: "
                 + file.getName());
     }
     // Close the input stream, all file contents are in the bytes
     // variable
     is.close();
 }
 try {
     String packageName = "com.test.app";
     appPolicy.changeApplicationIcon(packageName, bytes);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 String iconPath = "/sdcard/icon.jpg";
 File file = null;
 FileInputStream is = null;
 byte[] bytes = null;
 try {
     file = new File(iconPath);
     is = new FileInputStream(file);
 } catch (Exception e) {
     e.printStackTrace();
 }
 if (null != is) {
     // Get the size of the file
     long length = file.length();
     if (length > Integer.MAX_VALUE) {
         throw new IOException("The file is too big");
     }

     // Create the byte array to hold the data
     bytes = new byte[(int) length];
     // Read in the bytes
     int offset = 0;
     int numRead = 0;
     while (offset < bytes.length
             && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
         offset += numRead;
     }
     // Ensure all the bytes have been read in
     if (offset < bytes.length) {
         throw new IOException("The file is not completely read: "
                 + file.getName());
     }
     // Close the input stream, all file contents are in the bytes
     // variable
     is.close();
 }
 try {
     String packageName = "com.test.app";
     appPolicy.changeApplicationIcon(packageName, bytes);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     String packageName = "com.test.app";
     appPolicy.changeApplicationName(packageName, "New Application Name");
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     String packageName = "com.test.app";
     appPolicy.changeApplicationName(packageName, "New Application Name");
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

In case of multiple administrators, this API clears only the blacklist and whitelist set by the calling administrator. For example, administrator A sets one set of packages and administrator B sets another set of packages. If administrator A calls this API, all packages set by administrator A are cleared but that of administrator B are still valid and enforced.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 try {
     // try to clear all package names from both whitelist and blacklist
     boolean result = appPolicy.clearAppPackageNameFromList();
     if (true == result) {
         //both list cleared
     } else {
         //failed
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     // try to clear all package names from both whitelist and blacklist
     boolean result = appPolicy.clearAppPackageNameFromList();
     if (true == result) {
         //both list cleared
     } else {
         //failed
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 try {
     // try to clear all signature data from both whitelist and blacklist
     boolean result = appPolicy.clearAppSignatureFromList();
     if (true == result) {
         //both list cleared
     } else {
         //failed
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     // try to clear all signature data from both whitelist and blacklist
     boolean result = appPolicy.clearAppSignatureFromList();
     if (true == result) {
         //both list cleared
     } else {
         //failed
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear all packages from disable clipboard blacklist. Only the packages previously added by the calling administrator will be cleared.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableClipboardBlackList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableClipboardBlackList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear all packages from disable clipboard white list. Only the packages previously added by the calling administrator will be cleared.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableClipboardWhiteList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableClipboardWhiteList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear the list of packages from the disable update blacklist. After the packages are cleared from the list, they can be updated, downgraded or replaced. This API will only clear the packages that the calling administrator has added.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableUpdateBlackList();
     if (true == status) {
         // blacklist is successfully cleared
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear the list of packages from the disable update whitelist. If any package cleared from the whitelist was already added to the blacklist using addPackagesToDisableUpdateBlackList(List), it will not be able to be updated. This API will only clear the packages that the calling administrator has added.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearDisableUpdateWhiteList();
     if (true == status) {
         // whitelist is successfully cleared
     } else {
         // previous behaviour for device still prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear all packages from focus monitoring list.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearFocusMonitoringList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearFocusMonitoringList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();

 try {
     if (appPolicy.clearNewAdminActivationAppWhiteList()) {
         Log.w(TAG, " Clear new administrator activation whitelist allowed");
     } else {
         Log.w(TAG, "Failed to set the policy.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "Exception" + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean prevent = true;
     if (appPolicy.clearNewAdminActivationAppWhiteList()) {
         Log.w(TAG, " Clear administrator activation whitelist allowed");
     } else {
         Log.w(TAG, "Failed to set the policy.");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "Exception" + e);
 }
 

An administrator can use this API to clear all packages from disable clipboard blacklist. Only the packages previously added by the calling administrator will be cleared.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPackagesFromDisableClipboardList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPackagesFromDisableClipboardList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear the list of packages from the disable update blacklist and whitelist. After the packages are cleared from the list, they can be updated, downgraded or replaced. This API will only clear the packages that the calling administrator has added.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPackagesFromDisableUpdateList();
     if (true == status) {
         //  both lists are successfully cleared
     } else {
         // lists removal failed
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove a all of the packages from the force stop blacklist and whitelist. After the packages are removed the user can stop the packages using force stop in the Settings app, stop through third party applications, and stop any service from the package.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {;
     boolean status = appPolicy.clearPackagesFromForceStopList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     boolean status = appPolicy.clearPackagesFromForceStopList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove all of the packages from the status bar notification black and white list. After the packages are removed, an application with a matching package name can show status bar notifications.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPackagesFromNotificationList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     boolean status = appPolicy.clearPackagesFromNotificationList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove all of the packages from the widget black and white list. After the packages are removed, the user can use a widget with a matching package name.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPackagesFromWidgetList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();

 try {
     boolean status = appPolicy.clearPackagesFromWidgetList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to clear all packages from prevent start blacklist. Only the packages previously added by the calling administrator will be cleared.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPreventStartBlackList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean status = appPolicy.clearPreventStartBlackList();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 ApplicationPolicy appPolicy = edm.getApplicationPolicy();
  try {
     boolean result = appPolicy.clearUsbDevicesForDefaultAccess(packageName);
  }catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
   }

 

 // When you create container successfully, containerID will be returned via intent.
 // Use this containerID in below API.
 EnterpriseKnoxManager ekm = EnterpriseKnoxManager.getInstance(context);
 KnoxContainerManager kcm = ekm.getKnoxContainerManager(containerID);
 ApplicationPolicy appPolicy = kcm.getApplicationPolicy();
 try {
     boolean result = appPolicy.clearUsbDevicesForDefaultAccess(packageName);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }