Authentication

// Development mode - API key only (for testing)
const client = Client.createClient({
  apiKey: 'your-dev-api-key',
  region: 'sg'
});

// Simple login without auth token (development/testing only)
await client.login({
  userId: 'dev-user-123',
  displayName: 'Developer'
});

// Observe session state
AmityCoreClient.observeSessionState()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnNext { sessionState: SessionState ->
                when (state) {
                    AmitySessionState.NOT_LOGGED_IN -> {
                        // Show login screen
                        showLogin()
                    }
                    AmitySessionState.ESTABLISHING -> {
                        // Show loading indicator
                        showLoading()
                    }
                    AmitySessionState.ESTABLISHED -> {
                        // Hide loading indicator, proceed to app
                        hideLoading()
                        proceedToApp()
                    }
                    AmitySessionState.TOKEN_EXPIRED -> {
                        // Attempt to refresh token (Optional)
                        showTokenRefreshIndicator()
                    }
                    AmitySessionState.TERMINATED -> {
                        // Handle session termination
                        handleTermination()
                    }
                }
            }
            .doOnError {
                // Exception
            }
            .subscribe()

// Listen to session state changes
import { Client } from '@amityco/ts-sdk';
import React, { FC, useEffect, useState } from 'react';

const SessionState: FC = () => {
    const [sessionState, setSessionState] = useState('');
    useEffect(() => {
        return Client.onSessionStateChange((state: Amity.SessionStates) => {
            switch (state) {
                case 'notLoggedIn':
                    // Show login form
                    showLoginForm();
                    break;
                case 'establishing':
                    // Show loading spinner
                    showLoadingSpinner();
                    break;
                case 'established':
                    // Hide spinner, navigate to app
                    hideLoadingSpinner();
                    navigateToApp();
                    break;
                case 'tokenExpired':
                    // Attempt to refresh token (Optional)
                     showTokenRefreshIndicator()
                    break;
                case 'terminated':
                    // Handle termination
                    handleSessionTermination();
                    break;
            }
        }
        );
    }, []);

  return null;
};

// Listen to session state changes
AmityCoreClient.observeSessionState().listen((state) {
  switch (state) {
    case AmitySessionState.notLoggedIn:
      // Show login screen
      showLoginScreen();
      break;
    case AmitySessionState.establishing:
      // Show loading indicator
      showLoadingIndicator();
      break;
    case AmitySessionState.established:
      // Hide loading indicator, proceed to app
      hideLoadingIndicator();
      proceedToApp();
      break;
    case AmitySessionState.tokenExpired:
      // Attempt to refresh token (Optional)
      showTokenRefreshIndicator()
      break;
    case AmitySessionState.terminated:
      // Handle session termination
      handleSessionTermination();
      break;
  }
});

class ProductionSessionHandler : SessionHandler {
    override fun sessionWillRenewAccessToken(renewal: AccessTokenRenewal) {
        // Call your backend to refresh token
        authRepository.refreshToken { newToken ->
            if (newToken != null) {
                renewal.renewWithAuthToken(newToken)
            } else {
                renewal.unableToRetrieveAuthToken()
            }
        }
    }
}

// Use during login
val sessionHandler = ProductionSessionHandler()
AmityCoreClient.login(userId)
    .displayName(displayName)
    .authToken(authToken)
    .sessionHandler(sessionHandler)
    .build()
    .submit()

interface SessionHandler {
    sessionWillRenewAccessToken: (renewal: TokenRenewal) => void;
}

const createProductionSessionHandler = (): Amity.SessionHandler => ({
    sessionWillRenewAccessToken: async (renewal: Amity.AccessTokenRenewal) => {
        try {
            // Request fresh token from your backend (server-to-server)
            // Your backend re-verifies the user and generates new token
            const newToken = await AuthService.refreshToken();
            renewal.renewWithAuthToken(newToken);
        } catch (error) {
            console.error('Token refresh failed:', error);
            renewal.unableToRetrieveAuthToken();
        }
    }
});

// Use when logging in with backend-verified token
await client.login({
        userId: 'user-123',
        displayName: 'John Doe'
        authToken: 'your-auth-token',
    }, sessionHandler);

Function(AccessTokenRenewal) getProductionSessionHandler() {
  return (AccessTokenRenewal renewal) async {
    try {
      final myAuthToken = await getAuthTokenFromMyServer();
      renewal.renewWithAuthToken(myAuthToken);
    } catch (error) {
      renewal.unableToRetrieveAuthToken();
    }
  };
}

void authenticateUser() async {
// Use during login
  try {
    await AmityCoreClient.login(
      'userId',
      sessionHandler: getProductionSessionHandler(),
    ).displayName('displayName').authToken('authToken').submit();
  } catch (error) {
    // Handle authentication error
  }
}

// 1. Implement the AccessTokenHandler interface.
//    The SDK calls `onTokenRenew` when the access token is expired
//    or about to expire. You must return a fresh JWT obtained from
//    your own authentication backend.
val handler = object : AccessTokenHandler {
  override suspend fun onTokenRenew(userId: String): String {
    // get new token from your api
    val response = myApiService.refreshToken(userId)
    return response.accessToken
  }
}

// 2. Register the handler BEFORE calling loginWithAccessToken.
//    The handler must be set first so the SDK can invoke it
//    whenever a token renewal is needed.
AmityCoreClient.setAccessTokenHandler(handler)

// 3. Now login with the initial access token.
//    On subsequent token renewals, the SDK will automatically
//    call onTokenRenew and re-authenticate using the returned JWT.
AmityCoreClient.loginWithAccessToken(accessToken)
  .build()
  .submit()
  .subscribe()

import { Client } from "@amityco/ts-sdk";

// 1. Define custom token handler.
//    The SDK calls `onTokenRenew` when the access token is expired
//    or about to expire. You must return a fresh JWT obtained from
//    your own authentication backend.
const tokenHandler = {
  async onTokenRenew(userId: string): Promise<string> {
    // Request new JWT from your authentication backend
    const response = await fetch("https://your-backend.com/api/refresh-token", {
      method: "POST",
      credentials: "include",
      userId,
    });

    const data = await response.json();
    return data.accessToken;
  },
};

// 2. Register the handler BEFORE calling loginWithAccessToken.
//    The handler must be set first so the SDK can invoke it
//    whenever a token renewal is needed.
Client.setAccessTokenHandler(tokenHandler);

// 3. Now login with the initial access token.
//    On subsequent token renewals, the SDK will automatically
//    call onTokenRenew and re-authenticate using the returned JWT.
await Client.loginWithAccessToken(initialAccessToken);