feat: add phone number authentication

android/app/build.gradle

@@ -119,6 +119,8 @@ dependencies {
     implementation platform('com.google.firebase:firebase-bom:31.2.0')
     implementation 'com.google.firebase:firebase-analytics-ktx'
     implementation 'com.android.support:multidex:2.0.1'
+    implementation 'com.google.firebase:firebase-auth-ktx'
+    implementation 'com.google.android.gms:play-services-safetynet:18.0.1'
 
     /// Facebook SDK
     implementation 'com.facebook.android:facebook-android-sdk:latest.release'
@@ -128,7 +130,6 @@ dependencies {
 
     // TODO: Add the dependencies for Firebase products you want to use
     // When using the BoM, don't specify versions in Firebase dependencies
-    implementation 'com.google.firebase:firebase-analytics-ktx'
 
     // Add the dependencies for any other desired Firebase products
     // https://firebase.google.com/docs/android/setup#available-libraries

lib/authentication_with_phone_number/domain/i_phone_number_repository_facade.dart

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import 'package:firebase_auth/firebase_auth.dart' hide User;
+import 'package:fpb/core/domain/user.dart';
+import 'package:fpb/core/failures/auth_failure.dart';
+
+abstract class IPhoneNumberRepositoryFacade {
+
+  Future<void> sendOtpCode({
+    required String phoneNumber,
+    required void Function(PhoneAuthCredential) verificationCompleted,
+    required void Function(FirebaseAuthException) verificationFailed,
+    required void Function(String, int?) codeSent,
+    required void Function(String) codeAutoRetrievalTimeout,
+  });
+
+  Future<Either<AuthFailure, String>> verifyAndLogin({
+    required String smsCode, required String verificationId,
+  });
+
+  Future<Either<AuthFailure, User>> signUpWithEmailAndPassword({required String email, required String password});
+
+  Future<Either<AuthFailure, Unit>> signOut();
+
+}

lib/authentication_with_phone_number/infrastructure/phone_number_authentication_repository.dart

@@ -0,0 +1,115 @@
+import 'dart:io';
+
+import 'package:dartz/dartz.dart';
+import 'package:firebase_auth/firebase_auth.dart' hide User;
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:fpb/authentication_with_phone_number/domain/i_phone_number_repository_facade.dart';
+import 'package:fpb/core/domain/user.dart';
+import 'package:fpb/core/failures/auth_failure.dart';
+import 'package:fpb/core/infrastructure/user.dto.dart';
+import 'package:injectable/injectable.dart';
+
+
+@LazySingleton(as: IPhoneNumberRepositoryFacade)
+class PhoneNumberAuthRepository implements IPhoneNumberRepositoryFacade {
+  final FirebaseAuth _firebaseAuth;
+  PhoneNumberAuthRepository(this._firebaseAuth);
+
+  Future<void> sendOtpCode({
+    required String phoneNumber,
+    required void Function(PhoneAuthCredential) verificationCompleted,
+    required void Function(FirebaseAuthException) verificationFailed,
+    required void Function(String, int?) codeSent,
+    required void Function(String) codeAutoRetrievalTimeout,
+  }) async {
+    await _firebaseAuth.verifyPhoneNumber(
+      phoneNumber: phoneNumber,
+      verificationCompleted: verificationCompleted,
+      verificationFailed: verificationFailed,
+      codeSent: codeSent,
+      codeAutoRetrievalTimeout: codeAutoRetrievalTimeout,
+    );
+  }
+
+  @override
+  Future<Either<AuthFailure, String>> verifyAndLogin(
+      {required String smsCode, required String verificationId}) async {
+    try {
+      final AuthCredential authCredential = PhoneAuthProvider.credential(
+          verificationId: verificationId, smsCode: smsCode);
+
+      final authResult =
+          await _firebaseAuth.signInWithCredential(authCredential);
+
+      return right(authResult.user!.phoneNumber!);
+    } on PlatformException catch (e) {
+      debugPrint("Error occurred: code: ${e.code} , message: ${e.message}");
+      if (e.code == 'ERROR_INVALID_CREDENTIAL') {
+        return left(const AuthFailure.invalidCredential());
+      } else if (e.code == 'ERROR_USER_DISABLED') {
+        return left(const AuthFailure.userDisable());
+      } else if (e.code == 'ERROR_ACCOUNT_EXISTS_WITH_DIFFERENT_CREDENTIAL') {
+        return left(const AuthFailure.accountExitWithDifferentCred());
+      } else if (e.code == 'ERROR_OPERATION_NOT_ALLOWED') {
+        return left(const AuthFailure.operationNotAllowed());
+      } else if (e.code == 'ERROR_INVALID_VERIFICATION_CODE') {
+        return left(const AuthFailure.invalidVerificationCode());
+      } else if (e.code == 'ERROR_INVALID_ACTION_CODE') {
+        return left(const AuthFailure.invalidVerificationCode());
+      } else {
+        debugPrint("Error occurred: code: ${e.code} , message: ${e.message}");
+        return left(const AuthFailure.serverError());
+      }
+    }
+  }
+
+  @override
+  Future<Either<AuthFailure, User>> signUpWithEmailAndPassword({
+    required String email,
+    required String password,
+  }) async {
+    try {
+      final userCred = await _firebaseAuth.createUserWithEmailAndPassword(
+        email: email,
+        password: password,
+      );
+      final user = UserDTO.fromFirebase(userCred.user!).toDomain();
+      return right(user);
+    } on FirebaseAuthException catch (e) {
+      if (e.code == 'email-already-in-use') {
+        return left(const AuthFailure.emailAlreadyInUse());
+      } else if (e.code == 'invalid-email') {
+        return left(const AuthFailure.invalidEmailAndPasswordCombination());
+      } else if (e.code == 'weak-password') {
+        return left(const AuthFailure.weakPassword());
+      } else if (e.code == 'operation-not-allowed') {
+        return left(const AuthFailure.operationNotAllowed());
+      } else if (e.code == 'user-disabled') {
+        return left(const AuthFailure.userDisable());
+      }
+      return left(const AuthFailure.unexpected());
+    } catch (e) {
+      return left(const AuthFailure.serverError());
+    }
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> signOut() async {
+    try {
+      await Future.wait([
+        _firebaseAuth.signOut(),
+      ]);
+      return right(unit);
+    } on SocketException catch (e) {
+      return left(AuthFailure.fromErrorMessage(e.message));
+    } on PlatformException catch (e) {
+      return left(AuthFailure.fromErrorMessage(e.code));
+    } on FirebaseAuthException catch (e) {
+      return left(AuthFailure.fromErrorMessage(e.code));
+    } on FirebaseException catch (e) {
+      return left(AuthFailure.fromErrorMessage(e.code));
+    }
+  }
+
+}

lib/authentication_with_phone_number/phone_number_bloc/phone_number_bloc.dart

@@ -0,0 +1,184 @@
+import 'package:bloc/bloc.dart';
+import 'package:firebase_auth/firebase_auth.dart';
+import 'package:formz/formz.dart';
+import 'package:fpb/authentication_with_phone_number/domain/i_phone_number_repository_facade.dart';
+import 'package:fpb/core/failures/auth_failure.dart';
+import 'package:fpb/sign_in/domain/otp_field.dart';
+import 'package:fpb/sign_in/domain/password.dart';
+import 'package:fpb/sign_in/domain/phone_number.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:injectable/injectable.dart';
+
+part 'phone_number_event.dart';
+part 'phone_number_state.dart';
+part 'phone_number_bloc.freezed.dart';
+
+@injectable
+class PhoneNumberBloc extends Bloc<PhoneNumberEvent, PhoneNumberState> {
+  PhoneNumberBloc({required this.phoneNumberRepository,}) : super(const PhoneNumberState()) {
+    on<_PhoneNumberChanged>(_onPhoneNumberChanged);
+    on<_PhoneNumberSubmitted>(_onPhoneNumberSubmitted);
+
+    on<_OtpChanged>(_onOtpChanged);
+    on<_OtpSubmitted>(_onOtpSubmitted);
+
+    on<_PasswordChanged>(_onPasswordChanged);
+    on<_ConfirmPasswordChanged>(_onConfirmPasswordChanged);
+    on<_NewPasswordSubmitted>(_onNewPasswordSubmitted);
+  }
+
+  final IPhoneNumberRepositoryFacade phoneNumberRepository;
+  late String verificationId;
+
+  void _onPhoneNumberChanged(
+    _PhoneNumberChanged event,
+    Emitter<PhoneNumberState> emit,
+  ) {
+    final phoneNumber = PhoneNumber.dirty(event.phoneNumber);
+    emit(
+      state.copyWith(
+        phoneNumber: phoneNumber,
+      ),
+    );
+  }
+
+  Future<void> _onPhoneNumberSubmitted(
+      _PhoneNumberSubmitted event,
+      Emitter<PhoneNumberState> emit,
+      ) async {
+    if (state.phoneNumber.valid) {
+      emit(state.copyWith(status: FormzStatus.submissionInProgress));
+      try {
+        await phoneNumberRepository.sendOtpCode(
+          phoneNumber: state.phoneNumber.value,
+          codeSent: (String _verificationId, int? resendToken) {
+            verificationId = _verificationId;
+            emit(state.copyWith(status: FormzStatus.submissionSuccess));
+            print("SendOTP: Here's the code sent");
+          },
+          verificationCompleted: (PhoneAuthCredential credential) {
+            print("SendOTP: Verif complete");
+          },
+          verificationFailed: (FirebaseAuthException e) {
+            emit(state.copyWith(
+                status: FormzStatus.submissionFailure,
+                failure: AuthFailure.fromErrorMessage(
+                    e.message ?? 'Oops!! something went wrong')));
+            print("SendOTP: Verification failed");
+          },
+          codeAutoRetrievalTimeout: (String verificationId) {
+            print("SendOTP: time out");
+          },
+        );
+      } catch (_) {
+        emit(state.copyWith(
+          status: FormzStatus.submissionFailure,
+          failure: AuthFailure.fromErrorMessage(
+            'Oops!! something went wrong',
+          ),
+        ));
+      }
+    }else{
+
+    }
+  }
+
+
+  void _onOtpChanged(
+      _OtpChanged event,
+      Emitter<PhoneNumberState> emit,
+      ) {
+    final otpCode = OtpField.dirty(event.otpCode);
+    emit(
+      state.copyWith(
+        otpCode: otpCode,
+        status: Formz.validate([otpCode]),
+      ),
+    );
+
+    if(state.status.isValid && state.otpCode.value.length >= 6){
+      add(PhoneNumberEvent.submitPhoneNumber());
+    }
+  }
+
+  Future<void> _onOtpSubmitted(
+      _OtpSubmitted event,
+      Emitter<PhoneNumberState> emit,
+      ) async {
+    if (state.status.isValidated) {
+      emit(state.copyWith(status: FormzStatus.submissionInProgress));
+      try {
+        final failureOrUserPhoneNumber =
+        await phoneNumberRepository.verifyAndLogin(
+          smsCode: state.otpCode.value, verificationId: verificationId,
+        );
+        failureOrUserPhoneNumber.fold(
+                (failure) =>
+                emit(state.copyWith(status: FormzStatus.submissionFailure, failure: failure)),
+                (userPhoneNumber){
+              return emit(state.copyWith(status: FormzStatus.submissionSuccess));
+            });
+      } catch (_) {
+        emit(state.copyWith(status: FormzStatus.submissionFailure, failure: AuthFailure.fromErrorMessage('Oops!! something went wrong'),),);
+      }
+    }
+  }
+
+
+  void _onPasswordChanged(
+      _PasswordChanged event,
+      Emitter<PhoneNumberState> emit,
+      ) {
+    final password = Password.dirty(event.password);
+    emit(
+      state.copyWith(
+        password: password,
+        status: Formz.validate([password]), failure: AuthFailure.fromErrorMessage('Oops!! something went wrong'),
+      ),
+    );
+  }
+
+  void _onConfirmPasswordChanged(
+      _ConfirmPasswordChanged event,
+      Emitter<PhoneNumberState> emit,
+      ) {
+    final confirmPassword = Password.dirty(event.password);
+    FormzStatus status = Formz.validate([confirmPassword]);;
+    if(status == FormzStatus.valid){
+      if(confirmPassword.value != state.password.value){
+        status = FormzStatus.invalid;
+      }
+    }
+    emit(
+      state.copyWith(
+        confirmPassword: confirmPassword,
+        status: status , failure: AuthFailure.fromErrorMessage('Oops!! something went wrong'),
+      ),
+    );
+  }
+
+  Future<void> _onNewPasswordSubmitted(
+      _NewPasswordSubmitted event,
+      Emitter<PhoneNumberState> emit,
+      ) async {
+    if (state.status.isValidated) {
+      emit(state.copyWith(status: FormzStatus.submissionInProgress));
+      final String emailDomain = '@flutterplaza.com';
+      String email = '${state.phoneNumber}$emailDomain';
+
+      try {
+        final failureOrUser =
+        await phoneNumberRepository.signUpWithEmailAndPassword(email: email, password: state.password.value);
+        failureOrUser.fold(
+                (failure) =>
+                emit(state.copyWith(status: FormzStatus.submissionFailure, failure: failure)),
+                (user) {
+              return emit(state.copyWith(status: FormzStatus.submissionSuccess));
+            }
+        );
+      } catch (_) {
+        emit(state.copyWith(status: FormzStatus.submissionFailure, failure: AuthFailure.fromErrorMessage('Oops!! something went wrong'),),);
+      }
+    }
+  }
+}