authentication_bloc.dart

Go to the documentation of this file.

import 'package:equatable/equatable.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
 
import '../../../../../core/common/use_case/use_case.dart';
import '../../../../../core/error/failures.dart';
import '../../../../../core/services/service_locator.dart';
import '../../../domain/entities/credentials_entity.dart';
import '../../../domain/entities/session_entity.dart';
import '../../../domain/use_cases/check_biometric_auth_availability_usecase.dart';
import '../../../domain/use_cases/fast_sign_in_usecase.dart';
import '../../../domain/use_cases/load_credentials_usecase.dart';
import '../../../domain/use_cases/load_session_usecase.dart';
import '../../../domain/use_cases/signin_usecases.dart';
import '../../../domain/use_cases/signout_usecase.dart';
 
part 'authentication_event.dart';
part 'authentication_state.dart';
 
class AuthenticationBloc extends Bloc<AuthenticationEvent, AuthenticationState> {
  final _signInUseCase = sl<SignInUseCase>();
  final _signOutUseCase = sl<SignOutUseCase>();
  final _loadUserCredentialsUseCase = sl<LoadCredentialsUseCase>();
  final _loadSessionUseCase = sl<LoadSessionUseCase>();
  final _checkBiometricAuthAvailabilityUseCase = sl<CheckBiometricAuthAvailabilityUseCase>();
  final _fastSignInUseCase = sl<FastSignInUseCase>();
 
  AuthenticationBloc() : super(AuthenticationInitialState()) {
    on<SignInEvent>(_onSignInEvent);
    on<SignOutEvent>(_onSignOutEvent);
    on<LoadCredentialsEvent>(_onLoadCredentialsEvent);
    on<LoadSessionEvent>(_onLoadSessionEvent);
    on<CheckBiometricAuthenticationAvailabilityEvent>(_onCheckBiometricAuthenticationAvailabilityEvent);
    on<LoadEmailEvent>(_onloadEmailEvent);
    on<FastSignInEvent>(_onFastSignInEvent);
  }
 
  Future<void> _onloadEmailEvent(
    LoadEmailEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadUserCredentialsUseCase(NoParams());
    results.fold(
      (failure) => emit(AuthenticationFailureState(failure: failure)),
      (credentials) => emit(EmailLoadedState(email: credentials?.email)),
    );
  }
 
  Future<void> _onSignInEvent(
    SignInEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    emit(AuthenticatingState());
    final results = await _signInUseCase(event.reqEntity);
    results.fold(
      (failure) => emit(AuthenticationFailureState(failure: failure)),
      (session) => emit(AuthenticatedState(session: session)),
    );
  }
 
  Future<void> _onFastSignInEvent(
    FastSignInEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    emit(FastSignInLoading());
    final results = await _fastSignInUseCase(event.reqEntity);
    results.fold(
      (failure) => emit(FastSignInFailed(failure: failure)),
      (session) => emit(FastSignInLoaded()),
    );
  }
 
  Future<void> _onSignOutEvent(
    SignOutEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _signOutUseCase(NoParams());
    results.fold(
      (failure) => emit(AuthenticationFailureState(failure: failure)),
      (_) => emit(UnauthenticatedState()),
    );
  }
 
  Future<void> _onLoadSessionEvent(
    LoadSessionEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadSessionUseCase(NoParams());
    results.fold(
      (failure) => (failure) => emit(AuthenticationFailureState(failure: failure)),
      (session) {
        emit(
          session == null
              ? UnauthenticatedState()
              : AuthenticatedState(session: session),
        );
      },
    );
  }
 
  Future<void> _onLoadCredentialsEvent(
    LoadCredentialsEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadUserCredentialsUseCase(NoParams());
    results.fold(
      (failure) => emit(AuthenticationFailureState(failure: failure)),
      (credentials) => emit(CredentialsLoadedState(credentials: credentials)),
    );
  }
 
  Future<void> _onCheckBiometricAuthenticationAvailabilityEvent(
    CheckBiometricAuthenticationAvailabilityEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _checkBiometricAuthAvailabilityUseCase(NoParams());
    results.fold(
      (failure) => emit(BiometricAuthUnavailable()),
      (isAvailable) {
        emit(
          isAvailable ? BiometricAuthAvailable() : BiometricAuthUnavailable(),
        );
      },
    );
  }
}