Customer authentication

public static void setOnClientStateChangeListener(OnClientStateChangeListener listener)

fun setOnClientStateChangeListener(listener:OnClientStateChangeListener)

Client.setOnClientStateChangeListener(listener);

Client.setOnClientStateChangeListener(listener)

public static void removeClientStateChangeListener()

fun removeClientStateChangeListener()

Client.removeClientStateChangeListener();

Client.removeClientStateChangeListener()

public static IApiCall registerAccount(@NonNull RegisterClient registerClient)

fun registerAccount(registerClient: RegisterClient): IApiCall

private IApiCall signUpCall;
private void signUp(RegisterClient registerClient) {
        if (signUpCall != null) signUpCall.cancel();
        signUpCall = Client.registerAccount(registerClient);
        signUpCall.onSubscribe(() -> toggleLoading(true))
                  .doFinally(() -> toggleLoading(false))
                  .execute(this::onSignUpSuccessful, this::onSignUpFailure);
    }

private var signUpCall: IApiCall
    private fun signUp(registerClient: RegisterClient) {
        signUpCall!!.cancel()
        signUpCall = Client.registerAccount(registerClient)
        signUpCall!!.onSubscribe({ toggleLoading(true) })
            .doFinally({ toggleLoading(false) })
            .execute(({ this.onSignUpSuccessful() }), ({ this.onSignUpFailure() }))
    }

public static IApiCall confirmAccount(String token)

fun confirmAccount(token: String): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.confirmAccount(token);
            call.execute(this::onSuccess, this::onError);

private val call: IApiCall? = null
			call.cancel();
            call = Client.confirmAccount(token);
            call.execute(this::onSuccess, this::onError);

public static IApiCall activateAccount(String email)

fun activateAccount(email: String): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.activateAccount(email);
            call.execute(this::onSuccess, this::onError);

private val call: IApiCall? = null
			call.cancel();
            call = Client.activateAccount(email);
            call.execute(this::onSuccess, this::onError);

public static IApiCall requestAccountActivationByPin(String email)

fun requestAccountActivationByPin(email:String):IApiCall

IApiCall apiCall;
apiCall = Client.requestAccountActivationByPin(email);
apiCall.execute(this::onSuccess, this::onFailure);

val apiCall:IApiCall
apiCall = Client.requestAccountActivationByPin(email)
apiCall.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall confirmAccountActivationByPin(String pinCode, String email)

fun confirmAccountActivationByPin(pinCode: String, email:String):IApiCall

IApiCall apiCall;
apiCall = Client.confirmAccountActivationByPin(pinCode, email);
apiCall.execute(this::onSuccess, this::onFailure);

val apiCall:IApiCall
apiCall = Client.confirmAccountActivationByPin(pinCode, email)
apiCall.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall signIn(@NonNull String email, @NonNull String password)

fun signIn(email: String, password: String): IApiCall

private IApiCall signInCall;
private void signIn(String login, String password) {
        if (signInCall != null) signInCall.cancel();
        signInCall = Client.signIn(login, password);
        signInCall.onSubscribe(() -> toggleLoading(true))
                  .execute(() -> onSignInSuccessful(login), () -> onSignInFailure());
    }

private var signInCall: IApiCall
    private fun signIn(login: String, password: String) {
        signInCall!!.cancel()
        signInCall = Client.signIn(login, password)
        signInCall!!.onSubscribe({ toggleLoading(true) })
            .execute({ onSignInSuccessful(login) }, { onSignInFailure() })
    }

public static IDataApiCall<AuthConditions> signInConditionally(@NonNull String email, @NonNull String password)

fun signInConditionally(
        email: String,
        password: String,
        ): IDataApiCall<AuthConditions>

private IDataApiCall<AuthConditions> call;
if (call != null) call.cancel();
            call = Client.signInConditionally(email, password));
            call.execute(this::onSuccess, this::onFailure);

val call:IDataApiCall<AuthConditions>
call.cancel()
call = Client.signInConditionally(email, password)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall authenticate(String token, ClientIdentityProvider provider, Agreements agreements, Attributes attributes, String authId)

fun authenticate(
        token: String,
        provider: ClientIdentityProvider,
        agreements: Agreements?,
        attributes: Attributes?,
        authId: String?
    ): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.authenticate(token, provider, null, null, null);
            call.execute(this::onSuccess, this::onFailure);

val call:IApiCall
call.cancel()
call = Client.authenticate(token, provider, null, null, null)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IDataApiCall<AuthConditions> authenticateConditionally(@NonNull String token, @NonNull ClientIdentityProvider provider, @Nullable Agreements agreements, @Nullable Attributes attributes, @Nullable String authId)

fun authenticateConditionally(
        token: String,
        provider: ClientIdentityProvider,
        agreements: Agreements?,
        attributes: Attributes?,
        authId: String?
        ): IDataApiCall

private IDataApiCall<AuthConditions> call;
if (call != null) call.cancel();
            call = Client.authenticateConditionally(token, clientIdentityProvider, agreements, attributes, authId));
            call.execute(this::onSuccess, this::onFailure);

val call:IDataApiCall<AuthConditions>
call.cancel()
call = Client.authenticateConditionally(token, clientIdentityProvider, agreements, attributes, authId)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall authenticateWithTokenPayload(TokenPayload tokenPayload, @NonNull String authId) 

fun authenticateWithTokenPayload(
        tokenPayload: TokenPayload,
        authId: String
        ): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.authenticateWithTokenPayload(tokenPayload, authId);
            call.execute(this::onSuccess, this::onFailure);

val call:IApiCall
call.cancel()
call = Client.authenticateWithTokenPayload(tokenPayload, authId)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall simpleAuthentication(ClientData clientData, String authId)

fun simpleAuthentication(
        clientData: ClientData,
        authId: String
    ): IApiCall

public static boolean isSignedIn()

fun isSignedIn():Boolean

boolean isSignedIn = Client.isSignedIn()

var isSignedIn = Client.isSignedIn()

public static boolean isSignedInViaSimpleAuthentication()

fun isSignedInViaSimpleAuthentication():Boolean

boolean isSignedInViaSimpleAuthentication = Client.isSignedInViaSimpleAuthentication()

var isSignedInViaSimpleAuthentication = Client.isSignedInViaSimpleAuthentication()

public static void signOut()

fun signOut()

Client.signOut();

Client.signOut();

public static IApiCall signOut(ClientSignOutMode mode, Boolean signOutFromAllDevices)

fun signOut(mode: ClientSignOutMode, signOutFromAllDevices: Boolean): IApiCall

private IApiCall signOutCall;
private void signOut() {
  if (signOutCall != null) signOutCall.cancel();
  signOutCall = Client.signOut(ClientSignOutMode.SIGN_OUT_WITH_SESSION_CLEARING, true);
  signOutCall.onSubscribe(() -> toggleLoading(true))
             .execute(() -> onSignOutSuccessful(login), () -> onSignOutFailure());
}

private var signOutCall: IApiCall
private fun signOut(login: String, password: String) {
  signOutCall!!.cancel()
  signOutCall = Client.signOut(.SIGN_OUT_WITH_SESSION_CLEARING, true)
  signOutCall!!.onSubscribe({ toggleLoading(true) })
              .execute({ onSignOutSuccessful(login) }, { onSignOutFailure() })
}

public static IApiCall authenticateByOAuth(@NonNull String accessToken, @Nullable Agreements agreements, @Nullable Attributes attributes, @Nullable String authId)

fun authenticateByOAuth(
        accessToken: String,
        agreements: Agreements?,
        attributes: Attributes?,
        authId: String?
    ): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.authenticateByOAuth(token, null, null, null);
            call.execute(this::onSuccess, this::onFailure);

val call:IApiCall
call.cancel()
call = Client.authenticateByOAuth(token, null, null, null)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall authenticateByOAuthIfRegistered(@NonNull String accessToken, @Nullable String authId)

fun authenticateByOAuthIfRegistered(
        accessToken: String,
        authId: String?
    ): IApiCall

private IApiCall call;
if (call != null) call.cancel();
            call = Client.authenticateByOAuthIfRegistered(token, null);
            call.execute(this::onSuccess, this::onFailure);

val call:IApiCall
call.cancel()
call = Client.authenticateByOAuthIfRegistered(token, null)
call.execute(({ this.onSuccess() }), ({ this.onFailure() }))

public static IApiCall authenticateByFacebook(@NonNull String facebookToken, @Nullable Agreements agreements, @Nullable Attributes attributes, @Nullable String authId)

fun authenticateByFacebook(
        facebookToken: String,
        agreements: Agreements?,
        attributes: Attributes?,
        authId: String?
    ): IApiCall

private IApiCall signInFacebookCall;
private void signInFacebook(String facebookToken) {
        if (signInFacebookCall != null) signInFacebookCall.cancel();
        signInFacebookCall = Client.authenticateByFacebook(facebookToken, null, null, null);
        signInFacebookCall.onSubscribe(() -> toggleFacebookLoading(true))
                          .execute(this::onSignInFacebookSuccess, this::onSignInFacebookError);
    }

private var signInFacebookCall: IApiCall? = null
    private fun signInFacebook(facebookToken: String) {
        if (signInFacebookCall != null) signInFacebookCall!!.cancel()
        signInFacebookCall = Client.authenticateByFacebook(facebookToken, null, null, null)
        signInFacebookCall!!.onSubscribe({ toggleFacebookLoading(true) })
            .execute(({ this.onSignInFacebookSuccess() }), ({ this.onSignInFacebookError() }))
    }

public static IApiCall authenticateByFacebookRegistered(@NonNull String facebookToken, @Nullable String authId)

fun authenticateByFacebookRegistered(facebookToken: String, authId: String?): IApiCall

private IApiCall signInFacebookRegisteredCall;
private void signInFacebookRegistered(String facebookToken) {
        if (signInFacebookRegisteredCall != null) signInFacebookRegisteredCall.cancel();
        signInFacebookRegisteredCall = Client.authenticateByFacebookRegistered(facebookToken, null);
        signInFacebookRegisteredCall.onSubscribe(() -> toggleFacebookLoading(true))
                          .execute(this::onSignInFacebookSuccess, this::onSignInFacebookError);
    }

private var signInFacebookRegisteredCall: IApiCall? = null
    private fun signInFacebook(facebookToken: String) {
        signInFacebookRegisteredCall!!.cancel()
        signInFacebookRegisteredCall = Client.authenticateByFacebookRegistered(facebookToken, null)
        signInFacebookRegisteredCall!!.onSubscribe({ toggleFacebookLoading(true) })
            .execute(({ this.onSignInFacebookSuccess() }), ({ this.onSignInFacebookError() }))
    }

public static void signOut(ClientSignOutMode mode)

fun signOut()

Client.signOut(mode);

Client.signOut(mode);