Construindo um App de Gestão de Corridas com Flutter 3.41: Dashboard, Sprints e Menu Rápido (Parte 3)

Utilizando as Sealed Classes do Dart moderno (Flutter 3.41), aqui está o código completo do RaceBloc, dividido em Eventos, Estados e a Lógica Principal.

1. Os Eventos (race_event.dart)

Definimos as ações que a interface pode solicitar ao BLoC de Corridas: carregar a lista, adicionar uma nova prova ou marcar uma corrida como concluída.

import 'package:equatable/equatable.dart';
import '../../data/models/race.dart';

sealed class RaceEvent extends Equatable {
  const RaceEvent();

  @override
  List<Object> get props => [];
}

class LoadRaces extends RaceEvent {}

class AddRace extends RaceEvent {
  final Race race;
  
  const AddRace(this.race);

  @override
  List<Object> get props => [race];
}

class CompleteRace extends RaceEvent {
  final int raceId;
  
  const CompleteRace(this.raceId);

  @override
  List<Object> get props => [raceId];
}

2. Os Estados (race_state.dart)

O estado RaceLoaded é o mais importante aqui. Note que além da lista completa de corridas (races), ele também expõe um objeto opcional nextRace. Isso facilita muito a vida da Home Screen, que não precisará fazer cálculos na interface.

import 'package:equatable/equatable.dart';
import '../../data/models/race.dart';

sealed class RaceState extends Equatable {
  const RaceState();
  
  @override
  List<Object?> get props => [];
}

final class RaceInitial extends RaceState {}

final class RaceLoading extends RaceState {}

final class RaceLoaded extends RaceState {
  final List<Race> races;
  final Race? nextRace; // Exposto diretamente para o Card da Home

  const RaceLoaded({required this.races, this.nextRace});

  @override
  List<Object?> get props => [races, nextRace];
}

final class RaceError extends RaceState {
  final String message;
  
  const RaceError(this.message);

  @override
  List<Object> get props => [message];
}

3. A Lógica de Negócio (race_bloc.dart)

O motor do BLoC interage com o RaceRepository (que criamos na parte anterior) e processa os dados.

import 'package:flutter_bloc/flutter_bloc.dart';
import '../../data/repositories/race_repository.dart';
import '../../data/models/race.dart';
import 'race_event.dart';
import 'race_state.dart';

class RaceBloc extends Bloc<RaceEvent, RaceState> {
  final RaceRepository repository;

  RaceBloc(this.repository) : super(RaceInitial()) {
    on<LoadRaces>(_onLoadRaces);
    on<AddRace>(_onAddRace);
    on<CompleteRace>(_onCompleteRace);
  }

  Future<void> _onLoadRaces(LoadRaces event, Emitter<RaceState> emit) async {
    emit(RaceLoading());
    try {
      // Busca todas as corridas ordenadas por data (Lógica do Repository)
      final races = await repository.getAllRaces();

      // Encontra a próxima corrida (a primeira da lista que não foi concluída)
      Race? nextRace;
      try {
        nextRace = races.firstWhere((r) => !r.isCompleted);
      } catch (_) {
        nextRace = null; // Todas as provas foram concluídas ou calendário vazio
      }

      emit(RaceLoaded(races: races, nextRace: nextRace));
    } catch (e) {
      emit(const RaceError("Erro ao carregar o calendário de provas."));
    }
  }

  Future<void> _onAddRace(AddRace event, Emitter<RaceState> emit) async {
    try {
      await repository.insertRace(event.race);
      add(LoadRaces()); // Recarrega a lista após salvar para atualizar a Home
    } catch (e) {
      emit(const RaceError("Erro ao salvar a prova de corrida."));
    }
  }

  Future<void> _onCompleteRace(CompleteRace event, Emitter<RaceState> emit) async {
    try {
      await repository.markRaceAsCompleted(event.raceId);
      add(LoadRaces()); // Atualiza o calendário e recalcula qual é a nova "Próxima Corrida"
    } catch (e) {
      emit(const RaceError("Erro ao finalizar a corrida."));
    }
  }
}

💡 Dica de Integração na Home:

Com esse BLoC pronto, lá no Assunto 7 (Nova Estrutura da Home Screen), você pode envolver o NextRaceCard com um BlocBuilder de forma muito limpa:

// Snippet atualizado para o Assunto 7
BlocBuilder<RaceBloc, RaceState>(
  builder: (context, state) {
    if (state is RaceLoaded && state.nextRace != null) {
      return NextRaceCard(nextRace: state.nextRace!);
    } else if (state is RaceLoaded && state.nextRace == null) {
      return const Center(child: Text('Temporada Finalizada!'));
    }
    return const Center(child: CircularProgressIndicator());
  },
)

📊 6. Classificação Atual (Standings List)

Abaixo do Card da próxima corrida, exibiremos a lista do campeonato. Vamos usar o BlocBuilder para escutar o ChampionshipBloc e renderizar uma lista elegante.

Snippet para a Home (ListView.builder embutido):

BlocBuilder<ChampionshipBloc, ChampionshipState>(
  builder: (context, state) {
    if (state is ChampionshipLoaded) {
      return ListView.separated(
        shrinkWrap: true, // Necessário se estiver dentro de um SingleChildScrollView
        physics: const NeverScrollableScrollPhysics(),
        itemCount: state.standings.length,
        separatorBuilder: (_, __) => const Divider(height: 1),
        itemBuilder: (context, index) {
          final standing = state.standings[index];
          return ListTile(
            leading: CircleAvatar(
              backgroundColor: Theme.of(context).colorScheme.surfaceVariant,
              child: Text('${index + 1}º', style: const TextStyle(fontWeight: FontWeight.bold)),
            ),
            title: Text(standing.driver.name, style: const TextStyle(fontWeight: FontWeight.bold)),
            subtitle: Text(standing.driver.team),
            trailing: Text(
              '${standing.points} pts', 
              style: Theme.of(context).textTheme.titleMedium?.copyWith(color: Theme.of(context).colorScheme.primary),
            ),
          );
        },
      );
    }
    return const Center(child: CircularProgressIndicator());
  },
)

🏗️ 7. Nova Estrutura da Home Screen (CustomScrollView)

Para combinar o Card de Destaque e a Lista de Classificação de forma performática (evitando o erro clássico de “Listas infinitas dentro de Colunas”), usaremos Slivers.

Arquivo: lib/modules/home/home_screen.dart

class HomeScreen extends StatelessWidget {
  const HomeScreen({super.key});

  @override
  Widget build(BuildContext context) {
    // Despacha o evento para calcular a tabela assim que a tela abre
    context.read<ChampionshipBloc>().add(CalculateStandings());
    
    return Scaffold(
      appBar: /* AppBar com o PopupMenu (Assunto 4) */,
      body: CustomScrollView(
        slivers: [
          // Espaço para o Card da Próxima Corrida
          SliverToBoxAdapter(
             // Substitua por um BlocBuilder buscando a próxima corrida
            child: NextRaceCard(nextRace: Race(name: 'GP de Interlagos', date: '25/11/2026', isSprint: true)),
          ),
          
          // Título da Seção
          SliverToBoxAdapter(
            child: Padding(
              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
              child: Text('CLASSIFICAÇÃO DO CAMPEONATO', style: Theme.of(context).textTheme.titleSmall),
            ),
          ),

          // Lista de Classificação usando SliverList
          SliverToBoxAdapter(
            child: /* O BlocBuilder do Assunto 6 vai aqui */,
          ),
        ],
      ),
    );
  }
}

🏁 8. Tela de Gestão de Provas de Corrida (CRUD)

O usuário precisa cadastrar as provas e definir se são normais ou Sprint. Usaremos o SegmentedButton do Material 3 para essa seleção.

Arquivo: lib/modules/races/race_form_screen.dart

class RaceFormScreen extends StatefulWidget {
  const RaceFormScreen({super.key});

  @override
  State<RaceFormScreen> createState() => _RaceFormScreenState();
}

class _RaceFormScreenState extends State<RaceFormScreen> {
  final _nameController = TextEditingController();
  final _dateController = TextEditingController();
  bool _isSprint = false;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Cadastrar Prova')),
      body: Padding(
        padding: const EdgeInsets.all(24),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            TextField(controller: _nameController, decoration: const InputDecoration(labelText: 'Nome do GP (Ex: GP de Mônaco)', border: OutlineInputBorder())),
            const SizedBox(height: 16),
            TextField(
              controller: _dateController, 
              decoration: const InputDecoration(labelText: 'Data da Prova', border: OutlineInputBorder(), prefixIcon: Icon(Icons.calendar_today)),
            ),
            const SizedBox(height: 24),
            
            // Material 3 SegmentedButton para o Tipo de Prova
            SegmentedButton<bool>(
              segments: const [
                ButtonSegment(value: false, label: Text('Feature Race (25pts)'), icon: Icon(Icons.flag)),
                ButtonSegment(value: true, label: Text('Sprint (8pts)'), icon: Icon(Icons.bolt)),
              ],
              selected: {_isSprint},
              onSelectionChanged: (val) => setState(() => _isSprint = val.first),
            ),
            
            const Spacer(),
            FilledButton(
              onPressed: () {
                final newRace = Race(name: _nameController.text, date: _dateController.text, isSprint: _isSprint);
                context.read<RaceBloc>().add(AddRace(newRace));
                Navigator.pop(context);
              },
              child: const Text('SALVAR PROVA'),
            )
          ],
        ),
      ),
    );
  }
}