Bind and verify user devices

Map<String, String> customClaims  = new HashMap<>() {{
    put("os", "value1");
}};

callback.sign(context, customClaims, new FRListener<Void>() {
    @Override
    public void onSuccess(Void result) {
        // Proceed to the next node
    }

    @Override
    public void onException(Exception e) {
        // Check for DeviceBindingErrorStatus.InvalidCustomClaims status
        // and fix invalid custom claims if needed
        // Proceed to the next node
    }
});

try {
    callback.sign(context, mapOf("os" to "android"))
    // Proceed to the next node
} catch (e: CancellationException) {
    // Ignore, due to configuration change
} catch (e: DeviceBindingException) {
    // Map custom client errors:
    when (e.status) {
        is UnRegister -> {
            callback.setClientError("UnReg")
        }
        is UnAuthorize -> {
            callback.setClientError("UnAuth")
        }
        is DeviceBindingErrorStatus.InvalidCustomClaims -> {
          // Fix the invalid custom claims
        }
    }
    // Proceed to the next node
}

callback.sign(
  customClaims: [
    "platform": "iOS",
    "isCompanyPhone": true,
    "lastUpdated": Int(Date().timeIntervalSince1970)
  ]
) { result in
      switch result
      {
          case .success:
              // Proceed to the next node
          case .failure(let error):
              // Handle the error and proceed to the next node
              if error == .invalidCustomClaims {
                  // Fix the invalid custom claims
                  print(error.errorMessage)
                  return
              }
      }
  }

val frUserKeys = FRUserKeys(context)
var keys: List<UserKey> = frUserKeys.loadAll()

let userKeys = FRUserKeys().loadAll()

val frUserKeys = FRUserKeys(context)
frUserKeys.delete(userKey, false)

do {
    try FRUserKeys().delete(
        userKey: userKey,
        forceDelete: false
    )
}

catch {
    print("Failed to delete public key from server")
}

val deviceBindingCallback = node.getCallback(DeviceBindingCallback::class.java)

deviceBindingCallback.bind(
    activity,
    prompt = Prompt("Custom Title", "Custom Subtitle", "Custom Description"),
    listener =
        object : FRListener<Void?> {
            override fun onSuccess(result: Void?) {
                node.next(activity, activity)
            }

            override fun onException(e: java.lang.Exception) {
                node.next(activity, activity)
            }
        }
)

val deviceSigningVerifierCallback = node.getCallback(DeviceSigningVerifierCallback::class.java)

deviceSigningVerifierCallback.sign(
    activity,
    prompt = Prompt("Custom Title", "Custom Subtitle", "Custom Description"),
    listener =
        object : FRListener<Void?> {
            override fun onSuccess(result: Void?) {
                node.next(activity, activity)
            }

            override fun onException(e: java.lang.Exception) {
                node.next(activity, activity)
            }
        }
)

if callback.type == "DeviceBindingCallback",
let deviceBindingCallback = callback as? DeviceBindingCallback {
    let customPrompt = Prompt (
        title: "Custom Title",
        subtitle: "Custom Subtitle",
        description: "Custom Description"
    )
    deviceBindingCallback.bind (prompt: customPrompt)
    { result in
        /// process the result
    }
    return
}

if callback.type == "DeviceSigningVerifierCallback",
let deviceSigningVerifierCallback = callback as? DeviceSigningVerifierCallback {
    let customPrompt = Prompt (
        title: "Custom Title",
        subtitle: "Custom Subtitle",
        description: "Custom Description"
    )
    deviceSigningVerifierCallback.sign (prompt: customPrompt)
    { result in
        /// process the result
    }
    return
}

callback.bind(requireContext(), deviceBindingAuthenticationType -> {
    switch (deviceBindingAuthenticationType) {
        case APPLICATION_PIN: {
            return new CustomAppPinDeviceAuthenticator();
        }
        default:
            return callback.getDeviceAuthenticator(deviceBindingAuthenticationType);
    }
}, new FRListener<Void>() {
    @Override
    public void onSuccess(Void result) {
      // Proceed to the next node
    }

    @Override
    public void onException(Exception e) {
      // Proceed to the next node
    }
});

public class CustomAppPinDeviceAuthenticator extends ApplicationPinDeviceAuthenticator {

    public CustomAppPinDeviceAuthenticator() {
        super((prompt, fragmentActivity, $completion) -> {
            $completion.resumeWith("1234".toCharArray());
            return IntrinsicsKt.getCOROUTINE_SUSPENDED();
        });
    }
}

class CustomPinCollector: PinCollector {
    override suspend fun collectPin(prompt: Prompt, fragmentActivity: FragmentActivity): CharArray {}
}

class CustomAppPinDeviceAuthenticator: ApplicationPinDeviceAuthenticator(CustomPinCollector())

callback.bind(context) {
    when (it) {
        // Implement your custom app PIN UI...
        APPLICATION_PIN -> CustomAppPinDeviceAuthenticator()
        else -> {
            callback.getDeviceAuthenticator(it)
        }
    }
}

callback.bind(deviceAuthenticator: { type in
    switch type {
        case .applicationPin:
            return ApplicationPinDeviceAuthenticator(pinCollector: CustomPinCollector())
        default:
            return callback.getDeviceAuthenticator(type: type)
    }
}, completion: { result in
    switch result {
        case .success:
            // Proceed to the next node
        case .failure(let error):
            // Handle the error and proceed to the next node
    }
})

class CustomPinCollector: PinCollector {
    func collectPin(prompt: Prompt, completion: @escaping (String?) -> Void) {
        // Implement your custom app PIN UI...
        completion("1234")
    }
}

callback.sign(requireContext(), new CustomUserKeySelector(),  new FRListener<Void>() {
   @Override
   public void onSuccess(Void result) {

   }

   @Override
   public void onException(Exception e) {

   }
});

// Custom user selector that always returns the most recently created key
public class CustomUserKeySelector implements UserKeySelector {

    @Nullable
    @Override
    public Object selectUserKey(@NonNull UserKeys userKeys, @NonNull FragmentActivity fragmentActivity, @NonNull Continuation<? super UserKey> $completion) {
        $completion.resumeWith(userKeys.getItems().get(0));
        return IntrinsicsKt.getCOROUTINE_SUSPENDED();
    }
}

callback.sign(context, CustomUserKeySelector())

// Custom user selector that always returns the most recently created key
class CustomUserKeySelector : UserKeySelector {
    override suspend fun selectUserKey(userKeys: UserKeys,
                                       fragmentActivity: FragmentActivity): UserKey {
        return userKeys.items[0]
    }
}

callback.sign(userKeySelector: CustomUserKeySelector()) { result in
    switch result {
        case .success:
            // Proceed to the next node
        case .failure(let error):
            // Handle the error and proceed to the next node
    }
}

// Custom user selector that always returns the most recently created key
class CustomUserKeySelector: UserKeySelector {
    func selectUserKey(userKeys: [UserKey], selectionCallback: @escaping UserKeySelectorCallback) {
        selectionCallback(userKeys.first)
    }
}