How To Clean Flutter Code With Multiple Classes

A Palpitate package that makes information technology easy and intuitive to implement Uncle Bob'due south Clean Architecture in Palpitate. This bundle provides basic classes that are tuned to piece of work with Flutter and are designed co-ordinate to the Clean Architecture.

Add this to your package's pubspec.yaml file:

                      dependencies:   flutter_clean_architecture: ^5.0.2                  

You tin can install packages from the command line:

with Flutter:

          $ flutter packages get                  

Alternatively, your editor might support flutter packages get. Check the docs for your editor to larn more than.

Now in your Sprint lawmaking, you can apply:

          import 'packet:flutter_clean_architecture/flutter_clean_architecture.sprint';                  

Information technology is architecture based on the book and weblog by Uncle Bob. It is a combination of concepts taken from the Onion Architecture and other architectures. The main focus of the architecture is separation of concerns and scalability. It consists of 4 chief modules: App, Domain, Information, and Device.

Source code dependencies only indicate in. This means inwards modules are neither aware of nor dependent on outer modules. Still, outer modules are both aware of and dependent on inner modules. Outer modules represent the mechanisms by which the business organisation rules and policies (inner modules) operate. The more you move inward, the more abstraction is present. The outer you motion the more concrete implementations are present. Inner modules are not aware of any classes, functions, names, libraries, etc.. present in the outer modules. They only represent rules and are completely contained from the implementations.

Domain

The Domain module defines the business logic of the application. It is a module that is contained from the development platform i.e. information technology is written purely in the programming linguistic communication and does not incorporate any elements from the platform. In the example of Palpitate, Domain would be written purely in Sprint without any Palpitate elements. The reason for that is that Domain should but be concerned with the business concern logic of the application, not with the implementation details. This also allows for easy migration between platforms, should any bug arise.

Contents of Domain

Domain is fabricated upward of several things.

• Entities
  • Enterprise-wide business rules
  • Made upward of classes that can comprise methods
  • Business organization objects of the application
  • Used awarding-broad
  • To the lowest degree likely to change when something in the application changes
• Usecases
  • Application-specific business rules
  • Encapsulate all the usecases of the application
  • Orchestrate the flow of information throughout the app
  • Should not exist afflicted past whatsoever UI changes any
  • Might change if the functionality and flow of application change
• Repositories
  • Abstruse classes that define the expected functionality of outer layers
  • Are not aware of outer layers, simply define expected functionality
    • East.chiliad. The Login usecase expects a Repository that has login functionality
  • Passed to Usecases from outer layers

Domain represents the inner-most layer. Therefore, it the about abstract layer in the architecture.

App

App is the layer exterior Domain. App crosses the boundaries of the layers to communicate with Domain. Even so, the Dependency Rule is never violated. Using polymorphism, App communicates with Domain using inherited class: classes that implement or extend the Repositories present in the Domain layer. Since polymorphism is used, the Repositories passed to Domain still adhere to the Dependency Rule since as far as Domain is concerned, they are abstract. The implementation is hidden backside the polymorphism.

Contents of App

Since App is the presentation layer of the awarding, it is the nigh framework-dependent layer, as it contains the UI and the event handlers of the UI. For every folio in the application, App defines at least 3 classes: a Controller, a Presenter, and a View.

• View
  • Represents only the UI of the page. The View builds the page'southward UI, styles it, and depends on the Controller to handle its events. The View has-a Controller.
  • In the case of Flutter
    • The View is comprised of ii classes
      • I that extends View, which would be the root Widget representing the View
      • 1 that extends ViewState with the template specialization of the other class and its Controller.
    • The ViewState contains the view getter, which is technically the UI implementation
    • StatefulWidget contains the Country as per Palpitate
    • The StatefulWidget just serves to laissez passer arguments to the State from other pages such as a championship etc.. It but instantiates the Country object (the ViewState) and provides information technology with the Controller information technology needs through it's consumer.
    • The StatefulWidget has-a Country object (the ViewState) which has-a Controller
    • In summary, both the StatefulWidget and the State are represented by a View and ViewState of the folio.
    • The ViewState form maintains a GlobalKey that can exist used as a key in its scaffold. If used, the Controller tin hands access it via getState() in gild to show snackbars and other dialogs. This is helpful just optional.
• Controller
  • Every ViewState has-a Controller. The Controller provides the needed member information of the ViewState i.e. dynamic data. The Controller likewise implements the consequence-handlers of the ViewState widgets, simply has no access to the Widgets themselves. The ViewState uses the Controller, non the other way around. When the ViewState calls a handler from the Controller, refreshUI() can be chosen to update the view.
  • Every Controller extends the Controller abstruse class, which implements WidgetsBindingObserver. Every Controller class is responsible for handling lifecycle events for the View and tin override:
    • void onInActive()
    • void onPaused()
    • void onResumed()
    • void onDetached()
    • void onDisposed()
    • void onReassembled()
    • void onDidChangeDependencies()
    • void onInitState()
    • etc..
  • Also, every Controller has to implement initListeners() that initializes the listeners for the Presenter for consistency.
  • The Controller has-a Presenter. The Controller will laissez passer the Repository to the Presenter, which information technology communicate later with the Usecase. The Controller will specify what listeners the Presenter should telephone call for all success and error events equally mentioned previously. Simply the Controller is allowed to obtain instances of a Repository from the Data or Device module in the outermost layer.
  • The Controller has access to the ViewState and tin refresh the ControlledWidgets via refreshUI().
• Presenter
  • Every Controller has-a Presenter. The Presenter communicates with the Usecase equally mentioned at the commencement of the App layer. The Presenter volition have members that are functions, which are optionally set by the Controller and will exist called if fix upon the Usecase sending back data, completing, or erroring.
  • The Presenter is comprised of ii classes
    • Presenter due east.g. LoginPresenter
      • Contains the event-handlers set up by the Controller
      • Contains the Usecase to be used
      • Initializes and executes the usecase with the Observer<T> class and the appropriate arguments. E.grand. with username and password in the case of a LoginPresenter
    • A class that implements Observer<T>
      • Has reference to the Presenter course. Ideally, this should be an inner class only Dart does non withal support them.
      • Implements 3 functions
        • onNext(T)
        • onComplete()
        • onError()
      • These 3 methods represent all possible outputs of the Usecase
        • If the Usecase returns an object, it volition exist passed to onNext(T).
        • If it errors, it volition call onError(eastward).
        • One time information technology completes, it will phone call onComplete().
      • These methods volition then telephone call the corresponding methods of the Presenter that are set by the Controller. This way, the event is passed to the Controller, which can and then manipulate data and update the ViewState
• Extra
  • Utility classes (whatever commonly used functions like timestamp getters etc..)
  • Constants classes (const strings for convenience)
  • Navigator (if needed)

Information

Represents the data-layer of the application. The Data module, which is a office of the outermost layer, is responsible for data retrieval. This tin be in the class of API calls to a server, a local database, or even both.

Contents of Information

• Repositories
  • Every Repository should implement Repository from the Domain layer.
  • Using polymorphism, these repositories from the data layer can be passed across the boundaries of layers, starting from the View down to the Usecases through the Controller and Presenter.
  • Retrieve data from databases or other methods.
  • Responsible for any API calls and high-level data manipulation such every bit
    • Registering a user with a database
    • Uploading information
    • Downloading information
    • Handling local storage
    • Calling an API
• Models (non a must depending on the awarding)
  • Extensions of Entities with the addition of extra members that might be platform-dependent. For example, in the case of local databases, this tin can be manifested as an isDeleted or an isDirty entry in the local database. Such entries cannot be present in the Entities every bit that would violate the Dependency Rule since Domain should not exist aware of the implementation.
  • In the example of our application, models in the Data layer volition non exist necessary equally we exercise not have a local database. Therefore, it is unlikely that we volition need actress entries in the Entities that are platform-dependent.
• Mappers
  • Map Entity objects to Models and vice-versa.
  • Static classes with static methods that receive either an Entity or a Model and return the other.
  • Simply necessary in the presence of Models
• Actress
  • Utility classes if needed
  • Constants classes if needed

Device

Role of the outermost layer, Device communicates direct with the platform i.e. Android and iOS. Device is responsible for Native functionality such as GPS and other functionality present within the platform itself similar the filesystem. Device calls all Native APIs.

Contents of Data

• Devices
  • Similar to Repositories in Information, Devices are classes that communicate with a specific functionality in the platform.
  • Passed through the layers the same manner Repositories are pass across the boundaries of the layer: using polymorphism between the App and Domain layer. That means the Controller passes it to the Presenter then the Presenter passes information technology polymorphically to the Usecase, which receives it as an abstruse class.
• Actress
  • Utility classes if needed
  • Constants classes if needed

          lib/     app/                          <--- application layer         pages/                        <-- pages or screens           login/                        <-- some page in the app             login_controller.dart         <-- login controller extends `Controller`             login_presenter.dart          <-- login presenter extends `Presenter`             login_view.dart               <-- login view, 2 classes extend `View` and `ViewState` resp.         widgets/                      <-- custom widgets         utils/                        <-- utility functions/classes/constants         navigator.dart                <-- optional application navigator     data/                         <--- data layer         repositories/                 <-- repositories (call up data, heavy processing etc..)           data_auth_repo.dart           <-- example repo: handles all hallmark         helpers/                      <-- any helpers east.g. http helper         constants.dart                <-- constants such equally API keys, routes, urls, etc..     device/                       <--- device layer         repositories/                 <--- repositories that communicate with the platform east.g. GPS         utils/                        <--- any utility classes/functions     domain/                       <--- domain layer (business and enterprise) PURE Sprint         entities/                   <--- enterprise entities (cadre classes of the app)           user.dart                   <-- example entity           director.sprint                <-- example entity         usecases/                   <--- business processes eastward.m. Login, Logout, GetUser, etc..           login_usecase.dart          <-- instance usecase extends `UseCase` or `CompletableUseCase`         repositories/               <--- abstruse classes that ascertain functionality for information and device layers     main.dart                     <--- entry bespeak                  

Checkout a pocket-sized example hither and a total awarding built here.

View and ControlledWidgetBuilder

          import 'package:flutter_clean_architecture/flutter_clean_architecture.dart'; course CounterPage extends View {     @override      // Dependencies can be injected here      State<StatefulWidget> createState() => CounterState(); }  class CounterState extends ViewState<CounterPage, CounterController> {      CounterState() : super(CounterController());       @override      Widget get view => MaterialApp(         title: 'Flutter Demo',         dwelling: Scaffold(         central: globalKey, // using the built-in global fundamental of the `View` for the scaffold or any other                         // widget provides the controller with a way to access them via getContext(), getState(), getStateKey()         torso: Column(           children: <Widget>[             Eye(               // show the number of times the button has been clicked               child: ControlledWidgetBuilder<CounterController>(                 builder: (context, controller) {                   return Text(controller.counter.toString());                 }               ),             ),             // you lot can refresh manually inside the controller             // using refreshUI()             ControlledWidgetBuilder<CounterController>(                 architect: (context, controller) {                   render MaterialButton(onPressed: controller.increment);                 }               ),           ],         ),       ),     ); }                  

Responsive view state

To deal with screens on flutter spider web, yous can accept advantage of the responsive view land, that abstracts the main spider web apps breakpoints (desktop, tablet and mobile) to ease development for spider web with flutter_clean_architecture

For example:

          import 'package:flutter_clean_architecture/flutter_clean_architecture.dart'; class CounterPage extends View {     @override      // Dependencies tin can be injected here      State<StatefulWidget> createState() => CounterState(); }  class CounterState extends ResponsiveViewState<CounterPage, CounterController> {      CounterState() : super(CounterController());       Widget AppScaffold({Widget child}) {          return MaterialApp(               championship: 'Palpitate Demo',            home: Scaffold(              cardinal: globalKey, // using the congenital-in global key of the `View` for the scaffold or any other                              // widget provides the controller with a fashion to admission them via getContext(), getState(), getStateKey()              torso: kid            ),          );      }        @override      ViewBuilder go mobileView => AppScaffold(          kid: Column(              children: <Widget>[                // yous tin can refresh manually inside the controller                // using refreshUI()                ControlledWidgetBuilder<CounterController>(                  builder: (context, controller) {                    return Text('Counter on mobile view ${controller.counter.toString()}');                  }                ),              ],            )       );       @override      ViewBuilder become tabletBuilder => AppScaffold(        kid: Column(            children: <Widget>[              // you lot can refresh manually inside the controller              // using refreshUI()              ControlledWidgetBuilder<CounterController>(                builder: (context, controller) {                  render Text('Counter on tablet view ${controller.counter.toString()}');                }              ),            ],          )      );       @override      ViewBuilder become desktopBuilder => AppScaffold(         child: Row(             children: <Widget>[               // you tin can refresh manually inside the controller               // using refreshUI()               ControlledWidgetBuilder<CounterController>(                 builder: (context, controller) {                   return Text('Counter on desktop view ${controller.counter.toString()}');                 }               ),             ],           )       ); }                  

Widgets with Mutual Controller

In the effect that multiple widgets demand to use the same Controller of a sure Page, the Controller tin can be retrieved inside the children widgets of that page via FlutterCleanArchitecture.getController<HomeController>(context).

For example:

                      import '../pages/home/home_controller.dart'; import 'bundle:flutter/material.dart'; import 'package:flutter_clean_architecture/flutter_clean_architecture.dart';  class HomePageButton extends StatelessWidget {   last Cord text;   HomePageButton({@required this.text});    @override   Widget build(BuildContext context) {     // utilize a mutual controller assuming HomePageButton is always a child of Habitation     HomeController controller =         FlutterCleanArchitecture.getController<HomeController>(context);     return GestureDetector(       onTap: controller.buttonPressed,       kid: Container(         meridian: 50.0,         alignment: FractionalOffset.middle,         ornamentation: BoxDecoration(           color: Color.fromRGBO(230, 38, 39, one.0),           borderRadius: BorderRadius.round(25.0),         ),         child: Text(           text,           manner: const TextStyle(               color: Colors.white,               fontSize: 20.0,               fontWeight: FontWeight.w300,               letterSpacing: 0.4),         ),       ),     );   } }                  

Controller

          import 'package:flutter_clean_architecture/flutter_clean_architecture.sprint';  grade CounterController extends Controller {   int counter;   terminal LoginPresenter presenter;   CounterController() : counter = 0, presenter = LoginPresenter(), super();    void increment() {     counter++;   }    /// Shows a snackbar   void showSnackBar() {     ScaffoldState scaffoldState = getState(); // go the state, in this case, the scaffold     scaffoldState.showSnackBar(SnackBar(content: Text('Hi')));   }    @override   void initListeners() {     // Initialize presenter listeners hither     // These will be called upon success, failure, or data retrieval later usecase execution      presenter.loginOnComplete = () => print('Login Successful');      presenter.loginOnError = (due east) => print(e);      presenter.loginOnNext = () => impress("onNext");   }    void login() {       // laissez passer appropriate credentials here       // assuming you have text fields to recollect them and whatnot       presenter.login();   } }                  

Presenter

          import 'parcel:flutter_clean_architecture/flutter_clean_architecture.dart';  class LoginPresenter() {    Office loginOnComplete; // alternatively `void loginOnComplete();`   Function loginOnError;   Function loginOnNext; // non needed in the case of a login presenter    terminal LoginUseCase loginUseCase;   // dependency injection from controller   LoginPresenter(authenticationRepo): loginUseCase = LoginUseCase(authenticationRepo);    /// login function called by the controller   void login(String electronic mail, String password) {     loginUseCase.execute(_LoginUseCaseObserver(this), LoginUseCaseParams(email, countersign));   }     /// Disposes of the [LoginUseCase] and unsubscribes    @override    void dispose() {      _loginUseCase.dispose();    } }  /// The [Observer] used to observe the `Stream` of the [LoginUseCase] course _LoginUseCaseObserver implements Observer<void> {    // The above presenter   // This is not optimal, merely it is a workaround due to sprint limitations. Dart does   // not support inner classes or anonymous classes.   concluding LoginPresenter loginPresenter;    _LoginUseCaseObserver(this.loginPresenter);    /// implement if the `Stream` emits a value   // in this example, unnecessary   void onNext(_) {}    /// Login is successful, trigger event in [LoginController]   void onComplete() {     // any cleaning or preparation goes here     affirm(loginPresenter.loginOnComplete != null);     loginPresenter.loginOnComplete();    }    /// Login was unsuccessful, trigger effect in [LoginController]   void onError(east) {     // whatever cleaning or preparation goes here     affirm(loginPresenter.loginOnError != nothing);     loginPresenter.loginOnError(due east);   } }                  

UseCase

          import 'parcel:flutter_clean_architecture/flutter_clean_architecture.dart';  // In this instance, no parameters were needed. Hence, void. Otherwise, change to appropriate. class LoginUseCase extends CompletableUseCase<LoginUseCaseParams> {   final AuthenticationRepository _authenticationRepository; // some dependency to be injected                                           // the functionality is hidden backside this                                           // abstract class defined in the Domain module                                           // It should be implemented within the Information or Device                                           // module and passed polymorphically.    LoginUseCase(this._authenticationRepository);    @override   // Since the parameter type is void, `_` ignores the parameter. Change co-ordinate to the type   // used in the template.   Future<Stream<void>> buildUseCaseStream(params) async {     concluding StreamController controller = StreamController();     endeavour {         // bold you laissez passer credentials here       await _authenticationRepository.cosign(email: params.e-mail, password: params.countersign);       logger.finest('LoginUseCase successful.');       // triggers onComplete       controller.close();     } catch (e) {       print(e);       logger.severe('LoginUseCase unsuccessful.');       // Trigger .onError       controller.addError(eastward);     }     render controller.stream;   } }  class LoginUseCaseParams {     final String email;     concluding String password;     LoginUseCaseParams(this.email, this.password); }                  

Groundwork UseCase

A usecase tin can exist made to run on a divide isolate using the BackgroundUseCase class. Implementing this kind of usecase is a footling different than a regular usecase due to the constraints of an isolate. In order to create a BackgroundUseCase, but extend the course and override the buildUseCaseTask method. This method should return a UseCaseTask, which is simply a function that has a void render type and takes a BackgroundUseCaseParameters parameter. This method should be static and volition contain all the code you wish to run on a separate isolate. This method should communicate with the main isolate using the port provided in the BackgroundUseCaseParameters every bit follows. This example is of a BackgroundUseCase that performs matrix multiplication.

                      class MatMulUseCase extends BackgroundUseCase<List<List<double>>, MatMulUseCaseParams> {    // must be overridden   @override   buildUseCaseTask() {     render matmul;  // returns the static method that contains the code to exist run on an isolate   }    /// This method volition exist executed on a separate isolate. The [params] contain all the information and the sendPort    /// needed   static void matmul(BackgroundUseCaseParams params) async {     MatMulUseCaseParams matMulParams = params.params equally MatMulUseCaseParams;     Listing<List<double>> consequence = Listing<List<double>>.generate(         10, (i) => List<double>.generate(10, (j) => 0));      for (int i = 0; i < matMulParams.mat1.length; i++) {       for (int j = 0; j < matMulParams.mat1.length; j++) {         for (int g = 0; 1000 < matMulParams.mat1.length; k++) {           event[i][j] += matMulParams.mat1[i][k] * matMulParams.mat2[chiliad][j];         }       }     }     // send the result dorsum to the main isolate     // this volition be forwarded to the observer listneres     params.port.send(BackgroundUseCaseMessage(data: result));    } }                  

Just like a regular [UseCase], a parameter class is recommended for any [BackgroundUseCase]. An example corresponding to the above instance would be

          class MatMulUseCaseParams {   Listing<Listing<double>> mat1;   List<List<double>> mat2;   MatMulUseCaseParams(this.mat1, this.mat2);   MatMulUseCaseParams.random() {     var size = ten;     mat1 = List<List<double>>.generate(size,         (i) => Listing<double>.generate(size, (j) => i.toDouble() * size + j));      mat2 = Listing<List<double>>.generate(size,         (i) => Listing<double>.generate(size, (j) => i.toDouble() * size + j));   } }                  

Repository in Domain

                      abstract class AuthenticationRepository {   Time to come<void> register(       {@required String firstName,       @required String lastName,       @required String email,       @required String password});    /// Authenticates a user using his [username] and [countersign]   Future<void> cosign(       {@required Cord email, @required Cord password});    /// Returns whether the [User] is authenticated.   Future<bool> isAuthenticated();    /// Returns the current authenticated [User].   Future<User> getCurrentUser();    /// Resets the countersign of a [User]   Futurity<void> forgotPassword(String email);    /// Logs out the [User]   Time to come<void> logout(); }                  

This repository should be implemented in Information layer

                      class DataAuthenticationRepository extends AuthenticationRepository {   // singleton   static DataAuthenticationRepository _instance = DataAuthenticationRepository._internal();   DataAuthenticationRepository._internal();   factory DataAuthenticationRepository() => _instance;      @override   Hereafter<void> register(       {@required String firstName,       @required String lastName,       @required String electronic mail,       @required String password}) {           // TODO: implement       }    /// Authenticates a user using his [username] and [password]   @override   Future<void> authenticate(       {@required String email, @required Cord password}) {           // TODO: implement       }    /// Returns whether the [User] is authenticated.   @override   Future<bool> isAuthenticated() {       // TODO: implement   }    /// Returns the current authenticated [User].   @override   Future<User> getCurrentUser() {       // TODO: implement   }    /// Resets the countersign of a [User]   @override   Hereafter<void> forgotPassword(String email) {       // TODO: implement   }    /// Logs out the [User]   @override   Time to come<void> logout() {       // TODO: implement   } }                  

If the repository is platform-related, implement it in the Device layer.

Entity

Defined in Domain layer.

                      class User {     final String proper name;     final String e-mail;     terminal Cord uid;     User(this.name, this.electronic mail, this.uid); }                  

Checkout a pocket-size instance here and a full application built here.

Shady Boukhary Rafael Monteiro

Source: https://pub.dev/packages/flutter_clean_architecture

Posted by: bradleyroutionce.blogspot.com

Share this post