bloc

lib/blocs/authentication_bloc/authentication_bloc.dart

@@ -0,0 +1,37 @@
+import 'dart:async';
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:firebase_auth/firebase_auth.dart';
+import 'package:meta/meta.dart';
+import 'package:user_repository/user_repository.dart';
+
+part 'authentication_event.dart';
+part 'authentication_state.dart';
+
+class AuthenticationBloc
+    extends Bloc<AuthenticationEvent, AuthenticationState> {
+  final UserRepository userRepository;
+  late final StreamSubscription<User?> _userSubscription;
+
+  AuthenticationBloc({required UserRepository myUserRepository})
+      : userRepository = myUserRepository,
+        super(const AuthenticationState.unknown()) {
+    _userSubscription = userRepository.user.listen((authUser) {
+      add(AuthenticationUserChanged(authUser));
+    });
+    on<AuthenticationUserChanged>((event, emit) {
+      if (event.user != null) {
+        emit(AuthenticationState.authenticated(event.user!));
+      } else {
+        emit(const AuthenticationState.unauthenticated());
+      }
+    });
+  }
+
+  @override
+  Future<void> close() {
+    _userSubscription.cancel();
+    return super.close();
+  }
+}

lib/blocs/authentication_bloc/authentication_event.dart

@@ -0,0 +1,17 @@
+part of 'authentication_bloc.dart';
+
+@immutable
+abstract class AuthenticationEvent extends Equatable {
+  const AuthenticationEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class AuthenticationUserChanged extends AuthenticationEvent {
+  const AuthenticationUserChanged(this.user);
+
+  final User? user;
+}
+
+class AuthenticationLogoutRequested extends AuthenticationEvent {}

lib/blocs/authentication_bloc/authentication_state.dart

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

lib/blocs/my_user_bloc/my_user_bloc.dart

@@ -0,0 +1,26 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:user_repository/user_repository.dart';
+
+part 'my_user_event.dart';
+part 'my_user_state.dart';
+
+class MyUserBloc extends Bloc<MyUserEvent, MyUserState> {
+  final UserRepository _userRepository;
+
+  MyUserBloc({required UserRepository myUserRepository})
+      : _userRepository = myUserRepository,
+        super(const MyUserState.loading()) {
+    on<GetMyUser>(_onGetMyUser);
+  }
+
+  void _onGetMyUser(GetMyUser event, Emitter<MyUserState> emit) async {
+    emit(const MyUserState.loading());
+    try {
+      MyUser myUser = await _userRepository.getMyUser(event.myUserId);
+      emit(MyUserState.success(myUser));
+    } catch (e) {
+      emit(const MyUserState.failure());
+    }
+  }
+}

lib/blocs/my_user_bloc/my_user_event.dart

@@ -0,0 +1,17 @@
+part of 'my_user_bloc.dart';
+
+abstract class MyUserEvent extends Equatable {
+  const MyUserEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class GetMyUser extends MyUserEvent {
+  final String myUserId;
+
+  const GetMyUser({required this.myUserId});
+
+  @override
+  List<Object> get props => [myUserId];
+}

lib/blocs/my_user_bloc/my_user_state.dart

@@ -0,0 +1,23 @@
+part of 'my_user_bloc.dart';
+
+enum MyUserStatus { success, loading, failure }
+
+class MyUserState extends Equatable {
+  final MyUserStatus status;
+  final MyUser? user;
+
+  const MyUserState._({
+    this.status = MyUserStatus.loading,
+    this.user,
+  });
+
+  const MyUserState.loading() : this._();
+
+  const MyUserState.success(MyUser user)
+      : this._(status: MyUserStatus.success, user: user);
+
+  const MyUserState.failure() : this._(status: MyUserStatus.failure);
+
+  @override
+  List<Object?> get props => [status, user];
+}

lib/blocs/sign_up_bloc/sign_up_bloc.dart

@@ -0,0 +1,25 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:user_repository/user_repository.dart';
+
+part 'sign_up_event.dart';
+part 'sign_up_state.dart';
+
+class SignUpBloc extends Bloc<SignUpEvent, SignUpState> {
+  final UserRepository _userRepository;
+
+  SignUpBloc({required UserRepository userRepository})
+      : _userRepository = userRepository,
+        super(SignUpInitial()) {
+    on<SignUpRequired>((event, emit) async {
+      emit(SignUpProcess());
+      try {
+        MyUser user = await _userRepository.signUp(event.user, event.password);
+        await _userRepository.setUserData(user);
+        emit(SignUpSuccess());
+      } catch (e) {
+        emit(SignUpFailure());
+      }
+    });
+  }
+}

lib/blocs/sign_up_bloc/sign_up_event.dart

@@ -0,0 +1,15 @@
+part of 'sign_up_bloc.dart';
+
+abstract class SignUpEvent extends Equatable {
+  const SignUpEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SignUpRequired extends SignUpEvent {
+  final MyUser user;
+  final String password;
+
+  const SignUpRequired(this.user, this.password);
+}

lib/blocs/sign_up_bloc/sign_up_state.dart

@@ -0,0 +1,16 @@
+part of 'sign_up_bloc.dart';
+
+abstract class SignUpState extends Equatable {
+  const SignUpState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SignUpInitial extends SignUpState {}
+
+class SignUpSuccess extends SignUpState {}
+
+class SignUpFailure extends SignUpState {}
+
+class SignUpProcess extends SignUpState {}

lib/blocs/sing_in_bloc/sign_in_bloc.dart

@@ -0,0 +1,31 @@
+import 'dart:developer';
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:meta/meta.dart';
+import 'package:user_repository/user_repository.dart';
+
+part 'sign_in_event.dart';
+part 'sign_in_state.dart';
+
+class SignInBloc extends Bloc<SignInEvent, SignInState> {
+  final UserRepository _userRepository;
+
+  SignInBloc({required UserRepository userRepository})
+      : _userRepository = userRepository,
+        super(SignInInitial()) {
+    on<SignInRequired>((event, emit) async {
+      emit(SignInProcess());
+      try {
+        await _userRepository.signIn(event.email, event.password);
+        emit(SignInSuccess());
+      } catch (e) {
+        log(e.toString());
+        emit(const SignInFailure());
+      }
+    });
+    on<SignOutRequired>((event, emit) async {
+      await _userRepository.logOut();
+    });
+  }
+}

lib/blocs/sing_in_bloc/sign_in_event.dart

@@ -0,0 +1,19 @@
+part of 'sign_in_bloc.dart';
+
+abstract class SignInEvent extends Equatable {
+  const SignInEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SignInRequired extends SignInEvent {
+  final String email;
+  final String password;
+
+  const SignInRequired(this.email, this.password);
+}
+
+class SignOutRequired extends SignInEvent {
+  const SignOutRequired();
+}

lib/blocs/sing_in_bloc/sign_in_state.dart

@@ -0,0 +1,21 @@
+part of 'sign_in_bloc.dart';
+
+@immutable
+abstract class SignInState extends Equatable {
+  const SignInState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SignInInitial extends SignInState {}
+
+class SignInSuccess extends SignInState {}
+
+class SignInFailure extends SignInState {
+  final String? message;
+
+  const SignInFailure({this.message});
+}
+
+class SignInProcess extends SignInState {}

lib/blocs/update_user_info_bloc/update_user_info_bloc.dart

@@ -0,0 +1,29 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:user_repository/user_repository.dart';
+
+part 'update_user_info_event.dart';
+part 'update_user_info_state.dart';
+
+class UpdateUserInfoBloc
+    extends Bloc<UpdateUserInfoEvent, UpdateUserInfoState> {
+  final UserRepository _userRepository;
+
+  UpdateUserInfoBloc({required UserRepository userRepository})
+      : _userRepository = userRepository,
+        super(UpdateUserInfoInitial()) {
+    on<UploadPicture>(_onUploadPicture);
+  }
+
+  void _onUploadPicture(
+      UploadPicture event, Emitter<UpdateUserInfoState> emit) async {
+    emit(UploadPictureLoading());
+    try {
+      String userImage =
+          await _userRepository.uploadPicture(event.file, event.userId);
+      emit(UploadPictureSuccess(userImage));
+    } catch (e) {
+      emit(UploadPictureFailure());
+    }
+  }
+}

lib/blocs/update_user_info_bloc/update_user_info_event.dart

@@ -0,0 +1,18 @@
+part of 'update_user_info_bloc.dart';
+
+abstract class UpdateUserInfoEvent extends Equatable {
+  const UpdateUserInfoEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class UploadPicture extends UpdateUserInfoEvent {
+  final String file;
+  final String userId;
+
+  const UploadPicture(this.file, this.userId);
+
+  @override
+  List<Object> get props => [file, userId];
+}

lib/blocs/update_user_info_bloc/update_user_info_state.dart

@@ -0,0 +1,23 @@
+part of 'update_user_info_bloc.dart';
+
+abstract class UpdateUserInfoState extends Equatable {
+  const UpdateUserInfoState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class UpdateUserInfoInitial extends UpdateUserInfoState {}
+
+class UploadPictureFailure extends UpdateUserInfoState {}
+
+class UploadPictureLoading extends UpdateUserInfoState {}
+
+class UploadPictureSuccess extends UpdateUserInfoState {
+  final String userImage;
+
+  const UploadPictureSuccess(this.userImage);
+
+  @override
+  List<Object> get props => [userImage];
+}