This is a boilerplate project created in flutter using Provider, Firebase, Dio, and some fundamentals of Robert C Martin’s Clean Architecture.

Getting Started

The boilerplate is a minimal implementation that can be used to create a new project or library. It comes with a variety of basic components such as an app architecture, a theme, and necessary dependencies. The repository code can be used as an initializer to quickly build new projects and reduce the time it takes to develop them.

How to Use

Step 1:

Download or clone this repo by using the link below:  

Step 2:

Go to project root and execute the following command in console to get the required dependencies:

flutter pub get   

Step 3: Change the package name by just doing a project wide search and replacing “com.baseprojectsrl.baseproject” to the one you desire

Step 4:

This project uses code generation for domain/network models and app localization, execute the following command to generate files:

flutter packages pub run build_runner build --delete-conflicting-outputs  

or watch command in order to keep the source code synced automatically:

flutter packages pub run build_runner watch  

Step 5:

Go to Firebase, create a new project, configure it and place the GoogleServices-Info.plist and google-services.json in the correct positions, if you skip this step the app will not run

Hide Generated Files

In-order to hide generated files, navigate to Android Studio -> Preferences -> Editor -> File Types and paste the below lines under ignore files and folders section:


In Visual Studio Code, navigate to Preferences -> Settings and search for Files:Exclude. Add the following patterns:


Boilerplate Features:

  • Splash
  • Lazy loaded lists
  • Login
  • Home
  • Routing
  • Theme
  • Dio
  • Database
  • Provider (State Management)
  • Validation
  • Code Generation
  • Dependency Injection
  • Dark Theme Support
  • Multilingual Support

Folder Structure

Here is the folder structure we have been using in this project

|- dev/  
   |- main.dart  
|- i18n/  
|- prod/  
   |- main.dart  
|- resources/  
|- src/  
   |- base  
   |- home_page  
   |- login  
   |- post_detail  
   |- profile_page  
   |- signup  
   |- start  
   |- updates  
   |- app.dart  

Now, lets dive into the lib folder which has the main code for the application.

1- dev - This is where the starting point of the application in case we want to work in a hipotetycal   
       development enviroment  
2- i18n - Here we have all the .yaml files for each localization that we would need  
3- prod - This is where the starting point of the application in case we want to work in a hipotetycal   
        production enviroment  
4- resources - Here we have all the possible resources needed (Sizes,Image references etc.)  
5- src - This is where we develop the app itself  
   1- base - Base feature is where we manage the whole app which isn't specifically feature-related, and   
           instead it's app related. It contains all the non-feature releated data  
   2- home_page - Home page feature  
   3- login - Login page feature  
   4- post_detail - Post detail page feature  
   5- profile_page - Profile page  feature  
   6- signup - Signup page feature  
   7- start - Start feature is the first feature always launcher, it cointains basic navigation and auth   
   8- updates- Updates page feature  
   9- app.dart - This is the real starting point of the application, where we inject all the  
              dependencies and run the app  

Feature structure

Each feature follow the main principles of the Clean Architecture paths.

|- data  
|- di  
|- domain  
|- ui  


The Data layer consists of data source code such as Rest APIs, Access to local/remote databases, or any other data source. Here we follow a system of abstract classes in order to follow the signature of the methods defined in the Domain layer. This will complicate a bit the things, but allows us to have a robust code and will help also in the test/debugs faces.

|- source/  
   |- feature_remote_data_source.dart  
   |- feature_remote_data_source_impl.dart  
|- feature_repository_impl.dart  

Di (Dependency injection)

Here is where we make a class independent of its own dependencies. This will enable us to separate different parts of the app in a more manageable way because each class can make calls to any dependency, it needs at any given time.

|- feature_providers.dart  


The Domain folder contains the models which help draw and structure our data and the signature for the functions implemented in the data layer. This basically makes the domain layer a kind of ‘glue’ between Data and the UI/logic.

|- model/  
   |- request_model.dart  
   |- response_model.dart  
|- feature_repository.dart  


In the UI Folder we manage Pages/ Navigation/ Widgets/ State Management (ViewModel).

  • The Pages consist of the pages included in the feature we are working on. Which is built from smaller widgets regarding this feature.

  • Navigator is where we add the logic of the navigation within that feature which allows us to move through the pages.

  • The ViewModel is where we manage the state of these pages and the whole feature and the business logic of course.

|- model  
|- navigator  
|- pages  
|- viewmodel  
|- widget  


This is the starting point of the application. All the application level configurations are defined in this file i.e, theme, title, orientation etc. The behavior of the app such as flavour, be endpoint etc. can be configured by using the class AppConfig. In this case we use dev/main.dart and prod/main.dart for handling such things.


import 'package:flutter/material.dart';    
import '../src/app.dart';    
void main() {    
     host: "",    
     isProd: false,  


import 'dart:io';    
import 'package:firebase_core/firebase_core.dart';    
import 'package:firebase_crashlytics/firebase_crashlytics.dart';    
import 'package:flutter/cupertino.dart';    
import 'package:flutter/foundation.dart';    
import 'package:flutter/material.dart';    
import 'package:flutter/services.dart';    
import 'package:flutter_displaymode/flutter_displaymode.dart';    
import 'package:flutter_localizations/flutter_localizations.dart';    
import 'package:provider/provider.dart';    
import 'package:shared_preferences/shared_preferences.dart';    
import '../resources/app_config.dart';    
import 'base/settings/di/theme_providers.dart';    
import 'base/settings/ui/viewmodel/theme_viewmodel.dart';    
import 'base/token/di/token_providers.dart';    
import 'base/widget/ui/custom_circular_progress_indicator.dart';    
import 'start/di/start_page_providers.dart';    
import 'start/ui/navigator/start_page_navigator.dart';    
void mainCommon({required String host, required bool isProd, required String onesignalAppID}) async {    
 await WidgetsFlutterBinding.ensureInitialized();    
  await Firebase.initializeApp();    
  if(Platform.isAndroid) {    
 await FlutterDisplayMode.setHighRefreshRate();    
  final prefs = await SharedPreferences.getInstance();    
 (value) => runApp(    
           providers: themePageProviders(prefs),    
           builder: (context, __) {    
              final themeViewModel =<ThemeViewModel>();    
              return App(    
                 host: host,    
                 isProd: isProd,    
                 themeViewModel: themeViewModel,    


GeniusCrew B.V

Van Coothplein 53

4811 ND, Breda

The Netherlands


View Github