FlutterでFeature-Firstアーキテクチャの実例紹介

part 'when_to_meet.freezed.dart';
part 'when_to_meet.g.dart';
 
typedef WhenToMeetID = String;
 
/// WhenToMeetは約束の時間を決めるために使用するクラスです。
@freezed
class WhenToMeet with _$WhenToMeet {
  const factory WhenToMeet({
    required WhenToMeetID id,
    required String title,
    required UserID creator,
    required List<User> invitees,
    required List<AnonymousUser> attendees,
    required Map<DateTime, Set<TimeSlot>> availableTimes,
    required Map<UserID, Map<DateTime, Set<TimeSlot>>> selectedTimes,
  }) = _WhenToMeet;
 
  factory WhenToMeet.fromJson(Map<String, dynamic> json) => _WhenToMeet.fromJson(json);
 
  factory WhenToMeet.empty() => WhenToMeet(
        id: const UuidV4().generate(),
        title: '',
        creator: '',
        invitees: [],
        attendees: [],
        availableTimes: {},
        selectedTimes: {},
      );
 
  factory WhenToMeet.fromCreationState(String title, Map<DateTime, Set<TimeSlot>> availableTimes) => WhenToMeet(
        id: const UuidV4().generate(),
        title: title,
        creator: '',
        invitees: [],
        attendees: [],
        availableTimes: availableTimes,
        selectedTimes: {},
      );
}

// features/calendar/data/when_to_meet_repository.dartファイルとして作成
abstract class WhenToMeetRepository {
  Future<List<WhenToMeet>> getWhenToMeets();
  Future<void> addWhenToMeet(WhenToMeet whenToMeet);
  Future<void> deleteWhenToMeet(WhenToMeet whenToMeet);
  Future<void> updateWhenToMeet(WhenToMeet whenToMeet);
}

part 'remote_when_to_meet_repository.g.dart';
 
class RemoteWhenToMeetRepository implements WhenToMeetRepository {
  const RemoteWhenToMeetRepository(this._fs);
  final FirebaseFirestore _fs;
 
  CollectionReference get _whenToMeetCollection => _fs.collection('when_to_meet');
 
  @override
  Future<void> addWhenToMeet(WhenToMeet whenToMeet) {
    return _whenToMeetCollection.doc(whenToMeet.id).set(whenToMeet.toJson());
  }
 
  @override
  Future<void> deleteWhenToMeet(WhenToMeet whenToMeet) {
    return _whenToMeetCollection.doc(whenToMeet.id).delete();
  }
 
  @override
  Future<List<WhenToMeet>> getWhenToMeets() {
    return _whenToMeetCollection.get().then((snapshot) {
      return snapshot.docs.map((doc) {
        return WhenToMeet.fromJson(doc.data() as Map<String, dynamic>);
      }).toList();
    });
  }
 
  @override
  Future<void> updateWhenToMeet(WhenToMeet whenToMeet) {
    return _whenToMeetCollection.doc(whenToMeet.id).update(whenToMeet.toJson());
  }
}
 
@riverpod
WhenToMeetRepository whenToMeetRepository(WhenToMeetRepositoryRef ref) {
  return RemoteWhenToMeetRepository(fs: ref.watch(firebaseFirestoreProvider));
}

part 'general_provider.g.dart';
 
@riverpod
FirebaseFirestore firebaseFirestore(FirebaseFirestoreRef ref) {
  return FirebaseFirestore.instance;
}

part 'when_to_meet_service.g.dart';
 
class WhenToMeetService {
  WhenToMeetService({
    required this.remoteWhenToMeetRepository,
  });
  final RemoteWhenToMeetRepository remoteWhenToMeetRepository;
 
  Future<void> addWhenToMeet(WhenToMeet whenToMeet) {
    return remoteWhenToMeetRepository.addWhenToMeet(whenToMeet);
  }
 
  Future<List<WhenToMeet>> fetchWhenToMeets(User user) {
    return remoteWhenToMeetRepository.getWhenToMeets(user.id);
  }
 
  Future<WhenToMeet?> fetchWhenToMeet(WhenToMeetID id) {
    return remoteWhenToMeetRepository.getWhenToMeet(id);
  }
 
  Future<void> updateWhenToMeet(WhenToMeet whenToMeet) {
    return remoteWhenToMeetRepository.updateWhenToMeet(whenToMeet);
  }
}
 
@riverpod
WhenToMeetService whenToMeetService(WhenToMeetServiceRef ref) {
  return WhenToMeetService(
    remoteWhenToMeetRepository: ref.watch(remoteWhenToMeetRepositoryProvider),
  );
}

class WhenToMeetCreationPage extends ConsumerWidget {
  const WhenToMeetCreationPage({super.key});
 
  final List<Widget> _pages = const [
    WhenToMeetCreationTitlePage(),
    WhenToMeetCreationDatePage(),
    WhenToMeetCreationTimePage(),
  ];
 
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final controller = ref.read(whenToMeetCreationControllerProvider.notifier);
    final state = ref.watch(whenToMeetCreationControllerProvider);
 
    return GestureDetector(
      onTap: () => FocusScope.of(context).unfocus(),
      child: Scaffold(
        appBar: AppBar(
          title: const Text('約束を作成'),
          leading: controller.isFirstStep()
              ? null
              : IconButton(
                  icon: const Icon(Icons.arrow_back),
                  onPressed: () => controller.previousStep(),
                ),
        ),
        body: SafeArea(
          child: Column(
            children: [
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: pg),
                child: StepProgressIndicator(stepProgress: state.stepProgress),
              ),
              const SizedBox(height: pg * 2),
              Expanded(child: _pages[state.stepProgress.step]),
            ],
          ),
        ),
      ),
    );
  }
}

part 'when_to_meet_creation_controller.freezed.dart';
part 'when_to_meet_creation_controller.g.dart';
 
@freezed
class WhenToMeetCreationState with _$WhenToMeetCreationState {
  const factory WhenToMeetCreationState({
    required String title,
    required List<DateTime> dates,
    required List<int> selectedTimes,
    required List<TimeSlot> availableTimes,
    required StepProgress stepProgress,
  }) = _WhenToMeetCreationState;
 
  factory WhenToMeetCreationState.empty() {
    return WhenToMeetCreationState(
      title: '',
      dates: [],
      selectedTimes: [],
      availableTimes: [],
      stepProgress: StepProgress(step: 0, initialStep: 0, totalSteps: 3),
    );
  }
}
 
extension WhenToMeetCreationStateX on WhenToMeetCreationState {
  WhenToMeet toDomain() {
    final availableTimesMap =
        Map<DateTime, Set<TimeSlot>>.fromEntries(dates.map((date) => MapEntry(date, Set.from(availableTimes))));
    return WhenToMeet.fromCreationState(title, availableTimesMap);
  }
}

@riverpod
class WhenToMeetCreationController extends _$WhenToMeetCreationController {
  @override
  WhenToMeetCreationState build() {
    ref.onDispose(() => print('WhenToMeetCreationController disposed'));
    print('WhenToMeetCreationController created');
    // 戻り値にDomainをそのまま使わず、Stateを作って使う方が良い。ただし今は作ってしまったのでそのまま使おう。
    return WhenToMeetCreationState.empty();
  }
 
  Future<WhenToMeet> createWhenToMeet(List<TimeSlot> slots) async {
    state = state.copyWith(availableTimes: slots);
    final service = ref.read(whenToMeetServiceProvider);
    final whenToMeet = state.toDomain();
    await service.addWhenToMeet(whenToMeet);
    return whenToMeet;
  }
 
  void previousStep() {
    if (state.stepProgress.isFirstStep()) {
      return;
    }
    state = state.copyWith(stepProgress: state.stepProgress.previousStep());
  }
 
  void nextStep() {
    if (state.stepProgress.isLastStep()) {
      return;
    }
    state = state.copyWith(stepProgress: state.stepProgress.nextStep());
  }
 
  // タイトル入力
  void updateTitle(String title) {
    state = state.copyWith(title: title);
    nextStep();
  }
 
  // 日付入力
  void updateDates(List<DateTime> dates) {
    if (state.title.isEmpty) {
      assert(false, 'title is empty');
    }
 
    state = state.copyWith(dates: dates);
    nextStep();
  }
 
  // 時間帯入力
  void updateAvailableTimes(List<int> selectedTimes) {
    if (state.dates.isEmpty) {
      assert(false, 'Dates are empty');
    }
 
    state = state.copyWith(selectedTimes: selectedTimes);
  }
 
  void updateSelectedTimes(List<int> selectedTimes) {
    state = state.copyWith(selectedTimes: selectedTimes);
  }
 
  bool isFirstStep() => state.stepProgress.isFirstStep();
}