A Flutter package that makes it easy and intuitive to implement Uncle Bob's Clean Architecture in Flutter. This package provides basic classes that are tuned to work with Flutter and are designed according to the Clean Architecture.
Add this to your package's pubspec.yaml file:
dependencies:
core_clean_architecture: ^5.0.3
You 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 learn more.
Now in your Dart code, you can use:
import 'package:core_clean_architecture/core_clean_architecture.dart';
It is architecture based on the book and blog 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 four main modules: App
, Domain
, Data
, and Device
.
Source code dependencies only point inwards. This means inward modules are neither aware of nor dependent on outer modules. However, outer modules are both aware of and dependent on inner modules. Outer modules represent the mechanisms by which the business rules and policies (inner modules) operate. The more you move inward, the more abstraction is present. The outer you move the more concrete implementations are present. Inner modules are not aware of any classes, functions, names, libraries, etc.. present in the outer modules. They simply represent rules and are completely independent from the implementations.
The Domain
module defines the business logic of the application. It is a module that is independent from the development platform i.e. it is written purely in the programming language and does not contain any elements from the platform. In the case of Flutter
, Domain
would be written purely in Dart
without any Flutter
elements. The reason for that is that Domain
should only be concerned with the business logic of the application, not with the implementation details. This also allows for easy migration between platforms, should any issues arise.
Domain
is made up of several things.
- Entities
- Enterprise-wide business rules
- Made up of classes that can contain methods
- Business objects of the application
- Used application-wide
- Least 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 data throughout the app
- Should not be affected by any UI changes whatsoever
- Might change if the functionality and flow of application change
- Repositories
- Abstract classes that define the expected functionality of outer layers
- Are not aware of outer layers, simply define expected functionality
- E.g. The
Login
usecase expects aRepository
that haslogin
functionality
- E.g. The
- Passed to
Usecases
from outer layers
Domain
represents the inner-most layer. Therefore, it the most abstract layer in the architecture.
App
is the layer outside Domain
. App
crosses the boundaries of the layers to communicate with Domain
. However, 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 behind the polymorphism
.
Since App
is the presentation layer of the application, it is the most framework-dependent layer, as it contains the UI and the event handlers of the UI. For every page 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's UI, styles it, and depends on theController
to handle its events. TheView
has-aController
. - In the case of Flutter
- The
View
is comprised of 2 classes- One that extends
View
, which would be the rootWidget
representing theView
- One that extends
ViewState
with the template specialization of the other class and itsController
.
- One that extends
- The
ViewState
contains theview
getter, which is technically the UI implementation StatefulWidget
contains theState
as perFlutter
- The
StatefulWidget
only serves to pass arguments to theState
from other pages such as a title etc.. It only instantiates theState
object (theViewState
) and provides it with theController
it needs through it's consumer. - The
StatefulWidget
has-aState
object (theViewState
) which has-aController
- In summary, both the
StatefulWidget
and theState
are represented by aView
andViewState
of the page. - The
ViewState
class maintains aGlobalKey
that can be used as a key in its scaffold. If used, theController
can easily access it viagetState()
in order to show snackbars and other dialogs. This is helpful but optional.
- The
- Represents only the UI of the page. The
- Controller
- Every
ViewState
has-aController
. TheController
provides the needed member data of theViewState
i.e. dynamic data. TheController
also implements the event-handlers of theViewState
widgets, but has no access to theWidgets
themselves. TheViewState
uses theController
, not the other way around. When theViewState
calls a handler from theController
,refreshUI()
can be called to update the view. - Every
Controller
extends theController
abstract class, which implementsWidgetsBindingObserver
. EveryController
class is responsible for handling lifecycle events for theView
and can 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 thePresenter
for consistency. - The
Controller
has-aPresenter
. TheController
will pass theRepository
to thePresenter
, which it communicate later with theUsecase
. TheController
will specify what listeners thePresenter
should call for all success and error events as mentioned previously. Only theController
is allowed to obtain instances of aRepository
from theData
orDevice
module in the outermost layer. - The
Controller
has access to theViewState
and can refresh theControlledWidgets
viarefreshUI()
.
- Every
- Presenter
- Every
Controller
has-aPresenter
. ThePresenter
communicates with theUsecase
as mentioned at the beginning of theApp
layer. ThePresenter
will have members that are functions, which are optionally set by theController
and will be called if set upon theUsecase
sending back data, completing, or erroring. - The
Presenter
is comprised of two classesPresenter
e.g.LoginPresenter
- Contains the event-handlers set by the
Controller
- Contains the
Usecase
to be used - Initializes and executes the usecase with the
Observer<T>
class and the appropriate arguments. E.g. withusername
andpassword
in the case of aLoginPresenter
- Contains the event-handlers set by the
- A class that implements
Observer<T>
- Has reference to the
Presenter
class. Ideally, this should be an inner class butDart
does not yet 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 will be passed toonNext(T)
. - If it errors, it will call
onError(e)
. - Once it completes, it will call
onComplete()
.
- If the
- These methods will then call the corresponding methods of the
Presenter
that are set by theController
. This way, the event is passed to theController
, which can then manipulate data and update theViewState
- Has reference to the
- Every
- Extra
Utility
classes (any commonly used functions like timestamp getters etc..)Constants
classes (const
strings for convenience)Navigator
(if needed)
Represents the data-layer of the application. The Data
module, which is a part of the outermost layer, is responsible for data retrieval. This can be in the form of API calls to a server, a local database, or even both.
- Repositories
- Every
Repository
should implementRepository
from the Domain layer. - Using
polymorphism
, these repositories from the data layer can be passed across the boundaries of layers, starting from theView
down to theUsecases
through theController
andPresenter
. - Retrieve data from databases or other methods.
- Responsible for any API calls and high-level data manipulation such as
- Registering a user with a database
- Uploading data
- Downloading data
- Handling local storage
- Calling an API
- Every
- Models (not a must depending on the application)
- Extensions of
Entities
with the addition of extra members that might be platform-dependent. For example, in the case of local databases, this can be manifested as anisDeleted
or anisDirty
entry in the local database. Such entries cannot be present in theEntities
as that would violate the Dependency Rule since Domain should not be aware of the implementation. - In the case of our application, models in the
Data
layer will not be necessary as we do not have a local database. Therefore, it is unlikely that we will need extra entries in theEntities
that are platform-dependent.
- Extensions of
- Mappers
- Map
Entity
objects toModels
and vice-versa. - Static classes with static methods that receive either an
Entity
or aModel
and return the other. - Only necessary in the presence of
Models
- Map
- Extra
Utility
classes if neededConstants
classes if needed
Part of the outermost layer, Device
communicates directly 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 like the filesystem. Device
calls all Native APIs.
- Devices
- Similar to
Repositories
inData
,Devices
are classes that communicate with a specific functionality in the platform. - Passed through the layers the same way
Repositories
are pass across the boundaries of the layer: using polymorphism between theApp
andDomain
layer. That means theController
passes it to thePresenter
then thePresenter
passes it polymorphically to theUsecase
, which receives it as an abstract class.
- Similar to
- Extra
Utility
classes if neededConstants
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 (retrieve data, heavy processing etc..)
data_auth_repo.dart <-- example repo: handles all authentication
helpers/ <-- any helpers e.g. http helper
constants.dart <-- constants such as API keys, routes, urls, etc..
device/ <--- device layer
repositories/ <--- repositories that communicate with the platform e.g. GPS
utils/ <--- any utility classes/functions
domain/ <--- domain layer (business and enterprise) PURE DART
entities/ <--- enterprise entities (core classes of the app)
user.dart <-- example entity
manager.dart <-- example entity
usecases/ <--- business processes e.g. Login, Logout, GetUser, etc..
login_usecase.dart <-- example usecase extends `UseCase` or `CompletableUseCase`
repositories/ <--- abstract classes that define functionality for data and device layers
main.dart <--- entry point
Checkout a small example here and a full application built here.
import 'package:core_clean_architecture/core_clean_architecture.dart';
class 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',
home: Scaffold(
key: globalKey, // using the built-in global key of the `View` for the scaffold or any other
// widget provides the controller with a way to access them via getContext(), getState(), getStateKey()
body: Column(
children: <Widget>[
Center(
// show the number of times the button has been clicked
child: ControlledWidgetBuilder<CounterController>(
builder: (context, controller) {
return Text(controller.counter.toString());
}
),
),
// you can refresh manually inside the controller
// using refreshUI()
ControlledWidgetBuilder<CounterController>(
builder: (context, controller) {
return MaterialButton(onPressed: controller.increment);
}
),
],
),
),
);
}
To deal with screens on flutter web, you can take advantage of the responsive view state,
that abstracts the main web apps breakpoints (desktop, tablet and mobile) to ease development
for web with core_clean_architecture
For example:
import 'package:core_clean_architecture/core_clean_architecture.dart';
class CounterPage extends View {
@override
// Dependencies can be injected here
State<StatefulWidget> createState() => CounterState();
}
class CounterState extends ResponsiveViewState<CounterPage, CounterController> {
CounterState() : super(CounterController());
Widget AppScaffold({Widget child}) {
return MaterialApp(
title: 'Flutter Demo',
home: Scaffold(
key: globalKey, // using the built-in global key of the `View` for the scaffold or any other
// widget provides the controller with a way to access them via getContext(), getState(), getStateKey()
body: child
),
);
}
@override
ViewBuilder get mobileView => AppScaffold(
child: Column(
children: <Widget>[
// you can refresh manually inside the controller
// using refreshUI()
ControlledWidgetBuilder<CounterController>(
builder: (context, controller) {
return Text('Counter on mobile view ${controller.counter.toString()}');
}
),
],
)
);
@override
ViewBuilder get tabletBuilder => AppScaffold(
child: Column(
children: <Widget>[
// you can refresh manually inside the controller
// using refreshUI()
ControlledWidgetBuilder<CounterController>(
builder: (context, controller) {
return Text('Counter on tablet view ${controller.counter.toString()}');
}
),
],
)
);
@override
ViewBuilder get desktopBuilder => AppScaffold(
child: Row(
children: <Widget>[
// you can refresh manually inside the controller
// using refreshUI()
ControlledWidgetBuilder<CounterController>(
builder: (context, controller) {
return Text('Counter on desktop view ${controller.counter.toString()}');
}
),
],
)
);
}
In the event that multiple widgets need to use the same Controller
of a certain Page
,
the Controller
can be retrieved inside the children widgets of that page via
FlutterCleanArchitecture.getController<HomeController>(context)
.
For example:
import '../pages/home/home_controller.dart';
import 'package:flutter/material.dart';
import 'package:core_clean_architecture/core_clean_architecture.dart';
class HomePageButton extends StatelessWidget {
final String text;
HomePageButton({@required this.text});
@override
Widget build(BuildContext context) {
// use a common controller assuming HomePageButton is always a child of Home
HomeController controller =
FlutterCleanArchitecture.getController<HomeController>(context);
return GestureDetector(
onTap: controller.buttonPressed,
child: Container(
height: 50.0,
alignment: FractionalOffset.center,
decoration: BoxDecoration(
color: Color.fromRGBO(230, 38, 39, 1.0),
borderRadius: BorderRadius.circular(25.0),
),
child: Text(
text,
style: const TextStyle(
color: Colors.white,
fontSize: 20.0,
fontWeight: FontWeight.w300,
letterSpacing: 0.4),
),
),
);
}
}
import 'package:core_clean_architecture/core_clean_architecture.dart';
class CounterController extends Controller {
int counter;
final LoginPresenter presenter;
CounterController() : counter = 0, presenter = LoginPresenter(), super();
void increment() {
counter++;
}
/// Shows a snackbar
void showSnackBar() {
ScaffoldState scaffoldState = getState(); // get the state, in this case, the scaffold
scaffoldState.showSnackBar(SnackBar(content: Text('Hi')));
}
@override
void initListeners() {
// Initialize presenter listeners here
// These will be called upon success, failure, or data retrieval after usecase execution
presenter.loginOnComplete = () => print('Login Successful');
presenter.loginOnError = (e) => print(e);
presenter.loginOnNext = () => print("onNext");
}
void login() {
// pass appropriate credentials here
// assuming you have text fields to retrieve them and whatnot
presenter.login();
}
}
import 'package:core_clean_architecture/core_clean_architecture.dart';
class LoginPresenter() {
Function loginOnComplete; // alternatively `void loginOnComplete();`
Function loginOnError;
Function loginOnNext; // not needed in the case of a login presenter
final LoginUseCase loginUseCase;
// dependency injection from controller
LoginPresenter(authenticationRepo): loginUseCase = LoginUseCase(authenticationRepo);
/// login function called by the controller
void login(String email, String password) {
loginUseCase.execute(_LoginUseCaseObserver(this), LoginUseCaseParams(email, password));
}
/// Disposes of the [LoginUseCase] and unsubscribes
@override
void dispose() {
_loginUseCase.dispose();
}
}
/// The [Observer] used to observe the `Stream` of the [LoginUseCase]
class _LoginUseCaseObserver implements Observer<void> {
// The above presenter
// This is not optimal, but it is a workaround due to dart limitations. Dart does
// not support inner classes or anonymous classes.
final LoginPresenter loginPresenter;
_LoginUseCaseObserver(this.loginPresenter);
/// implement if the `Stream` emits a value
// in this case, unnecessary
void onNext(_) {}
/// Login is successful, trigger event in [LoginController]
void onComplete() {
// any cleaning or preparation goes here
assert(loginPresenter.loginOnComplete != null);
loginPresenter.loginOnComplete();
}
/// Login was unsuccessful, trigger event in [LoginController]
void onError(e) {
// any cleaning or preparation goes here
assert(loginPresenter.loginOnError != null);
loginPresenter.loginOnError(e);
}
}
import 'package:core_clean_architecture/core_clean_architecture.dart';
// In this case, 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 behind this
// abstract class defined in the Domain module
// It should be implemented inside the Data or Device
// module and passed polymorphically.
LoginUseCase(this._authenticationRepository);
@override
// Since the parameter type is void, `_` ignores the parameter. Change according to the type
// used in the template.
Future<Stream<void>> buildUseCaseStream(params) async {
final StreamController controller = StreamController();
try {
// assuming you pass credentials here
await _authenticationRepository.authenticate(email: params.email, password: params.password);
logger.finest('LoginUseCase successful.');
// triggers onComplete
controller.close();
} catch (e) {
print(e);
logger.severe('LoginUseCase unsuccessful.');
// Trigger .onError
controller.addError(e);
}
return controller.stream;
}
}
class LoginUseCaseParams {
final String email;
final String password;
LoginUseCaseParams(this.email, this.password);
}
A usecase can be made to run on a separate isolate using the BackgroundUseCase
class.
Implementing this kind of usecase is a little different than a regular usecase due to the constraints of an isolate.
In order to create a BackgroundUseCase
, simply extend the class and override the buildUseCaseTask
method.
This method should return a UseCaseTask
, which is just a function that has a void return type and takes a
BackgroundUseCaseParameters
parameter. This method should be static and will 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
as follows. This example is of a BackgroundUseCase
that performs matrix multiplication.
class MatMulUseCase extends BackgroundUseCase<List<List<double>>, MatMulUseCaseParams> {
// must be overridden
@override
buildUseCaseTask() {
return matmul; // returns the static method that contains the code to be run on an isolate
}
/// This method will be executed on a separate isolate. The [params] contain all the data and the sendPort
/// needed
static void matmul(BackgroundUseCaseParams params) async {
MatMulUseCaseParams matMulParams = params.params as MatMulUseCaseParams;
List<List<double>> result = List<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 k = 0; k < matMulParams.mat1.length; k++) {
result[i][j] += matMulParams.mat1[i][k] * matMulParams.mat2[k][j];
}
}
}
// send the result back to the main isolate
// this will 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 example would be
class MatMulUseCaseParams {
List<List<double>> mat1;
List<List<double>> mat2;
MatMulUseCaseParams(this.mat1, this.mat2);
MatMulUseCaseParams.random() {
var size = 10;
mat1 = List<List<double>>.generate(size,
(i) => List<double>.generate(size, (j) => i.toDouble() * size + j));
mat2 = List<List<double>>.generate(size,
(i) => List<double>.generate(size, (j) => i.toDouble() * size + j));
}
}
abstract class AuthenticationRepository {
Future<void> register(
{@required String firstName,
@required String lastName,
@required String email,
@required String password});
/// Authenticates a user using his [username] and [password]
Future<void> authenticate(
{@required String email, @required String password});
/// Returns whether the [User] is authenticated.
Future<bool> isAuthenticated();
/// Returns the current authenticated [User].
Future<User> getCurrentUser();
/// Resets the password of a [User]
Future<void> forgotPassword(String email);
/// Logs out the [User]
Future<void> logout();
}
This repository should be implemented in Data layer
class DataAuthenticationRepository extends AuthenticationRepository {
// singleton
static DataAuthenticationRepository _instance = DataAuthenticationRepository._internal();
DataAuthenticationRepository._internal();
factory DataAuthenticationRepository() => _instance;
@override
Future<void> register(
{@required String firstName,
@required String lastName,
@required String email,
@required String password}) {
// TODO: implement
}
/// Authenticates a user using his [username] and [password]
@override
Future<void> authenticate(
{@required String email, @required String 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 password of a [User]
@override
Future<void> forgotPassword(String email) {
// TODO: implement
}
/// Logs out the [User]
@override
Future<void> logout() {
// TODO: implement
}
}
If the repository is platform-related, implement it in the Device layer.
Defined in Domain layer.
class User {
final String name;
final String email;
final String uid;
User(this.name, this.email, this.uid);
}
Checkout a full example application built here.