Migrate authentication from version 100.x to version 200.x

ArcGISEnvironment.authenticationManager

AuthenticationManager()

// ArcGIS authentication challenge handler
ArcGISEnvironment.authenticationManager.arcGISAuthenticationChallengeHandler =
  ArcGISAuthenticationChallengeHandler { challenge ->
    // If OAuth user configuration is available for the challenge then create `OAuthUserCredential`
    if (oAuthConfiguration.canBeUsedForUrl(challenge.requestUrl)) {
      // prompt to open browser and sign in with OAuth username and password
      // ...
      ArcGISAuthenticationChallengeResponse
        .ContinueWithCredential(oAuthUserCredential)
    } else {
      // ...
      // Prompt user for getting the username and password to create the `TokenCredential`
      // ...
      // Create TokenCredential
      val tokenCredential = TokenCredential.createWithChallenge(challenge,username, password, 30).getOrNull()
      tokenCredential?.let { ArcGISAuthenticationChallengeResponse.ContinueWithCredential(it) } ?: ArcGISAuthenticationChallengeResponse.ContinueAndFail
    }
  }

// Network authentication challenge handler
ArcGISEnvironment.authenticationManager.networkAuthenticationChallengeHandler = NetworkAuthenticationChallengeHandler { authenticationChallenge ->
  when (authenticationChallenge.networkAuthenticationType) {
    is NetworkAuthenticationType.UsernamePassword ->
    // create the Password Credential
      val credential = PasswordCredential(username, password)
    NetworkAuthenticationChallengeResponse.ContinueWithCredential(credential)
    is NetworkAuthenticationType.ServerTrust ->
      NetworkAuthenticationChallengeResponse.ContinueWithCredential(ServerTrust)
    is NetworkAuthenticationType.Certificate -> {
      val selectedAlias = showCertificatePicker(activityContext)
      selectedAlias?.let {
        NetworkAuthenticationChallengeResponse.ContinueWithCredential(CertificateCredential(it))
      } ?: NetworkAuthenticationChallengeResponse.ContinueAndFail
    }
  }
}

private class CustomChallengeHandler implements AuthenticationChallengeHandler {

  @Override
  public AuthenticationChallengeResponse handleChallenge(AuthenticationChallenge challenge) {
    // handle authentication challenge by calling appropriate function on `challenge` object
    return new AuthenticationChallengeResponse(
            AuthenticationChallengeResponse.Action.CONTINUE_WITH_CREDENTIAL, challenge);
  }
}

AuthenticationManager.setAuthenticationChallengeHandler(new CustomChallengeHandler());

// Define OAuthConfiguration
private val oAuthConfiguration = OAuthUserConfiguration(
  "<portal URL>",
  "<ClientID>",
  "<redirectURI>"
)

// Create OAuthUserCredential by passing OAuthConfiguration and initiate OAuth sign in process by invoking the provided startSignIn lambda
val oAuthUserCredential = OAuthUserCredential.create(oAuthConfiguration) { oAuthUserSignIn ->
  promptForOAuthUserSignIn(oAuthUserSignIn)
}.getOrThrow()

OAuthConfiguration configuration = new OAuthConfiguration(url, clientId, redirectUri);
AuthenticationManager.addOAuthConfiguration(configuration);

scope.launch {
  var tokenCredential = TokenCredential.create(requestUrl,username, password, 30).getOrNull()
}

UserCredential credential = new UserCredential("<username>", "<password>");

var accessToken = "xxxxxxx"
val tokenInfo = TokenInfo(accessToken, Instant.now().plus(2, ChronoUnit.HOURS), true)
var pregeneratedTokenCredential = PregeneratedTokenCredential(requestUrl, tokenInfo)

// Pregenerated Token credential with token/referer
UserCredential credential = UserCredential.createFromToken("token", "referer");

private suspend fun showCertificatePicker(activityContext: Activity): String? =
  suspendCancellableCoroutine { continuation ->
    val aliasCallback = KeyChainAliasCallback { alias ->
      continuation.resume(alias)
    }
    KeyChain.choosePrivateKeyAlias(
      activityContext, aliasCallback, null, null, null, null
    )
  }

val selectedAlias = showCertificatePicker(activityContext)

var certificateCredential = selectedAlias?.let { CertificateCredential(it) } ?: null

// Client certificate credential
CertificateCredential certificateCredential = CertificateCredential("<certificate_path>", "certificate_password");

var passwordCredential = PasswordCredential("username", "password")

UserCredential credential = new UserCredential("<username>", "<password>");

var trustCredential = NetworkCredential.serverTrust

AuthenticationManager.setTrustAllSigners(true);

AuthenticationManager.setSelfSignedCertificateListener(selfSignedCertificateListener);

ArcGISEnvironment.authenticationManager.arcGISCredentialStore
ArcGISEnvironment.authenticationManager.networkCredentialStore

AuthenticationManager.CredentialCache;

lifecycleScope.launch {
  val arcGISCredentialStore = ArcGISCredentialStore.createWithPersistence().getOrThrow()
  ArcGISEnvironment.authenticationManager.arcGISCredentialStore = arcGISCredentialStore

  val networkCredentialStore = NetworkCredentialStore.createWithPersistence().getOrThrow()
  ArcGISEnvironment.authenticationManager.networkCredentialStore = networkCredentialStore
}

AuthenticationManager.CredentialCache.setPersistence(credentialPersistence)

var credential = TokenCredential.create(requestUrl,username, password, 30).getOrNull()
credential?.let {
  //  Preemptively add the credential to the store
  ArcGISEnvironment.authenticationManager.arcGISCredentialStore.add(it)
  var portal = Portal(url = "https://www.arcgis.com", Portal.Connection.Authenticated)
  portal.load()
}

// Set credential preemptively on the specific object before loading.
UserCredential credential = UserCredential("<username>", "<password>");
Portal portal =  new Portal("https://www.arcgis.com");
portal.setCredential(credential);
portal.loadAsync();
portal.addDoneLoadingListener(new Runnable() {
   @Override
   public void run() {
    // handle success or failure
   }
});