NOTE : All other settings values are set to default.

An administrator can use this API to remotely configure a Microsoft Exchange ActiveSync account on the user's device without user interaction. Most of these settings can be changed by the user except 'domain' and 'username'.

Exchange account base parameters: Exchange Account class.

The administrator can register ACTION_EXCHANGE_ACCOUNT_ADD_RESULT intent to receive account creation status and account Id.

The administrator can use removePendingAccount(String, String, String, String) to delete nonvalidated pending accounts.

NOTE:

On Android version 4.0 onwards:

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.
                         getExchangeAccountPolicy();
  try {
     accountId =  exchangeAccountPolicy.addNewAccount(new ExchangeAccount(
                 "testeasid@easserver.com", "testeasid","easDomain", "easserver.com",
                 "Password@123"));
     if(accountId >= 0){
         Log.d(TAG,"Add a new exchange account with base parameters succeeded!");
         // Administrator needs to call sendAccountsChangedBroadcast() API
         // to notify about the Microsoft Exchange account addition.
         exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," Add a new exchange account with base parameters failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.
                         getExchangeAccountPolicy();
  try {
     accountId =  exchangeAccountPolicy.addNewAccount(new ExchangeAccount(
                 "testeasid@easserver.com", "testeasid","easDomain", "easserver.com",
                 "Password@123"));
     if(accountId >= 0){
         Log.d(TAG,"Add a new exchange account with base parameters succeeded!");
         // Administrator needs to call sendAccountsChangedBroadcast() API
         // to notify about the Microsoft Exchange account addition.
         exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," Add a new exchange account with base parameters failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.allowInComingAttachments(false,accId);
      if (true == enable) {
          // administrator has disabled Incoming attachments for Exchange accounts.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.allowInComingAttachments(false, accId);
      if (true == enable) {
          // administrator has disabled Incoming attachments for Exchange accounts.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result  = exchangeAccountPolicy.deleteAccount(
         accountId);
      if(result){
          Log.d(TAG,"deleting account succeede!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account deletion.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"deleting account failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result  = exchangeAccountPolicy.deleteAccount(
         accountId);
      if(result){
          Log.d(TAG,"deleting account succeede!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account deletion.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"deleting account failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      Account  mAccnt  = exchangeAccountPolicy.getAccountDetails(
                  accountId);
      if(mAccnt != null){
          Log.d(TAG," return account details are not null (account exists)!");
      }else{
          Log.d(TAG," return account details are null (account does not exist).");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      Account  mAccnt  = exchangeAccountPolicy.getAccountDetails(
                  accountId);
      if(mAccnt != null){
          Log.d(TAG," return account details are not null (account exists)!");
      }else{
          Log.d(TAG," return account details are null (account does not exist).");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId  = exchangeAccountPolicy.getAccountId("easDomain",
                  "testeasid","easserver.com");
      if(accountId >0){
          Log.d(TAG," get account Id is valid/successful!");
      }else{
          Log.d(TAG," get account Id is invalid/failure.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId  = exchangeAccountPolicy.getAccountId("easDomain",
                  "testeasid","easserver.com");
      if(accountId >0){
          Log.d(TAG," get account Id is valid/successful!");
      }else{
          Log.d(TAG," get account Id is invalid/failure.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      Account[] accounts = exchangeAccountPolicy.getAllEASAccounts() ;
      if(accounts!= null){
          Log.d(TAG,"Retrieving Microsoft Exchange account detail succeeded! One or more accounts exist.");
      }else{
          Log.d(TAG," No Microsoft Exchange accounts exist.");
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      Account[] accounts = exchangeAccountPolicy.getAllEASAccounts() ;
      if(accounts!= null){
          Log.d(TAG,"Retrieving Microsoft Exchange account detail succeeded! One or more accounts exist.");
      }else{
          Log.d(TAG," No Microsoft Exchange accounts exist.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  String  deviceId = exchangeAccountPolicy.getDeviceId();
  if(deviceId != null){
      Log.d(TAG," Device Id:" +deviceId);
  }else{
      Log.d(TAG," Device Id is 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  String  deviceId = exchangeAccountPolicy.getDeviceId();
  if(deviceId != null){
      Log.d(TAG," Device Id:" +deviceId);
  }else{
      Log.d(TAG," Device Id is null" );
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getIncomingAttachmentsSize(accId);
      // Incoming attachments of Exchange accounts is enable.
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getIncomingAttachmentsSize(accId);
      // Incoming attachments of Exchange accounts is enable.
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxCalendarAgeFilter(accId);
      //  All(value 0), 2 weeks(value 1), 1 months(value 2), 3 months(value 3), 6 months (value 4)
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxCalendarAgeFilter(accId);
      //  All(value 0), 2 weeks(value 1), 1 months(value 2), 3 months(value 3), 6 months (value 4)
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxEmailAgeFilter(accId);
      //  All(value 0), 2 weeks(value 1), 1 months(value 2), 3 months(value 3), 6 months (value 4)
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      int value = exchangeAccountPolicy.getMaxEmailAgeFilter(accId);
      //  All(value 0), 2 weeks(value 1), 1 months(value 2), 3 months(value 3), 6 months (value 4)
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxEmailBodyTruncationSize(accId);

  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxEmailBodyTruncationSize(accId);

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

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxEmailHTMLBodyTruncationSize(accId);

  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      int value = exchangeAccountPolicy.getMaxEmailHTMLBodyTruncationSize(accId);

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

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.getRequireEncryptedSMIMEMessages(accId);
      if (true == enable) {
          // encrypted S/MIME messages are required for this account
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.getRequireEncryptedSMIMEMessages(accId);
      if (true == enable) {
          // encrypted S/MIME messages are required for this account
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.getRequireSignedSMIMEMessages(accId);
      if (true == enable) {
          // signed S/MIME messages are required for this account
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.getRequireSignedSMIMEMessages(accId);
      if (true == enable) {
          // signed S/MIME messages are required for this account
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      String alias = exchangeAccountPolicy.getSMIMECertificateAlias(accId, type);
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      String alias = exchangeAccountPolicy.getSMIMECertificateAlias(accId, type);
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.isIncomingAttachmentsAllowed(accId);
      if (true == enable) {
          // Incoming attachments of Exchange accounts are enable.
      }
      else{
          // Incoming attachments of Exchange accounts are disable.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.isIncomingAttachmentsAllowed(accId);
      if (true == enable) {
          // Incoming attachments of Exchange accounts are enable.
      }
      else{
          // Incoming attachments of Exchange accounts are disable.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
 try {
         exchangeAccountPolicy.removePendingAccount("testeasid@easserver.com",
                           "testeasid", "easserver.com", "mail.easserver.com");
 } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
 try {
         exchangeAccountPolicy.removePendingAccount("testeasid@easserver.com",
                           "testeasid", "easserver.com", "mail.easserver.com");
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result  = exchangeAccountPolicy.deleteAccount(
         accountId);
      if(result){
          Log.d(TAG,"deleting account succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account deletion.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"deleting account failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result  = exchangeAccountPolicy.deleteAccount(
         accountId);
      if(result){
          Log.d(TAG,"deleting account succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account deletion.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"deleting account failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAcceptAllCertificates(
              true, accountId);
      if(result){
          Log.d(TAG,"setAcceptAllCertificates succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setAcceptAllCertificates failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAcceptAllCertificates(
              true, accountId);
      if(result){
          Log.d(TAG,"setAcceptAllCertificates succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setAcceptAllCertificates failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAccountName(
          "MytestAccount",accountId);
      if(result){
          Log.d(TAG,"setAccountName succeeded!");
          // Administrator needs to call sendAccountsChangedBroadcast() API
          // to notify about the Microsoft Exchange account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setAccountName failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAccountName(
          "MytestAccount",accountId);
      if(result){
          Log.d(TAG,"setAccountName succeeded!");
          // Administrator needs to call sendAccountsChangedBroadcast() API
          // to notify about the Microsoft Exchange account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setAccountName failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.
             setAlwaysVibrateOnEmailNotification(true, accountId);
      if(result){
          Log.d(TAG,"setAlwaysVibrateOnEmailNotification succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"setAlwaysVibrateOnEmailNotification failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.
             setAlwaysVibrateOnEmailNotification(true, accountId);
      if(result){
          Log.d(TAG,"setAlwaysVibrateOnEmailNotification succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"setAlwaysVibrateOnEmailNotification failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAsDefaultAccount(
                     accountId);
      if(result){
          Log.d(TAG,"setAsDefaultAccount succeeded!");
      }else{
          Log.d(TAG,"setAsDefaultAccount failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }

 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setAsDefaultAccount(
                     accountId);
      if(result){
          Log.d(TAG,"setAsDefaultAccount succeeded!");
      }else{
          Log.d(TAG,"setAsDefaultAccount failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }

 

  byte[] read2array(String fileName) throws IOException {
      File file = new File(fileName);
      FileInputStream is = null;
      byte[] bytes = null;
      try {
      is = new FileInputStream(file);
      } catch (FileNotFoundException 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 was not completely read: " + file.getName());
          }
          // Close the input stream, all file contents are in the bytes variable
          is.close();
      }
      return bytes;
  }

 void setAccountCertificate() {
      long accountId = -1;
      byte[] certData = null;
      try {
          certData = read2array(certificatePath);
      } catch (IOException e) {
          e.printStackTrace();
      }

      EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
      ExchangeAccountPolicy  exchangeAccountPolicy = edm.
          getExchangeAccountPolicy();

      try {
          accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
          exchangeAccountPolicy.setClientAuthCert(certData, "password245",
             accountId);
      } catch(SecurityException e) {
          Log.w(TAG,"SecurityException: "+e);
      }
  }
 

  byte[] read2array(String fileName) throws IOException {
      File file = new File(fileName);
      FileInputStream is = null;
      byte[] bytes = null;
      try {
      is = new FileInputStream(file);
      } catch (FileNotFoundException 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 was not completely read: " + file.getName());
          }
          // Close the input stream, all file contents are in the bytes variable
          is.close();
      }
      return bytes;
  }

 void setAccountCertificate() {
      long accountId = -1;
      byte[] certData = null;
      try {
          certData = read2array(certificatePath);
      } catch (IOException e) {
          e.printStackTrace();
      }

      // 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);
      ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();

      try {
          accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
          exchangeAccountPolicy.setClientAuthCert(certData, "password245",
             accountId);
      } catch(SecurityException e) {
          Log.w(TAG,"SecurityException: "+e);
      }
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");

      boolean result = exchangeAccountPolicy.setDataSyncs(true, true,false,
           false,accountId);
      if(result){
          Log.d(TAG,"setDataSyncs succeeded!");
      }else{
          Log.d(TAG," setDataSyncs failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");

      boolean result = exchangeAccountPolicy.setDataSyncs(true, true,false,
           false,accountId);
      if(result){
          Log.d(TAG,"setDataSyncs succeeded!");
      }else{
          Log.d(TAG," setDataSyncs failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  String alias = "test";
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      boolean ret = exchangeAccountPolicy.setForceSMIMECertificateAlias(accId, alias, type);
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  String alias = "test";
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      boolean ret = exchangeAccountPolicy.setForceSMIMECertificateAlias(accId, alias, type);
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  String alias = "test";
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      // Please refer to UCM DEV guide to see how to retrieve storageName parameter
      boolean ret = exchangeAccountPolicy.setForceSMIMECertificateAlias(accId, storageName, alias, type);
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  String alias = "test";
  int type = 1; // ExchangeAccountPolicy.ENFORCE_SMIME_ALIAS_TYPE_ENCRYPT;
  try {
      // Please refer to UCM DEV guide to see how to retrieve storageName parameter
      boolean ret = exchangeAccountPolicy.setForceSMIMECertificateAlias(accId, storageName, alias, type);
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setIncomingAttachmentsSize(1000,accId);
      if (true == enable) {
          // administrator set maximum attachment size of Exchange accounts as 1000 byte.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setIncomingAttachmentsSize(1000,accId);
      if (true == enable) {
          // administrator set maximum attachment size of Exchange accounts as 1000 byte.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxCalendarAgeFilter(4,accId);
      if (true == enable) {
          // administrator set maximum calendar age of Exchange accounts as 6 months.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxCalendarAgeFilter(4,accId);
      if (true == enable) {
          // administrator set maximum calendar age of Exchange accounts as 6 months.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailAgeFilter(4,accId);
      if (true == enable) {
          // administrator set maximum Email age of Exchange accounts as 2 weeks.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailAgeFilter(4,accId);
      if (true == enable) {
          // administrator set maximum Email age of Exchange accounts as 2 weeks.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailBodyTruncationSize(20,accId);
      if (true == enable) {
          // administrator set maximum Email Body Truncation size of Exchange accounts as 20 kb.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailBodyTruncationSize(20,accId);
      if (true == enable) {
          // administrator set maximum Email Body Truncation size of Exchange accounts as 20 kb.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailBodyTruncationSize(20,accId);
      if (true == enable) {
          // administrator set maximum Email HTML Body Truncation size of Exchange accounts as 20 kb.
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean enable = exchangeAccountPolicy.setMaxEmailBodyTruncationSize(20,accId);
      if (true == enable) {
          // administrator set maximum Email HTML Body Truncation size of Exchange accounts as 20 kb.
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setPassword("password@123",
                           accountId);
      if(result){
          Log.d(TAG,"setPassword succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setPassword failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setPassword("password@123",
                           accountId);
      if(result){
          Log.d(TAG,"setPassword succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setPassword failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setPastDaysToSync(2,
                      accountId);
      if(result){
          Log.d(TAG,"setPastDaysToSync succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setPastDaysToSync failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setPastDaysToSync(2,
                      accountId);
      if(result){
          Log.d(TAG,"setPastDaysToSync succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setPastDaysToSync failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

  EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean result = exchangeAccountPolicy.setRequireEncryptedSMIMEMessages(accId, true);
      if (true == result) {
          // encrypted S/MIME messages are now required for this account
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  long accId = 1;
  try {
      boolean result = exchangeAccountPolicy.setRequireEncryptedSMIMEMessages(accId, true);
      if (true == result) {
          // encrypted S/MIME messages are now required for this account
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      boolean result = exchangeAccountPolicy.setRequireSignedSMIMEMessages(accId, true);
      if (true == result) {
          // signed S/MIME messages are now required for this account
      }
  } 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      boolean result = exchangeAccountPolicy.setRequireSignedSMIMEMessages(accId, true);
      if (true == result) {
          // signed S/MIME messages are now required for this account
      }
  } catch (SecurityException e) {
      Log.w(TAG,"SecurityException: " + e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");

      boolean  result = exchangeAccountPolicy.setSSL(true,
                      accountId);
      if(result){
          Log.d(TAG,"setSSL succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"setSSL failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");

      boolean  result = exchangeAccountPolicy.setSSL(true,
                      accountId);
      if(result){
          Log.d(TAG,"setSSL succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG,"setSSL failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setSignature(
                  "myTestSignature",accountId);
      if(result){
          Log.d(TAG,"setSignature succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setSignature failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean  result  = exchangeAccountPolicy.setSignature(
                  "myTestSignature",accountId);
      if(result){
          Log.d(TAG,"setSignature succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
     }else{
          Log.d(TAG,"setSignature failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result = exchangeAccountPolicy.setSyncPeakTimings(62, 480,
              1020, accountId);
      if(result){
          Log.d(TAG,"setSyncPeakTimings succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setSyncPeakTimings failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result = exchangeAccountPolicy.setSyncPeakTimings(62, 480,
              1020, accountId);
      if(result){
          Log.d(TAG,"setSyncPeakTimings succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setSyncPeakTimings failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

• Value -2 - Automatic push
• Value -1 - Never
• Value 5 - 5 minutes
• Value 10 - 10 minutes
• Value 15 - 15 minutes
• Value 30 - 30 minutes
• Value 60 - 1 hour
• Value 240 - 4 hours
• Value 720 - 12 hours

• Value -2 - Automatic push
• Value -1 - Never
• Value 5 - 5 minutes
• Value 10 - 10 minutes
• Value 15 - 15 minutes
• Value 30 - 30 minutes
• Value 60 - 1 hour
• Value 240 - 4 hours
• Value 720 - 12 hours

 long  accountId = -1;
 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
  ExchangeAccountPolicy  exchangeAccountPolicy = edm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result = exchangeAccountPolicy.setSyncSchedules(-2, 60, 0,
                  accountId);
      if(result){
          Log.d(TAG,"setSyncSchedules succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setSyncSchedules failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }
 

 long  accountId = -1;
 // 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);
  ExchangeAccountPolicy  exchangeAccountPolicy = kcm.getExchangeAccountPolicy();
  try {
      accountId = exchangeAccountPolicy.getAccountId("easDomain",
             "testeasid","easserver.com");
      boolean result = exchangeAccountPolicy.setSyncSchedules(-2, 60, 0,
                  accountId);
      if(result){
          Log.d(TAG,"setSyncSchedules succeeded!");
          // Administrator need to call sendAccountsChangedBroadcast() API
          // to notify the  exchange(EAS) account changes.
          exchangeAccountPolicy.sendAccountsChangedBroadcast();
      }else{
          Log.d(TAG," setSyncSchedules failed.");
      }
  } catch(SecurityException e) {
      Log.w(TAG,"SecurityException: "+e);
  }