See setOutgoingCallExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to allow incoming calls
     if (phoneRestrictionPolicy.addIncomingCallExceptionPattern(".*")) {
         Log.d(TAG, "success adding incoming call exception pattern");
     } else {
         Log.w(TAG, "failed adding incoming call exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to block incoming calls
     if (phoneRestrictionPolicy.addIncomingCallRestriction(".*")) {
         Log.d(TAG, "success adding incoming call restriction");
     } else {
         Log.w(TAG, "failed adding incoming call restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingSmsExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to allow incoming SMSs
     if (phoneRestrictionPolicy.addIncomingSmsExceptionPattern(".*")) {
         Log.d(TAG, "success adding incoming sms exception pattern");
     } else {
         Log.w(TAG, "failed adding incoming sms exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to block incoming SMS
     if (phoneRestrictionPolicy.addIncomingSmsRestriction(".*")) {
         Log.d(TAG, "success adding incoming SMS restriction");
     } else {
         Log.w(TAG, "failed adding incoming SMS restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to allow outgoing calls
     if (phoneRestrictionPolicy.addOutgoingCallExceptionPattern(".*")) {
         Log.d(TAG, "success adding outgoing call exception pattern");
     } else {
         Log.w(TAG, "failed adding outgoing call exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to block outgoing calls
     if (phoneRestrictionPolicy.addOutgoingCallRestriction(".*")) {
         Log.d(TAG, "success adding outgoing call restriction");
     } else {
         Log.w(TAG, "failed adding outgoing call restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingSmsExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // to allow outgoing SMSs
     if (phoneRestrictionPolicy.addOutgoingSmsExceptionPattern(".*")) {
         Log.d(TAG, "success adding outgoing sms exception pattern");
     } else {
         Log.w(TAG, "failed adding outgoing sms exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // previous patterns remain and the new pattern is added
     // blocking all outgoing SMS
     if (phoneRestrictionPolicy.addOutgoingSmsRestriction(".*")) {
         Log.d(TAG, "success adding outgoing SMS restriction");
     } else {
         Log.w(TAG, "failed adding outgoing SMS restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowCallerIDDisplay(false)) {
         Log.d(TAG, "Caller Id display blocked successfully");
     } else {
         Log.d(TAG, "Failed to block caller Id display");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 try {
     boolean enableCopyContactToSim = true;
     phoneRestrictionPolicy.allowCopyContactToSim(enableCopyContactToSim);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 } 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowIncomingMms(false)) {
         Log.d(TAG, "Incoming MMS blocked successfully");
     } else {
         Log.d(TAG, "Failed to block incoming MMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: This API is strongly coupled to the native MMS client application. So, if user defines a third-party application as default for messaging, this policy may not apply. It's recommended to prevent the user from installing other messaging applications by using ApplicationPolicy APIs (like addAppPackageNameToBlackList(String) and addPackagesToPreventStartBlackList(List)).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowIncomingSms(false)) {
         Log.d(TAG, "Incoming SMS blocked successfully");
     } else {
         Log.d(TAG, "Failed to block incoming SMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: This policy will not apply in case native telephony stack is not used to receive SMS.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowOutgoingMms(false)) {
         Log.d(TAG, "Outgoing MMS blocked successfuly");
     } else {
         Log.d(TAG, "Failed to block outgoing MMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: This API is strongly coupled to the native MMS client application. So, if user defines a third-party application as default for messaging, this policy may not apply. It's recommended to prevent the user from installing other messaging applications by using ApplicationPolicy APIs (like addAppPackageNameToBlackList(String) and addPackagesToPreventStartBlackList(List)).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowOutgoingSms(false)) {
         Log.d(TAG, "Outgoing SMS blocked successfully");
     } else {
         Log.d(TAG, "Failed to block outgoing SMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: This policy will not apply in case native telephony stack is not used to send SMS.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.allowWapPush(false)) {
         Log.d(TAG, "WAP push messages are disallowed.");
     } else {
         Log.d(TAG, "Failed to block WAP push");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.blockMmsWithStorage(true)) {
         Log.d(TAG, "MMS are blocked and stored for late delivery.");
     } else {
         Log.d(TAG, "Failed to enable blocking of MMS with storage for late delivery");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.blockSmsWithStorage(true)) {
         Log.d(TAG, "SMS will be blocked and stored for late delivery.");
     } else {
         Log.d(TAG, "Failed to enable blocking of SMS, with storage for late delivery");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: Since MDM 5.8 administrator can specify the iccId of the SIM card that will be affected for this policy using getPhoneRestrictionPolicy(String)

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 // This will get the phoneRestrictionPolicy for the default SIM.
 PhoneRestrictionPolicy phoneRestrictionPolicyForDefault = edm.getPhoneRestrictionPolicy();
 String oldPinCodeForDefaultSIM = "1234"
 String newPinCodeForDefaultSIM = "8888"

 // Subscription Manager to get SIM information
 SubscriptionManager subManager = (SubscriptionManager) getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
 // Get the iccId for the device inserted on Slot 0
 String iccId = subManager.getActiveSubscriptionInfoForSimSlotIndex(0).getIccId();
 // This will get the phoneRestrictionPolicy for a specific SIM Card with the given ICCID.
 PhoneRestrictionPolicy phoneRestrictionPolicyForSpecificSIM = edm.getPhoneRestrictionPolicy(iccId);
 String oldPinCodeForSpecificSIM = "5678"
 String newPinCodeForSpecificSIM = "9999"
 try {
     // Change SIM Pin for Default SIM
     int resultForDefaultSim = phoneRestrictionPolicyForDefault.changeSimPinCode(oldPinCodeForDefaultSIM,newPinCodeForDefaultSIM);
     checkResult(resultForDefaultSim);

     // Change the SIM Pin for a specific SIM
     int resultForSpecificSIm = phoneRestrictionPolicyForSpecificSIM.changeSimPinCode(oldPinCodeForSpecificSIM,newPinCodeForSpecificSIM);
     checkResult(resultForSpecificSIm);
 } catch (SecurityException securityException) {
     Log.w(TAG, "SecurityException: " + securityException);
 }

 private void checkResult(int result) {
      switch (result) {
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_NONE:
              Log.d(TAG, "SIM PIN code successfully changed");
              break;
          case PhoneRestrictionPolicy.ERROR_SIM_PIN_ALREADY_LOCKED:
             Log.d(TAG, "Failed: Already locked but not by administrator");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ALREADY_UNLOCKED:
         Log.d(TAG, "Failed: Cannot change PIN code when
                 PIN lock is disabled");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_BLOCKED_BY_PUK:
         Log.d(TAG, "Failed: SIM card is blocked by PIN unlock key (PUK)");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_DATABASE:
         Log.d(TAG, "Failed to enable SIM PIN lock: a database error
                 occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_UNKNOWN:
         Log.d(TAG, "Failed: Unknown error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_FAILED:
         Log.d(TAG, "Failed: Generic error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ID_NOT_READY:
         Log.d(TAG, "Failed: SIM card is not ready yet");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INCORRECT_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is wrong");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INVALID_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is in wrong format");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_MAX_RETRIES_EXCEEDED:
         Log.d(TAG, "Failed: Maximum number of retries reached");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_OWNED_BY_OTHER_ADMIN:
              Log.d(TAG,
              "Failed: Operation denied. Another administrator has already locked this SIM card on this device");
              break;
          case PhoneRestrictionPolicy.ERROR_SIM_NOT_INSERTED:
              Log.d(TAG,
              "Failed: The specified Sim Card is not present");
         break;
     }
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.clearStoredBlockedMms()) {
         Log.d(TAG, "Stored MMS were cleared.");
     } else {
         Log.d(TAG, "Failed to clear stored MMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.clearStoredBlockedSms()) {
         Log.d(TAG, "Stored SMS were cleared.");
     } else {
         Log.d(TAG, "Failed to clear stored SMS");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

NOTE: Since MDM 5.8 administrator can specify the iccId of the SIM card that will be affected by this policy using getPhoneRestrictionPolicy(String)

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);

 // This will get the phoneRestrictionPolicy for the default SIM.
 PhoneRestrictionPolicy phoneRestrictionPolicyForDefault = edm.getPhoneRestrictionPolicy();
 String pinCodeForDefault = "1234"

 // Subscription Manager to get SIM information
 SubscriptionManager subManager = (SubscriptionManager) getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
 // Get the iccId for the device inserted on Slot 0
 String iccId = subManager.getActiveSubscriptionInfoForSimSlotIndex(0).getIccId();
 // This will get the phoneRestrictionPolicy for a specific SIM Card with the given ICCID.
 PhoneRestrictionPolicy phoneRestrictionPolicyForSpecificSIM = edm.getPhoneRestrictionPolicy(iccId);
 String pinCodeForSpecificSIM = "5678"

 try {
     // Disable the SIM Pin Lock for Default SIM
     int resultForDefaultSim = phoneRestrictionPolicyForDefault.disableSimPinLock(pinCodeForDefault);
     checkResult(resultForDefaultSim);

     // Disable the SIM Pin Lock for a specific SIM
     int resultForSpecificSIm = phoneRestrictionPolicyForSpecificSIM.disableSimPinLock(pinCodeForSpecificSIM);
     checkResult(resultForSpecificSIm);
 } catch (SecurityException securityException) {
     Log.w(TAG, "SecurityException: " + securityException);
 }

 private void checkResult(int result) {
      switch (result) {
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_NONE:
         Log.d(TAG, "SIM PIN lock successfully disabled");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ALREADY_UNLOCKED:
         Log.d(TAG, "Failed: Already unlocked");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_BLOCKED_BY_PUK:
         Log.d(TAG, "Failed: SIM card is blocked by PIN unlock key (PUK)");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_DATABASE:
         Log.d(TAG, "Failed to enable SIM PIN lock: a database error
                 occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_UNKNOWN:
         Log.d(TAG, "Failed: Unknown error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_FAILED:
         Log.d(TAG, "F boolean isCopyContactToSimAllowed(ailed: Generic error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ID_NOT_READY:
         Log.d(TAG, "Failed: SIM card is not ready yet");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INCORRECT_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is wrong");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INVALID_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is in wrong format");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_MAX_RETRIES_EXCEEDED:
         Log.d(TAG, "Failed: Maximum number of retries reached");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_OWNED_BY_OTHER_ADMIN:
         Log.d(TAG, "Failed: Operation denied. Another administrator has locked
                 this SIM card on this device");
         break;
          case PhoneRestrictionPolicy.ERROR_SIM_NOT_INSERTED:
              Log.d(TAG,
              "Failed: The specified Sim Card is not present");
         break;
     }
 }
 

The API returns false if the device has no voice call capability (e.g., a tablet). This policy is controlled by the last administrator who called it. For a device managed by multiple administrators, the last limit values set are the values used to restrict the user. This measure also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.enableLimitNumberOfCalls(true)) {
         // Set the incoming call limit to 5 by day, no limit by week, 100 by
         // month
         if (phoneRestrictionPolicy.setLimitOfIncomingCalls(5, 0, 100)) {
             Log.d(TAG, "success setting incoming call limits");
         } else {
             Log.w(TAG, "failure setting incoming call limits");
         }
         // Set the outgoing call limit to 10 by day, no limit by week, no limit
         // by month
         if (phoneRestrictionPolicy.setLimitOfOutgoingCalls(10, 0, 0)) {
             Log.d(TAG, "success setting outgoing call limits");
         } else {
             Log.w(TAG, "failure setting outgoing call limits");
         }
     } else {
         Log.w(TAG, "failure enabling call limits");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.enableLimitNumberOfSms(true)) {
         // Set the incoming SMS limit to 10 by day, no limit by week, no limit
         // by month
         if (phoneRestrictionPolicy.setLimitOfIncomingSms(10, 0, 0)) {
             Log.d(TAG, "success setting incoming SMS limits");
         } else {
             Log.w(TAG, "failure setting incoming SMS limits");
         }
         // Set the outgoing SMS limit to 5 by day, 20 by week, 100 by month
         if (phoneRestrictionPolicy.setLimitOfOutgoingSms(5, 20, 100)) {
             Log.d(TAG, "success setting outgoing SMS limits");
         } else {
             Log.w(TAG, "failure setting outgoing SMS limits");
         }
     } else {
         Log.w(TAG, "failure enabling SMS limits");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);

 // This will get the phoneRestrictionPolicy for the default SIM.
 PhoneRestrictionPolicy phoneRestrictionPolicyForDefault = edm.getPhoneRestrictionPolicy();
 String pinCodeForDefault = "1234"

 // Subscription Manager to get SIM information
 SubscriptionManager subManager = (SubscriptionManager) getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
 // Get the iccId for the device inserted on Slot 0
 String iccId = subManager.getActiveSubscriptionInfoForSimSlotIndex(0).getIccId();
 // This will get the phoneRestrictionPolicy for a specific SIM Card with the given ICCID.
 PhoneRestrictionPolicy phoneRestrictionPolicyForSpecificSIM = edm.getPhoneRestrictionPolicy(iccId);
 String pinCodeForSpecificSIM = "5678"

 try {
     // Enable the SIM Pin for Default SIM
     int resultForDefaultSim = phoneRestrictionPolicyForDefault.enableSimPinLock(pinCodeForDefault);
     checkResult(resultForDefaultSim);

     // Enable the SIM Pin for a specific SIM
     int resultForSpecificSIm = phoneRestrictionPolicyForSpecificSIM.enableSimPinLock(pinCodeForSpecificSIM);
     checkResult(resultForSpecificSIm);
 } catch (SecurityException securityException) {
     Log.w(TAG, "SecurityException: " + securityException);
 }

 private void checkResult(int result) {
      switch (result) {
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_NONE:
         Log.d(TAG, "SIM PIN lock successfully enabled");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ALREADY_LOCKED:
         Log.d(TAG, "Failed: Already locked but not by administrator");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ALREADY_LOCKED_BY_ADMIN:
         Log.d(TAG, "Failed: Already locked by current administrator");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_BLOCKED_BY_PUK:
         Log.d(TAG, "Failed: SIM card is blocked by PIN unlock key (PUK)");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_DATABASE:
         Log.d(TAG, "Failed to enable SIM PIN lock: a database error
                 occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_UNKNOWN:
         Log.d(TAG, "Failed: Unknown error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_FAILED:
         Log.d(TAG, "Failed: Generic error occurred");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_ID_NOT_READY:
         Log.d(TAG, "Failed: SIM card is not ready yet");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INCORRECT_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is wrong");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_INVALID_CODE:
         Log.d(TAG, "Failed: Supplied PIN code is in wrong format");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_MAX_RETRIES_EXCEEDED:
         Log.d(TAG, "Failed: Maximum number of retries reached");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_PIN_OWNED_BY_OTHER_ADMIN:
         Log.d(TAG, "Failed: Operation denied. Another administrator has already
                 locked this SIM card on this device");
         break;
     case PhoneRestrictionPolicy.ERROR_SIM_NOT_INSERTED:
         Log.d(TAG, "Failed: The specified Sim Card is not present");
         break;
     }
 }
 

For a device managed by multiple administrators, this method returns the more restricted value rather than the value set by the calling administrator.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.getDataCallLimitEnabled()) {
     Log.d(TAG, "Data call limit enabled");
 } else {
     Log.w(TAG, "Data call limit disabled");
 }
 

 EnterpriseDeviceManager edm = (EnterpriseDeviceManager)
      getSystemService(EnterpriseDeviceManager.ENTERPRISE_POLICY_SERVICE);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 
 try {
     // get a new disclaimer text
     String result = phoneRestrictionPolicy.getDisclaimerText() {
     if (result == null) {
         // this policy not set by any admin
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.getEmergencyCallOnly(true)) { // true to get
                                                              // restricted value
                                                              // from all administrators
         Log.d(TAG, "blocking all calls except emergency");
     } else {
         Log.d(TAG, "not blocking all calls");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the concatenated exception pattern from the all administrators
     String incomingCallsPattern = phoneRestrictionPolicy.getIncomingCallExceptionPatterns();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the restriction pattern from the calling administrator (using parameter
     // false)
     String incomingCallsPattern = phoneRestrictionPolicy.getIncomingCallRestriction(false);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the concatenated exception pattern from the all administrators
     String incomingSMSsPattern = phoneRestrictionPolicy.getIncomingSmsExceptionPatterns();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the incoming SMS restriction pattern from the calling administrator (using parameter
     // false)
     String incomingSmsPattern = phoneRestrictionPolicy.getIncomingSmsRestriction(false);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

LIMIT_NUMBER_OF_DATA_CALLS_BY_DAY
LIMIT_NUMBER_OF_DATA_CALLS_BY_WEEK
LIMIT_NUMBER_OF_DATA_CALLS_BY_MONTH

For a device managed by multiple administrators, this method returns the more restricted value rather than the value set by the calling administrator.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.getDataCallLimitEnabled()) {
     int currentDataCallsByDay = phoneRestrictionPolicy
             .getLimitOfDataCalls(LIMIT_NUMBER_OF_DATA_CALLS_BY_DAY);
     int currentDataCallsByWeek = phoneRestrictionPolicy
             .getLimitOfDataCalls(LIMIT_NUMBER_OF_DATA_CALLS_BY_WEEK);
     int currentDataCallsByMonth = phoneRestrictionPolicy
             .getLimitOfDataCalls(LIMIT_NUMBER_OF_DATA_CALLS_BY_MONTH);
 }
 

LIMIT_NUMBER_OF_CALLS_BY_DAY
LIMIT_NUMBER_OF_CALLS_BY_WEEK
LIMIT_NUMBER_OF_CALLS_BY_MONTH

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.isLimitNumberOfCallsEnabled()) {
     int currentIncomingCallsByDay = phoneRestrictionPolicy
             .getLimitOfIncomingCalls(LIMIT_NUMBER_OF_CALLS_BY_DAY);
     int currentIncomingCallsByWeek = phoneRestrictionPolicy
             .getLimitOfIncomingCalls(LIMIT_NUMBER_OF_CALLS_BY_WEEK);
     int currentIncomingCallsByMonth = phoneRestrictionPolicy
             .getLimitOfIncomingCalls(LIMIT_NUMBER_OF_CALLS_BY_MONTH);
 }
 

LIMIT_NUMBER_OF_SMS_BY_DAY
LIMIT_NUMBER_OF_SMS_BY_WEEK
LIMIT_NUMBER_OF_SMS_BY_MONTH

For a device managed by multiple administrators, the last limit values set apply. This setting also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.isLimitNumberOfSmsEnabled()) {
     int currentIncomingSmsByDay = phoneRestrictionPolicy
             .getLimitOfIncomingSms(LIMIT_NUMBER_OF_SMS_BY_DAY);
     int currentIncomingSmsByWeek = phoneRestrictionPolicy
             .getLimitOfIncomingSms(LIMIT_NUMBER_OF_SMS_BY_WEEK);
     int currentIncomingSmsByMonth = phoneRestrictionPolicy
             .getLimitOfIncomingSms(LIMIT_NUMBER_OF_SMS_BY_MONTH);
 }
 

LIMIT_NUMBER_OF_CALLS_BY_DAY
LIMIT_NUMBER_OF_CALLS_BY_WEEK
LIMIT_NUMBER_OF_CALLS_BY_MONTH

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.isLimitNumberOfCallsEnabled()) {
     int currentOutgoingCallsByDay = phoneRestrictionPolicy
             .getLimitOfOutgoingCalls(LIMIT_NUMBER_OF_CALLS_BY_DAY);
     int currentOutgoingCallsByWeek = phoneRestrictionPolicy
             .getLimitOfOutgoingCalls(LIMIT_NUMBER_OF_CALLS_BY_WEEK);
     int currentOutgoingCallsByMonth = phoneRestrictionPolicy
             .getLimitOfOutgoingCalls(LIMIT_NUMBER_OF_CALLS_BY_MONTH);
 }
 

LIMIT_NUMBER_OF_SMS_BY_DAY
LIMIT_NUMBER_OF_SMS_BY_WEEK
LIMIT_NUMBER_OF_SMS_BY_MONTH

For a device managed by multiple administrators, the last limit values set apply. This setting also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 if (phoneRestrictionPolicy.isLimitNumberOfSmsEnabled()) {
     int currentIncomingSmsByDay = phoneRestrictionPolicy
             .getLimitOfOutgoingSms(LIMIT_NUMBER_OF_SMS_BY_DAY);
     int currentIncomingSmsByWeek = phoneRestrictionPolicy
             .getLimitOfOutgoingSms(LIMIT_NUMBER_OF_SMS_BY_WEEK);
     int currentIncomingSmsByMonth = phoneRestrictionPolicy
             .getLimitOfOutgoingSms(LIMIT_NUMBER_OF_SMS_BY_MONTH);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the concatenated exception pattern from the all administrators
     String outgoingCallsPattern = phoneRestrictionPolicy.getOutgoingCallExceptionPatterns();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 try {
     // get the restriction pattern from the calling administrator (using parameter
     // false)
     String outgoingCallsPattern = phoneRestrictionPolicy.getOutgoingCallRestriction(false);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the concatenated exception pattern from the all administrators
     String outgoingSMSsPattern = phoneRestrictionPolicy.getOutgoingSmsExceptionPatterns();
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // get the SMS restriction pattern from the calling administrator (when parameter is
     // false)
     String outgoingSmsPattern = phoneRestrictionPolicy.getOutgoingSmsRestriction(false);
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

- remote_uri, sender_alias, content_type, body, timestamp for all

- file_path, thumbnail_path for file type

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 long id = intent.getExtras().getLong(EXTRA_MSG_ID);
 
 String action = intent.getAction();
 boolean isFile = false;
 if (ACTION_RCS_MSG_FILE_THUMBNAIL_RECEIVED.equals(action)
        || ACTION_RCS_MSG_FILE_RECEIVED.equals(action)
        || ACTION_RCS_MSG_FILE_SENT.equals(action)) {
     isFile = true;
 }

 Bundle rcsData = phoneRestrictionPolicy.getRCSMessage(id);
 String remoteUri = rcsData.getString(REMOTE_URI);
 String senderAlias = rcsData.getString(SENDER_ALIAS);
 String contentType = rcsData.getString(CONTENT_TYPE);
 String body = rcsData.getString(BODY);
 long timestamp = rcsData.getLong(TIMESTAMP);
 if (isFile) {
     String filePath = rcsData.getString(FILE_PATH);
     String thumbnailPath = rcsData.getString(THUMBNAIL_PATH);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isBlockMmsWithStorageEnabled()) {
         Log.d(TAG, "Blocked incoming MMS are stored for late delivery");
     } else {
         Log.d(TAG, "MMS are not blocked by this policy");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isBlockSmsWithStorageEnabled()) {
         Log.d(TAG, "Blocked incoming SMS are stored for late delivery");
     } else {
         Log.d(TAG, "SMS are not blocked by this policy");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isCallerIDDisplayAllowed()) {
         Log.d(TAG, "caller Id display allowed  on call ");
     } else {
         Log.w(TAG, "caller Id display disallowed on call");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isCopyContactToSimAllowed()) {
         Log.d(TAG, "Copy, adding or edition of SIM Contact is allowed");
     } else {
         Log.w(TAG, "Copy, adding or edition of SIM Contact is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isIncomingMmsAllowed()) {
         Log.d(TAG, "Incoming MMS is allowed");
     } else {
         Log.w(TAG, "Incoming MMS is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isIncomingSmsAllowed()) {
         Log.d(TAG, "Incoming SMS is allowed");
     } else {
         Log.w(TAG, "Incoming SMS is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

This policy is controlled by the last administrator who called it. For a device managed by multiple administrators, the last limit values apply. This measure also applies to usage counters. The API returns false if the device has no voice call capability (e.g., a tablet).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isLimitNumberOfCallsEnabled()) {
         Log.d(TAG, "Call limit enabled");
     } else {
         Log.w(TAG, "Call limit disabled");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isLimitNumberOfSmsEnabled()) {
         Log.d(TAG, "SMS limit enabled");
     } else {
         Log.w(TAG, "SMS limit disabled");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isOutgoingMmsAllowed()) {
         Log.d(TAG, "Outgoing MMS is allowed");
     } else {
         Log.w(TAG, "Outgoing MMS is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isOutgoingSmsAllowed()) {
         Log.d(TAG, "Outgoing SMS is allowed");
     } else {
         Log.w(TAG, "Outgoing SMS is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = (EnterpriseDeviceManager)
      getSystemService(EnterpriseDeviceManager.ENTERPRISE_POLICY_SERVICE);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 
 try {
      //check whether the RCS feature is disabled or not.
      boolean result = phoneRestrictionPolicy.isRCSEnabled(PhoneRestrictionPolicy.RCS_FEATURE_ALL));
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.isWapPushAllowed()) {
         Log.d(TAG, "WAP Push processing is allowed");
     } else {
         Log.w(TAG, "WAP Push processing is disallowed");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeIncomingCallExceptionPattern()) {
         Log.d(TAG, "success removing incoming call exception pattern");
     } else {
         Log.w(TAG, "failed removing incoming call exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeIncomingCallRestriction()) {
         Log.d(TAG, "success removing incoming call restriction");
     } else {
         Log.w(TAG, "failed removing incoming call restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeIncomingSmsExceptionPattern()) {
         Log.d(TAG, "success removing incoming sms exception pattern");
     } else {
         Log.w(TAG, "failed removing incoming sms exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeIncomingSmsRestriction()) {
         Log.d(TAG, "success removing incoming SMS restriction");
     } else {
         Log.w(TAG, "failed removing incoming SMS restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeOutgoingCallExceptionPattern()) {
         Log.d(TAG, "success removing outgoing call exception pattern");
     } else {
         Log.w(TAG, "failed removing outgoing call exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeOutgoingCallRestriction()) {
         Log.d(TAG, "success removing outgoing call restriction");
     } else {
         Log.w(TAG, "failed removing outgoing call restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeIncomingSmsExceptionPattern()) {
         Log.d(TAG, "success removing incoming sms exception pattern");
     } else {
         Log.w(TAG, "failed removing incoming sms exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.removeOutgoingSmsRestriction()) {
         Log.d(TAG, "success removing outgoing SMS restriction");
     } else {
         Log.w(TAG, "failed removing outgoing SMS restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters.

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

  phoneRestrictionPolicy.enableLimitNumberOfCalls(true);
  phoneRestrictionPolicy.setLimitOfIncomingCalls(1, 2, 3);
  phoneRestrictionPolicy.setLimitOfOutgoingCalls(1, 2, 3);
  try {
      // Some time after the policy is enabled, the user has probably used some of the quota.
      // The administrator can reset the used quota.
      if (phoneRestrictionPolicy.resetCallsCount())
          Log.d(TAG, "success resetting call used quota");
      } else {
          Log.w(TAG, "failed resetting call used quota");
      }
  } catch (SecurityException e) {
      Log.w(TAG, "SecurityException: " + e);
  }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

  try {
      phoneRestrictionPolicy.setDataCallLimitEnabled(true);
      phoneRestrictionPolicy.setLimitOfDataCalls(1, 2, 3);
      // The user has probably used some of the quota
      // during the time period after the policy is enabled.
      // The administrator can reset the used quota by calling this reset method:
      if (phoneRestrictionPolicy.resetDataCallLimitCounter())
          Log.d(TAG, "success resetting data used quota");
      } else {
          Log.w(TAG, "failed resetting data used quota");
      }
  } catch (SecurityException e) {
      Log.w(TAG, "SecurityException: " + e);
  }
 

For a device managed by multiple administrators, the last limit values set apply.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 phoneRestrictionPolicy.enableLimitNumberOfSms(true);
 phoneRestrictionPolicy.setLimitOfIncomingSms(1, 2, 3);
 phoneRestrictionPolicy.setLimitOfOutgoingSms(1, 2, 3);
 try {
     // The user has probably used some of the quotas
     // after the policy is enabled.
     // The administrator can reset the used quota by calling this reset method:
     if (phoneRestrictionPolicy.resetSmsCount()) {
         Log.d(TAG, "success resetting SMS used quota");
     } else {
         Log.w(TAG, "failed resetting SMs used quota");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

For a device managed by multiple administrators, the last limit values set apply. This setting also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.setDataCallLimitEnabled(true)) {
         Log.w(TAG, "success enabling data call limit");
     } else {
         Log.w(TAG, "failure enabling data call limit");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Note: The maximum supported character length is 30. Since Knox 3.7, it is 60.

 EnterpriseDeviceManager edm = (EnterpriseDeviceManager)
      getSystemService(EnterpriseDeviceManager.ENTERPRISE_POLICY_SERVICE);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();
 
 try {
     // set a new disclaimer text
     String text = "sampleurl";
     if (phoneRestrictionPolicy.setDisclaimerText("text")) {
         Log.d(TAG, "success setting disclaimer text");
     } else {
         Log.w(TAG, "failed setting disclaimer text");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.setEmergencyCallOnly(true)) {
         Log.d(TAG, "success blocking all calls except emergency");
     } else {
         Log.w(TAG, "failed blocking all calls except emergency");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

See setOutgoingCallExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // set a new pattern to block all incoming calls
     if (phoneRestrictionPolicy.setIncomingCallExceptionPattern(".*")) {
         Log.d(TAG, "success setting incoming call exception pattern");
     } else {
         Log.w(TAG, "failed setting incoming call exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // set a new pattern to block all incoming calls
     if (phoneRestrictionPolicy.setIncomingCallRestriction(".*")) {
         Log.d(TAG, "success setting incoming call restriction");
     } else {
         Log.w(TAG, "failed setting incoming call restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingSmsExceptionPattern(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // set a new pattern to block all incoming SMSs
     if (phoneRestrictionPolicy.setIncomingSmsExceptionPattern(".*")) {
         Log.d(TAG, "success setting incoming SMS exception pattern");
     } else {
         Log.w(TAG, "failed setting incoming SMS exception pattern");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

See setOutgoingCallRestriction(String) to get regular expression samples to use in pattern methods.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     // set a new pattern to block all incoming SMS
     if (phoneRestrictionPolicy.setIncomingSmsRestriction(".*")) {
         Log.d(TAG, "success setting incoming SMS restriction");
     } else {
         Log.w(TAG, "failed setting incoming SMS restriction");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

For a device managed by multiple administrators, the last limit values set apply. This setting also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.setDataCallLimitEnabled(true)) {
         // Set the data usage limit to 100MB by day, 500MB by week, 1GB by month
         if (mPhoneRestrictionPolicy.setLimitOfDataCalls(104857600, 524288000, 1073741824)) {
             Log.d(TAG, "success setting data usage limits");
         } else {
             Log.w(TAG, "failure setting data usage limits");
         }
     } else {
         Log.w(TAG, "failure enabling data usage limits");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

For a device managed by multiple administrators, the last limit values set apply. This measure also applies to usage counters. The API returns false if the device has no voice call capability (e.g., a tablet).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.enableLimitNumberOfCalls(true)) {
         // Set the incoming call limit to 5 by day, no limit by week, 100 by
         // month
         if (phoneRestrictionPolicy.setLimitOfIncomingCalls(5, 0, 100)) {
             Log.d(TAG, "success setting incoming call limits");
         } else {
             Log.w(TAG, "failure setting incoming call limits");
         }
     } else {
         Log.w(TAG, "failure enabling call limits");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

For a device managed by multiple administrators, the last limit values set apply. This setting also applies to usage counters.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 PhoneRestrictionPolicy phoneRestrictionPolicy = edm.getPhoneRestrictionPolicy();

 try {
     if (phoneRestrictionPolicy.enableLimitNumberOfSms(true)) {
         // Set the incoming SMS message limit to 10 by day, no limit by week, no limit
         // by month
         if (phoneRestrictionPolicy.setLimitOfIncomingSms(10, 0, 0)) {
             Log.d(TAG, "success setting incoming SMS limits");
         } else {
             Log.w(TAG, "failure setting incoming SMS limits");
         }
     } else {
         Log.w(TAG, "failure enabling SMS limits");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }