import 'package:bloc/bloc.dart';
import 'package:bloc_concurrency/bloc_concurrency.dart';

class TestEvent {}

class TestBloc extends Bloc {
  TestBloc() : super(Object()) {
    on(_onTestEvent, transformer: restartable());
  }

  var testCounter = 0;

  Future _onTestEvent(event, emit) async {
    final counter = testCounter++;
    print('Starting test count: $counter, is emitter alive: ${!emit.isDone}');
    await Future.delayed(const Duration(seconds: 5));
    if (emit.isDone) return;
    // We should reach here only for latest event
    print('Finished test count: $counter, is emitter alive: ${!emit.isDone}');
  }
}

void main() {
  final bloc = TestBloc();
  bloc.stream.listen(null);
  bloc.add(TestEvent());
  bloc.add(TestEvent());
  bloc.add(TestEvent());
}

Nhưng khi e chạy thì e thấy nó ko cancel được TestEvent cũ

// Expected to print:

// Starting test count: 0, is emitter alive: true

// Starting test count: 1, is emitter alive: true

// Starting test count: 2, is emitter alive: true

// Finished test count: 2, is emitter alive: true

// Actually prints:

// Starting test count: 0, is emitter alive: true

// Starting test count: 1, is emitter alive: true

// Starting test count: 2, is emitter alive: true

// Finished test count: 0, is emitter alive: false

// Finished test count: 1, is emitter alive: false

// Finished test count: 2, is emitter alive: true

Mong a cho ý kiến ạ

Starting test count: 0, is emitter alive: true
Starting test count: 1, is emitter alive: true
Starting test count: 2, is emitter alive: true
Finished test count: 2, is emitter alive: true

Có lưu ý gì đặc biệt khi chạy không em?

Anh đang dùng:

environment:
  sdk: '>=2.18.2 <3.0.0'

dev_dependencies:
  lints: ^2.0.0
  test: ^1.16.0
  bloc: ^8.1.0
  bloc_concurrency: ^0.2.0
</pre>
                             – 
                            
                                monkey
                            
                            
                                1666124358000
                            
                            
                        

import 'package:bloc/bloc.dart';
import 'package:bloc_concurrency/bloc_concurrency.dart';

abstract class BaseEvent {}

class PickImageEvent extends BaseEvent {}

class IdentifyImageEvent extends BaseEvent {}

class ShowResultEvent extends BaseEvent {}

class BaseState {}

class TestBloc extends Bloc {
  TestBloc() : super(BaseState()) {
    on(_onPickImageEvent, transformer: restartable());
    on(_onIdentifyImageEvent, transformer: restartable());
    on(_onShowResultEvent, transformer: restartable());
  }

  var testCounter = 0;

  Future _onPickImageEvent(
    PickImageEvent event,
    Emitter emit,
  ) async {
    final counter = ++testCounter;
    print('Start picking image | Counter $counter');
    await Future.delayed(const Duration(seconds: 5));
    print('Have picked an image | Counter $counter');
    add(IdentifyImageEvent());
  }

  Future _onIdentifyImageEvent(
    IdentifyImageEvent event,
    Emitter emit,
  ) async {
    print('> Start identifying that image | Counter $testCounter');
    await Future.delayed(const Duration(seconds: 3));
    print('> Finished identifying that image | Counter $testCounter');
    add(ShowResultEvent());
  }

  Future _onShowResultEvent(
    ShowResultEvent event,
    Emitter emit,
  ) async {
    print('>> Start showing result | Counter $testCounter');
    await Future.delayed(const Duration(seconds: 2));
    print('>> Stopped showing result | Counter $testCounter');
  }
}

/// Expect result:
/// Start picking image | Counter 1
/// Start picking image | Counter 2
/// Start picking image | Counter 3
///
/// Have picked an image | Counter 3
///
/// > Start identifying that image | Counter 3
/// > Finished identifying that image | Counter 3
/// 
/// >> Start showing result | Counter 3
/// >> Stopped showing result | Counter 3

void main() {
  final bloc = TestBloc();
  bloc.stream.listen(null);
  bloc.add(PickImageEvent());
  bloc.add(PickImageEvent());
  bloc.add(PickImageEvent());
}

A xem giúp e nha, cảm ơn a