flutter_event_bus 0.0.2
flutter_event_bus: ^0.0.2 copied to clipboard

A library to provide EventBus and Interactor to Flutter app. It enables developer to write flutter app with Interactor pattern. Interactor pattern is a pattern similar to bloc, but with less structure

flutter_event_bus #

Star this Repo Pub Package

Flutter Event Bus is an EventBus designed specific for Flutter app, which enable developer to write flutter app with Interactor pattern, which is similar to Bloc but less structured on some aspect.

Why another Event Bus #

There is a Event Bus package, why create another one?

Marco Jakob did a great job while creating Event Bus package, which provides a generic Event Bus pattern implementation that can be used anywhere in Dart ecosystem.

But while writing app in Interactor pattern in flutter, there are a few common usages that existing library are not really convenient. So Flutter Event Bus has been carefully customised for these use cases.

Event Bus #

Event Bus is a pub/sub system to enable components collaborate with each other without direct coupling. Component can publish event to make announcement when something happens, or respond to event to take action.

Basic Usage #

class TextChangedEvent{
  final String text;
  const TextChangedEvent(this.text);

final eventBus = EventBus();

eventBus.respond<TextChangedEvent>((TextChangedEvent event) =>
  print("Text changed to ${event.text}");

eventBus.publish(TextChangedEvent("new text"));

Stop responding events #

final subscription = eventBus.respond<TextChangedEvent>(responder);

eventBus.publish(TextChangedEvent("Responded")); // This event will be responded by responder


eventBus.publish(TextChangedEvent("Ignored")); // This event will not be responded by responder

Respond to different type of events #

final subscription = eventBus
  .respond<EventA>(responderA) // Subscribe to EventA
  .respond<EventB>(responderB) // Subscribe to EventB
  .respond<EventC>(responderC) // Subscribe to EventC
  .respond(genericResponder); // Subscribe to EventA EventB EventC and any other event on event bus

  // Generic Responder could be useful for monitoring, logging or diagnosis purpose, probably will be hardly used to take action to event

subscription.dispose(); // All previous 4 subscriptions will be cancelled all together

Used in Flutter #

Event Bus Widget #

To embed EventBus in Flutter, you can use EventBusWidget, which provide EventBus to its child tree.

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  Widget build(BuildContext context) =>
      child: MaterialApp(
        // .....

Capture user interaction #

You're like to publish event in stateless widget to broadcast user interaction into your app.

class SubmitFormEvent { }

class SubmitButton extends StatelessWidget {
  Widget build(BuildContext context) =>
      child: const Text("Publish"),
      onPressed: () {
        EventBus.publish(context, SubmitFormEvent()); // Publish event to the event bus provided by ancestor EventBusWidget

Capture state changes #

You might also wish to publish some event when app state had a certain change

class MyWidgetState extends State<MyWidget> {
  int _counter = 0;
  EventBus eventBus;

  void didChangeDependencies() {

    eventBus = EventBus.of(context); // Find EventBus provided by ancestor EventBusWidget

  void _incrementCounter(InreaseCounterEvent event) {
    setState(() {
      if(++_counter == 100) {

Respond events #

To respond to events you can listening event bus directly. But more commonly you will do it via Interactor.

You can use Interactor as base class as your stateful widget state, and implements the subscribeEvents method to describe the events that interactor can handle. Interactor manages the subscription and cancel the subscription when it is removed from the tree.

class IncreaseCounterEvent {}
class DecreaseCounterEvent {}
class CounterChangedEvent {
  final int value;

class MyPage extends StatefulWidget {
  MyPage({Key key}) : super(key: key);

  _MyPageInteractor createState() => _MyPageInteractor();

class _MyPageInteractor extends Interactor<MyHomePage> {
  int _counter = 0;

  Widget build(BuildContext context) {
    // Build the widget tree as usual

  Subscription subscribeEvents() => eventBus

  void _incrementCounter(IncreaseCounterEvent event) {
    setState(() {


   void _incrementCounter(DecreaseCounterEvent event) {
    setState(() {

      if(_counter < 0) {
        _counter = 0;


License #

The MIT License (MIT)

pub points



A library to provide EventBus and Interactor to Flutter app. It enables developer to write flutter app with Interactor pattern. Interactor pattern is a pattern similar to bloc, but with less structure and restriction

Repository (GitHub)
View/report issues


API reference






Packages that depend on flutter_event_bus