pub package

BSEV (BloC,Streams,Events,View)

Set of packages and utilitarian functions that help in the use of BloC pattern with dependency injection.

With bsev you will use the Bloc pattern in a simple, reactive and organized way. Communication between the business logic and the view occurs entirely through two-way streams.

fluxo_bsev

Usage

To use this plugin, add bsev as a dependency in your pubspec.yaml file.

We should initially create the class that represents our Streams and Events:

Streams

import 'package:bsev/bsev.dart';

class HomeStreams extends StreamsBase{

  var count = BehaviorSubjectCreate<Int>(initValue: 0);
  //var count = StreamCreate<Int>();
  //var count = PublishSubjectCreate<Int>();
  //var count = ReplaySubjectCreate<Int>();

  @override
  void dispose() {
    count.close();
  }

}

Events

import 'package:bsev/bsev.dart';

class IncrementEvent extends EventsBase{}

Now we can create our Bloc, class that will be centralized the business rule.

Bloc

import 'package:bsev/bsev.dart';

    class HomeBloc extends BlocBase<HomeStreams>{

  //If you need to communicate with some instantiated BloC, regardless of whether part of your tree of widgets can use:
  //dispatchToBloc<OtherBloc>(MsgEvent());
  
  //If you need to send an event to the view:
  //dispatchView(MyEvent());

  @override
  void initView() {
  }
  
  @override
  void eventReceiver(EventsBase event) {
  
  // called when the Bloc receives an event
  
    if(event is IncrementEvent){
      streams.count.set(streams.count.value + 1)
    }
    
  }
}

Note: If you do not want to use events (for a screen that only starts, loads and displays data) you can use EventsBase as an event. Ex: BlocBase <HomeStreams, EventsBase>

In our bloc we have 2 mandatory methods: initState and eventReceiver:

initView: In the first buildView this method is invoked;

eventReceiver: Invoked whenever the pad receives an event;

View

import 'package:bsev/bsev.dart';

class HomeView extends StatelessWidget{
  
  @override
  Widget build(BuildContext context) {
    
    return Bsev<HomeBloc,HomeStreams>(
      dataToBloc: "any data", //optional initial data to bloc
      eventReceiver: (context, event, dispatcher){ //optional
        // performs action received by the bloc
      },
      builder: (context, dispatcher, streams){
      
          return Scaffold(
            appBar: AppBar(),
            body: _buildBody(streams),
            floatingActionButton: FloatingActionButton(
                onPressed: (){
                  dispatcher(IncrementEvent());
                }
            ),
          );
      
      }
    );
    
  }
    
  Widget _buildBody(HomeStreams streams) {

    return StreamBuilder(
      stream: streams.count.get,
      initialData: 0,
      builder: (_,snapshot){

        int count = 0;
        if(snapshot.hasData){
          count = snapshot.data;
        }

        return Center(
          child: Text(count.toString())
        )
      }
    );

  }
  
}

As our Bloc and our StreamsBase will be injected automatically, we should configure it in the Injector in the main of our application:

  MyApp(){

    var injector = Injector.appInstance;
    injector.registerDependency((i)=> HomeBloc());
    injector.registerDependency((i)=> HomeStreams());
    
  }

Questions about how to use the injector consult documentation.

More complex example is found here: exemplo

Used packages

Packagespub
rxdartPub
injectorPub

User cases

--------- | FlutterNews | DartLangBr | Boleiro |

Libraries

bloc_base
bloc_view
bsev
dispatcher
events_base
flavors
stream_base
stream_create
util