What are the differences between BLOC x Cubit?

Question

BLOC and Cubit are part of the same package (Bloc) and use the same standard (Bloc - Design Pattern Business Logic Component) which helps to separate the presentation layer from the business rule.

What are the differences between the two models and what are the advantages of each?

Answer 1

The main difference between Bloc and Cubit, is that the Bloc requires the implementation of events (Events) who will be responsible for changing their states (States). A Cubit is a lighter version of the Bloc, as it only works with states and internal methods that will directly alter these states.

In Widgets that consume a Bloc, for example the Blocbuilder, you can exchange a Bloc for a Cubit with ease, since the Bloc is built internally through a Cubit and these Widgets observe only the state of the object.

The advantage of using a Cubit is that for simpler use cases, you have the facility to not need to declare different events and mainly to map these events to the internal states of the object, which improves readability and reduces the amount of code to perform the task.

Simple Bloc example implementing a counter:

/// Evento a ser processado por [CounterBloc].
enum CounterEvent {
  /// Notifica o Bloc a incrementar seu estado.
  increment,

  /// Notifica o Bloc a fazer um decremento em seu estado.
  decrement
}

class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0);

  //Método que mapeia Eventos adicionados ao Bloc para novos Estados
  @override
  Stream<int> mapEventToState(CounterEvent event) async* {
    switch (event) {
      case CounterEvent.decrement:
        yield state - 1;
        break;
      case CounterEvent.increment:
        yield state + 1;
        break;
      default:
        addError(Exception('unsupported event'));
    }
  }
}

Cubit that implements the same behavior without the need to declare and map events to states:

class CounterCubit extends Cubit<int> {
  CounterCubit() : super(0);

  void increment() => emit(state + 1);
  void decrement() => emit(state - 1);
}