implemented authentication with firebase

lib/app/view/app.dart

@@ -1,9 +1,35 @@
+import 'package:flow_builder/flow_builder.dart';
 import 'package:flutter/material.dart';
-import 'package:learn/counter/counter.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:learn/authentication/authentication.dart';
 import 'package:learn/l10n/l10n.dart';
+import 'package:learn/repositories/src/authentication_repository/authentication_repository.dart';
+import 'package:learn/routes/routes.dart';
 
 class App extends StatelessWidget {
-  const App({super.key});
+  const App({
+    super.key,
+    required AuthenticationRepository authenticationRepository,
+  }) : _authenticationRepository = authenticationRepository;
+
+  final AuthenticationRepository _authenticationRepository;
+
+  @override
+  Widget build(BuildContext context) {
+    return RepositoryProvider.value(
+      value: _authenticationRepository,
+      child: BlocProvider(
+        create: (_) => AuthenticationBloc(
+          authenticationRepository: _authenticationRepository,
+        ),
+        child: const AppView(),
+      ),
+    );
+  }
+}
+
+class AppView extends StatelessWidget {
+  const AppView({super.key});
 
   @override
   Widget build(BuildContext context) {
@@ -16,7 +42,10 @@ class App extends StatelessWidget {
       ),
       localizationsDelegates: AppLocalizations.localizationsDelegates,
       supportedLocales: AppLocalizations.supportedLocales,
-      home: const CounterPage(),
+      home: FlowBuilder<AuthStatus>(
+        state: context.select((AuthenticationBloc bloc) => bloc.state.status),
+        onGeneratePages: onGenerateAppViewPages,
+      ),
     );
   }
 }

lib/authentication/authentication.dart

@@ -0,0 +1,5 @@
+export 'bloc/authentication_bloc.dart';
+export 'view/login_form.dart';
+export 'view/login_page.dart';
+export 'view/signup_form.dart';
+export 'view/signup_page.dart';

lib/authentication/bloc/authentication_bloc.dart

@@ -0,0 +1,50 @@
+import 'dart:async';
+
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:learn/repositories/repositories.dart';
+
+part 'authentication_event.dart';
+part 'authentication_state.dart';
+
+class AuthenticationBloc
+    extends Bloc<AuthenticationEvent, AuthenticationState> {
+  AuthenticationBloc({
+    required AuthenticationRepository authenticationRepository,
+  })  : _authenticationRepository = authenticationRepository,
+        super(
+          authenticationRepository.currentUser.isNotEmpty
+              ? AuthenticationState.authenticated(
+                  authenticationRepository.currentUser)
+              : const AuthenticationState.unauthenticated(),
+        ) {
+    on<_AppUserChanged>(_onUserChanged);
+    on<AppLogoutRequested>(_onLogoutRequested);
+    _userSubscription = _authenticationRepository.user.listen(
+      (user) => add(_AppUserChanged(user)),
+    );
+  }
+
+  final AuthenticationRepository _authenticationRepository;
+  late final StreamSubscription<User> _userSubscription;
+
+  void _onUserChanged(
+      _AppUserChanged event, Emitter<AuthenticationState> emit) {
+    emit(
+      event.user.isNotEmpty
+          ? AuthenticationState.authenticated(event.user)
+          : const AuthenticationState.unauthenticated(),
+    );
+  }
+
+  void _onLogoutRequested(
+      AppLogoutRequested event, Emitter<AuthenticationState> emit) {
+    unawaited(_authenticationRepository.logOut());
+  }
+
+  @override
+  Future<void> close() {
+    _userSubscription.cancel();
+    return super.close();
+  }
+}

lib/authentication/bloc/authentication_event.dart

@@ -0,0 +1,15 @@
+part of 'authentication_bloc.dart';
+
+abstract class AuthenticationEvent {
+  const AuthenticationEvent();
+}
+
+class AppLogoutRequested extends AuthenticationEvent {
+  const AppLogoutRequested();
+}
+
+class _AppUserChanged extends AuthenticationEvent {
+  const _AppUserChanged(this.user);
+
+  final User user;
+}

lib/authentication/bloc/authentication_state.dart

@@ -0,0 +1,26 @@
+part of 'authentication_bloc.dart';
+
+enum AuthStatus {
+  authenticated,
+  unauthenticated,
+  inProgress,
+}
+
+class AuthenticationState extends Equatable {
+  const AuthenticationState._({
+    required this.status,
+    this.user = User.empty,
+  });
+
+  const AuthenticationState.authenticated(User user)
+      : this._(status: AuthStatus.authenticated, user: user);
+
+  const AuthenticationState.unauthenticated()
+      : this._(status: AuthStatus.unauthenticated);
+
+  final AuthStatus status;
+  final User user;
+
+  @override
+  List<Object> get props => [status, user];
+}

lib/authentication/cubit/login_cubit.dart

@@ -0,0 +1,72 @@
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:formz/formz.dart';
+import 'package:learn/authentication/models/email.dart';
+import 'package:learn/authentication/models/password.dart';
+import 'package:learn/repositories/repositories.dart';
+
+part 'login_state.dart';
+
+class LoginCubit extends Cubit<LoginState> {
+  LoginCubit(this._authenticationRepository) : super(const LoginState());
+
+  final AuthenticationRepository _authenticationRepository;
+
+  void emailChanged(String value) {
+    final email = Email.dirty(value);
+    emit(
+      state.copyWith(
+        email: email,
+        status: Formz.validate([email, state.password]),
+      ),
+    );
+  }
+
+  void passwordChanged(String value) {
+    final password = Password.dirty(value);
+    emit(
+      state.copyWith(
+        password: password,
+        status: Formz.validate([state.email, password]),
+      ),
+    );
+  }
+
+  Future<void> logInWithCredentials() async {
+    if (!state.status.isValidated) return;
+    emit(state.copyWith(status: FormzStatus.submissionInProgress));
+    try {
+      await _authenticationRepository.logInWithEmailAndPassword(
+        email: state.email.value,
+        password: state.password.value,
+      );
+      emit(state.copyWith(status: FormzStatus.submissionSuccess));
+    } on LogInWithEmailAndPasswordFailure catch (e) {
+      emit(
+        state.copyWith(
+          errorMessage: e.message,
+          status: FormzStatus.submissionFailure,
+        ),
+      );
+    } catch (_) {
+      emit(state.copyWith(status: FormzStatus.submissionFailure));
+    }
+  }
+
+  Future<void> logInWithGoogle() async {
+    emit(state.copyWith(status: FormzStatus.submissionInProgress));
+    try {
+      await _authenticationRepository.logInWithGoogle();
+      emit(state.copyWith(status: FormzStatus.submissionSuccess));
+    } on LogInWithGoogleFailure catch (e) {
+      emit(
+        state.copyWith(
+          errorMessage: e.message,
+          status: FormzStatus.submissionFailure,
+        ),
+      );
+    } catch (_) {
+      emit(state.copyWith(status: FormzStatus.submissionFailure));
+    }
+  }
+}

lib/authentication/cubit/login_state.dart

@@ -0,0 +1,32 @@
+part of 'login_cubit.dart';
+
+class LoginState extends Equatable {
+  const LoginState({
+    this.email = const Email.pure(),
+    this.password = const Password.pure(),
+    this.status = FormzStatus.pure,
+    this.errorMessage,
+  });
+
+  final Email email;
+  final Password password;
+  final FormzStatus status;
+  final String? errorMessage;
+
+  @override
+  List<Object> get props => [email, password, status];
+
+  LoginState copyWith({
+    Email? email,
+    Password? password,
+    FormzStatus? status,
+    String? errorMessage,
+  }) {
+    return LoginState(
+      email: email ?? this.email,
+      password: password ?? this.password,
+      status: status ?? this.status,
+      errorMessage: errorMessage ?? this.errorMessage,
+    );
+  }
+}

lib/authentication/cubit/signup_cubit.dart

@@ -0,0 +1,86 @@
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:formz/formz.dart';
+import 'package:learn/authentication/models/confirmed_password.dart';
+import 'package:learn/authentication/models/email.dart';
+import 'package:learn/authentication/models/password.dart';
+import 'package:learn/repositories/repositories.dart';
+
+part 'signup_state.dart';
+
+class SignUpCubit extends Cubit<SignUpState> {
+  SignUpCubit(this._authenticationRepository) : super(const SignUpState());
+
+  final AuthenticationRepository _authenticationRepository;
+
+  void emailChanged(String value) {
+    final email = Email.dirty(value);
+    emit(
+      state.copyWith(
+        email: email,
+        status: Formz.validate([
+          email,
+          state.password,
+          state.confirmedPassword,
+        ]),
+      ),
+    );
+  }
+
+  void passwordChanged(String value) {
+    final password = Password.dirty(value);
+    final confirmedPassword = ConfirmedPassword.dirty(
+      password: password.value,
+      value: state.confirmedPassword.value,
+    );
+    emit(
+      state.copyWith(
+        password: password,
+        confirmedPassword: confirmedPassword,
+        status: Formz.validate([
+          state.email,
+          password,
+          confirmedPassword,
+        ]),
+      ),
+    );
+  }
+
+  void confirmedPasswordChanged(String value) {
+    final confirmedPassword = ConfirmedPassword.dirty(
+      password: state.password.value,
+      value: value,
+    );
+    emit(
+      state.copyWith(
+        confirmedPassword: confirmedPassword,
+        status: Formz.validate([
+          state.email,
+          state.password,
+          confirmedPassword,
+        ]),
+      ),
+    );
+  }
+
+  Future<void> signUpFormSubmitted() async {
+    if (!state.status.isValidated) return;
+    emit(state.copyWith(status: FormzStatus.submissionInProgress));
+    try {
+      await _authenticationRepository.signUp(
+        email: state.email.value,
+        password: state.password.value,
+      );
+      emit(state.copyWith(status: FormzStatus.submissionSuccess));
+    } on SignUpWithEmailAndPasswordFailure catch (e) {
+      emit(
+        state.copyWith(
+          errorMessage: e.message,
+          status: FormzStatus.submissionFailure,
+        ),
+      );
+    } catch (_) {
+      emit(state.copyWith(status: FormzStatus.submissionFailure));
+    }
+  }
+}

lib/authentication/cubit/signup_state.dart

@@ -0,0 +1,38 @@
+part of 'signup_cubit.dart';
+
+enum ConfirmPasswordValidationError { invalid }
+
+class SignUpState extends Equatable {
+  const SignUpState({
+    this.email = const Email.pure(),
+    this.password = const Password.pure(),
+    this.confirmedPassword = const ConfirmedPassword.pure(),
+    this.status = FormzStatus.pure,
+    this.errorMessage,
+  });
+
+  final Email email;
+  final Password password;
+  final ConfirmedPassword confirmedPassword;
+  final FormzStatus status;
+  final String? errorMessage;
+
+  @override
+  List<Object> get props => [email, password, confirmedPassword, status];
+
+  SignUpState copyWith({
+    Email? email,
+    Password? password,
+    ConfirmedPassword? confirmedPassword,
+    FormzStatus? status,
+    String? errorMessage,
+  }) {
+    return SignUpState(
+      email: email ?? this.email,
+      password: password ?? this.password,
+      confirmedPassword: confirmedPassword ?? this.confirmedPassword,
+      status: status ?? this.status,
+      errorMessage: errorMessage ?? this.errorMessage,
+    );
+  }
+}