authentication_bloc.dart

Go to the documentation of this file.

import 'package:equatable/equatable.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
 
import '../../../../../core/common/use_cases/use_cases.dart';
import '../../../../../core/errors/failures.dart';
import '../../../../../core/services/notification_service.dart';
import '../../../../../core/services/service_locator.dart';
import '../../../domain/entities/credentials_entity.dart';
import '../../../domain/entities/session_entity.dart';
import '../../../domain/use_cases/chec_biometric_auth_availability_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>();
 
  AuthenticationBloc() : super(AuthenticationInitialState()) {
    on<SignInEvent>(_onSignInEvent);
    on<SignOutEvent>(_onSignOutEvent);
    on<LoadCredentialsEvent>(_onLoadCredentialsEvent);
    on<LoadSessionEvent>(_onLoadSessionEvent);
    on<CheckBiometricAuthenticationAvailabilityEvent>(
        _onCheckBiometricAuthenticationAvailabilityEvent);
    on<LoadEmailEvent>(_onloadEmailEvent);
  }
 
  Future<void> _onloadEmailEvent(
    LoadEmailEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadUserCredentialsUseCase.call(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.call(event.reqEntity);
    await results.fold(
      (failure) async => emit(AuthenticationFailureState(failure: failure)),
      (session) async {
        if (!emit.isDone) {
          await NotificationService().setupAfterAuthentication(session);
          emit(AuthenticatedState(session: session));
        }
      },
    );
  }
 
  Future<void> _onLoadSessionEvent(
    LoadSessionEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadSessionUseCase.call(NoParams());
    await results.fold(
      (failure) async => emit(AuthenticationFailureState(failure: failure)),
      (session) async {
        if (!emit.isDone) {
          if (session != null) {
            await NotificationService().setupAfterAuthentication(session);
            emit(AuthenticatedState(session: session));
          } else {
            emit(UnauthenticatedState());
          }
        }
      },
    );
  }
 
  Future<void> _onSignOutEvent(
    SignOutEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _signOutUseCase.call(NoParams());
    await results.fold(
      (failure) async => emit(AuthenticationFailureState(failure: failure)),
      (_) async {
        if (!emit.isDone) {
          final notificationService = NotificationService();
          final token = await FirebaseMessaging.instance.getToken();
          if (token != null) {
            await notificationService.removeDeviceToken(token);
          }
          notificationService.updateSession(null);
          emit(UnauthenticatedState());
        }
      },
    );
  }
 
  Future<void> _onLoadCredentialsEvent(
    LoadCredentialsEvent event,
    Emitter<AuthenticationState> emit,
  ) async {
    final results = await _loadUserCredentialsUseCase.call(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.call(NoParams());
    results.fold(
      (failure) => emit(BiometricAuthUnavailable()),
      (isAvailable) {
        emit(
          isAvailable ? BiometricAuthAvailable() : BiometricAuthUnavailable(),
        );
      },
    );
  }
}