Authentication state

user: User | null;

import { useRouter } from "expo-router";
import { usePrivy } from "@privy-io/expo";
import { useEffect } from "react";
import { Text, View } from "react-native";

export default function MyComponent() {
  const { isReady, user } = usePrivy();
  const router = useRouter();

  useEffect(() => {
    if (isReady && !user) {
      // Replace this code with however you'd like to handle an unauthenticated user
      // As an example, you might redirect them to a login page
      router.replace("/login");
    }
  }, [isReady, user, router]);

  if (!isReady) {
    // Do nothing while the PrivyProvider initializes with updated user state
    return null;
  }

  if (isReady && !user) {
    // You could show a loading state or handle this differently
    return <Text>Not authenticated</Text>;
  }

  if (isReady && user) {
    // Replace this code with however you'd like to handle an authenticated user
    return (
      <View>
        <Text>User {user.id} is logged in.</Text>
      </View>
    );
  }
}

public enum AuthState {
  /// AuthState has not been determined yet, show loading
  case notReady

  /// User is unauthenticated
  case unauthenticated

  /// Auth state cannot be determined while no network connectivity is available, but session tokens exist in cache
  case authenticatedUnverified(AuthenticatedUnverifiedContext)

  /// User is authenticated and has an associated PrivyUser object
  case authenticated(PrivyUser)
}

public protocol Privy {
  /// Get the user's current auth state.
  func getAuthState() async -> AuthState
}

// Grab current auth state
if case .authenticated(let user) = await privy.getAuthState() {
  // User is authenticated. Grab the user's linked accounts
  let linkedAccounts = user.linkedAccounts
}

public protocol Privy {
  /// An AsyncStream that emits auth state changes.
  var authStateStream: AsyncStream<AuthState> { get }
}

  let task = Task {
    for await authState in privy.authStateStream {
      switch authState {
        case .authenticated(let user):
          // User is authenticated. Grab the user's linked accounts
          let linkedAccounts = user.linkedAccounts
        case .notReady:
          // Privy was just initialized and has not determined auth state yet
        case .authenticatedUnverified:
          // Prior user session exists, but can't be refreshed / verified. Likely due to network connectivity.
        case .unauthenticated:
          // User in not authenticated. Perhaps show login screen.
      }
    }
  }

let privyUser = await privy.getUser()

if (privyUser != null) {
  // User is authenticated
  let linkedAccounts = privyUser.linkedAccounts
}

public sealed interface AuthState {
  // AuthState has not been determined yet, show loading
  public data object NotReady : AuthState

  // User is unauthenticated
  public data object Unauthenticated : AuthState

  // Auth state cannot be determined while no network connectivity is available, but session tokens exist in cache
  public data class AuthenticatedUnverified(/* */) : AuthState

  // User is authenticated and has an associated PrivyUser object
  public data class Authenticated(val user: PrivyUser) : AuthState
}

coroutineScope.launch {
  val authState = privy.getAuthState()

  if (authState is AuthState.Authenticated) {
    // User is authenticated. Grab the user's linked accounts
    val privyUser = currentAuthState.user
    val linkedAccount = privyUser.linkedAccounts
  }
}

public interface Privy {
 // A state flow that can be subscribed to for auth state updates
 public val authState: StateFlow<AuthState>
}

coroutineScope.launch {
    privy.authState.collectLatest { authState ->
        when(authState) {
            is AuthState.Authenticated -> {
                // User is authenticated. Grab the user's linked accounts
                val privyUser = authState.user
                val linkedAccounts = privyUser.linkedAccounts
            }
            AuthState.NotReady -> {
                // Privy was just initialized and has not determined auth state yet
            }
            is AuthState.AuthenticatedUnverified -> {
                // Prior user session exists, but can't be verified due to no network connectivity.
            }
            AuthState.Unauthenticated -> {
                // User in not authenticated. Perhaps show login screen.
            }
        }
    }
}

coroutineScope.launch {
  val privyUser = privy.getUser()

  if (privyUser != null) {
    // User is authenticated
    val linkedAccounts = privyUser.linkedAccounts
  }
}

public enum AuthState
{
    NotReady, // Privy has not yet finished initializing
    Unauthenticated, // User is unauthenticated
    Authenticated // User is authenticated
}

public interface IPrivy {
  // Get the user's current authentication state.
  Task<AuthState> GetAuthState();
}

var authState = await PrivyManager.Instance.GetAuthState();
Debug.Log(authState);

public interface IPrivy {
  // Sets a callback method to be invoked when the authentication state changes.
  void SetAuthStateChangeCallback(Action<AuthState> callback);
}

PrivyManager.Instance.SetAuthStateChangeCallback(authState =>
{
    // User's authentication state has updated
    Debug.Log(authState);
});

public interface IPrivy {
  // Get the current user.
  Task<PrivyUser> GetUser();
}

var privyUser = await PrivyManager.Instance.GetUser();

if (privyUser != null)
{
  var linkedAccounts = privyUser.LinkedAccounts;
}

/// Base class representing different authentication states.
sealed class AuthState {
  const AuthState();
}

/// Represents the initial state before authentication status is determined.
class NotReady extends AuthState {
  const NotReady();
}

/// Represents the state when the user is not authenticated.
class Unauthenticated extends AuthState {
  const Unauthenticated();
}

/// Represents the state when the user is authenticated.
class Authenticated extends AuthState {
  final PrivyUser user;

  /// Constructor accepting the authenticated user's details.
  const Authenticated(this.user);
}

abstract interface class Privy {
  // Get the current authentication state.
  AuthState get currentAuthState;

  // A stream for auth state updates.
  Stream<AuthState> get authStateStream;
}

final privyUser = privy.user;

if (privyUser != null) {
  // User is authenticated
  final linkedAccounts = privyUser.linkedAccounts;
}

// Grab current auth state
final currentAuthState = privy.currentAuthState;

if (currentAuthState is Authenticated) {
  // User is authenticated. Retrieve the associated user from the auth state.
  final privyUser = currentAuthState.user;
  final linkedAccounts = privyUser.linkedAccounts;
}

privy.authStateStream.listen((authState) {
  switch (authState) {
    case Authenticated():
      // User is authenticated. Retrieve the user.
      final privyUser = authState.user;
      final userId = privyUser.linkedAccounts;
      break;
    case NotReady():
      // Privy is not yet ready. Ensure Privy is initialized first.
      break;
    case Unauthenticated():
      // User is not authenticated. You may want to show the login screen.
      break;
  }
});