This class is a Service that helps platform discover and bind to the client. Once the class has been extended in client application, declare the class as a service with the following intent filter in AndroidManifest.xml -

     com.samsung.android.knox.ddar.BIND_DUAL_DAR_CLIENT
 

     <?xml version="1.0" encoding="utf-8"?>
     <manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.samsung.android.knox.test">
         <application>
         <meta-data android:name="supportedDualDarSdkVersion"
             android:value="1.1" />
         <service
             android:name="com.samsung.android.knox.test.MyDualDARClient">
             <intent-filter>
                 <action android:name="com.samsung.android.knox.ddar.BIND_DUAL_DAR_CLIENT" />
             </intent-filter>
         </service>
         </application>
     </manifest>
 

Sample Dual DAR Client implementation:

     public class MyDualDARClient extends DualDARClient {

          public boolean isSupported(int feature) {
              if(feature == FEATURE_RESET_PASSWORD) {
                  return true;
              }
              return false;
          }

          public boolean onClientBringup() {
              // Install new version of dual dar client library and other files if version mismatch
              if(!getInstalledClientLibraryVersion().equals(CLIENT_VERSION)){
                  List<String> secondaryLibs = new ArrayList<>();
                  secondaryLibs.add(PROP_FILE);
                  if (installLibrary(CLIENT_LIB_FILE_NAME, secondaryLibs, true) != ERROR_NONE) {
                      Log.e(TAG, "Error installing Dual DAR client lib" + RELAY_FILE_NAME);
                      return false;
                  }
              }

              if(!getInstalledClientLibraryVersion().equals(CLIENT_VERSION)){
                  Log.e(TAG, "Version mismatch for Dual DAR client lib. Expected " + CLIENT_VERSION + " but installed " + getInstalledClientLibraryVersion());
                  return false;
              }
              return true;
         }

         public boolean onDualDARSetupForUser(int userId) {
              // Generate Secret (Master Key) and set it to platform for (de)encrypting filesystem
              byte[] masterKey = generateSecretKey();
              Map<String, Byte[]> secrets = new HashMap<>();
              Byte[] secretData = new Byte[masterKey.length];
              for(int i=0;i<masterKey.length;i++) {
                  secretData[i] = masterKey[i];
              }
              secrets.put(MASTER_KEY_ALIAS, secretData);
              setSecret(userId, secrets);

              // Generate and save salt
              byte[] salt = generateAndSaveSalt();

              // Generate and save default auth token
              byte[] defAuthToken = generateAndSaveDefAuthToken();

              // Encrypt master key and save
              saveEncryptedMasterKey(encryptMasterKeyWithPassword(masterKey, defAuthToken, salt));

              return true;
         }

      public boolean onPasswordAuth(int userId, byte[] password) {
          byte[] salt = getSalt();

          if (password == null) {
              //get default password
              password = getDefaultAuthToken();
          }

          // Generate KEK using given auth token
          SecretKey kek = generateKek(password, salt);

          // Decrypt the encrypted master key on disk with KEK and set to platform
          byte[] masterKey = getSecret(kek, getEncryptedMasterKey());

          // Decrypt the encrypted master key on disk with KEK and set to platform
          Map<String, Byte[]> secrets = new HashMap<>();
          Byte[] secretData = new Byte[masterKey.length];
          for(int i=0;i<masterKey.length;i++) {
              secretData[i] = masterKey[i];
          }
          secrets.put(MASTER_KEY_ALIAS, secretData);
          setSecret(userId, secrets);

          return true;
      }

      public boolean onPasswordChange(int userId, byte[] oldPassword, byte[] newPassword) {
          byte[] salt = getSalt();
          if(oldPassword == null) {
              oldPassword = getDefaultAuthToken();
          }
          saveEncryptedMasterKey(reEncryptMasterKeyWithNewPassword(
              getEncryptedMasterKey(), derivedOldSystemToken, derivedNewSystemToken, salt));
          return true;
      }

      public void onDataLockStateChange(int userId, boolean locked) {
          Log.d(TAG, " onDataLockStateChange " + userId + " locked: " + locked);
      }

      public boolean onDualDARDestroyForUser(int userId) {
          destroyKeysAndTokens(userId);
          return true;
      }

      public boolean onSetResetPasswordToken(int userId, byte[] password, long tokenHandle, byte[] token) {
          // Decrypt Master Key using password and re-encrypt with token
          EncryptedMasterKey reEncryptedMasterKey = null;
          byte[] salt = getSalt();
          if(password == null) {
              password = getDefaultAuthToken();
          }

          reEncryptedMasterKey = reEncryptMasterKeyWithNewPassword(
              getEncryptedMasterKey(), password, token, salt);

          // Save token encrypted Master Key
          saveTokenEncryptedMasterKey(reEncryptedMasterKey, userId, tokenHandle);

          // Save token handle
          addTokenHandleAndSave(userId, tokenHandle);
          return true;
      }

      public void onClearResetPasswordToken(int userId, long tokenHandle) {
          // Clear token encrypted Master Key
          removeTokenEncryptedMasterKey(userId, tokenHandle);

          // Clear token handle
          removeTokenHandleAndSave(userId, tokenHandle);
      }

      public boolean onResetPasswordWithToken(int userId, byte[] newPassword, long tokenHandle, byte[] token) {
          // Decrypt Master Key using token and re-encrypt with new password
          EncryptedMasterKey reEncryptedMasterKey = null;
          byte[] salt = getSalt();

          if(newPassword == null) {
              newPassword = getDefaultAuthToken();
          }

          reEncryptedMasterKey = reEncryptMasterKeyWithNewPassword(
          getTokenEncryptedMasterKey(userId, tokenHandle), token, newPassword, salt);

          saveEncryptedMasterKey(reEncryptedMasterKey);
          return true;
      }
 }