Good Flutter layered architecture: TBR Group expertise

In this post, you’ll learn more about Layering the Flutter Application Architecture.

Structuring code is crucial for building large-scale applications that are maintainable and extendable. Poorly structured code can make it difficult to add new features or make changes to existing functionality, leading to bugs and technical debt that can accumulate over time.

What is app architecture?

The architecture of an application determines how its components interact with each other, how data is stored and retrieved, and how the application responds to user input. A well-structured architecture should be modular, with clear separation of concerns between different parts of the codebase. This allows developers to work on different parts of the codebase independently, without fear of breaking other parts of the application. 

There are several popular architectural patterns that can be used to structure code, such as Model-View-Controller (MVC), Model-View-ViewModel (MVVM), and Clean Architecture. Each pattern has its own strengths and weaknesses, and the choice of pattern will depend on the specific needs of the application.

 Some common components of an application architecture include:

  • User interface (UI). The interface that users interact with to use the application.
  • Data storage. The technology used to store data, such as a database or file system.
  • Backend. The server-side components that handle business logic and data processing.
  • Networking. The protocols and technologies used to communicate between the frontend and backend of the application.
  • Security. The mechanisms used to protect the application from unauthorized access and attacks.

A few words about layers

Layers refer to different levels of abstraction or responsibility in a system. Each layer has a specific function and interacts with the layers above and below it to provide a cohesive and functional system.

The layers typically include:

  • Presentation Layer: This layer is responsible for presenting the data to the user in a way that is easy to understand and interact with. It includes user interface components such as screens, forms, and dialogs.
  • Business Layer: This layer contains the application logic and business rules that process and manipulate data. It handles data validation, workflows, and business logic rules that govern how data is processed.
  • Data Access Layer: This layer is responsible for accessing data from a database or other data storage mechanism. It includes data access components such as data mappers, repositories, and data contexts.
  • Infrastructure Layer: This layer contains the technical infrastructure components that support the application. It includes components such as logging, configuration, and security.

By separating an application into layers, each layer can be developed and tested independently, making the application more maintainable and scalable. It also allows for more flexibility in the development process, as changes can be made to one layer without affecting the others.

The layered architecture pattern is just one example of how layers can be used in software development. Other examples include the OSI model for networking and the protocol stack used in communications.

The Single Responsibility Principle

The Single Responsibility Principle (SRP) is a software development principle when each class or module should have only one responsibility or job to perform.

The SRP is one of the SOLID principles;it helps to ensure that code is easy to understand, modify, and test.

When a class or module has only one responsibility, it is easier to understand its purpose and to modify it without affecting other parts of the codebase. This also helps to reduce the likelihood of introducing bugs or errors when making changes.

For example, a class that handles user authentication should not also be responsible for managing user profiles. Instead, these responsibilities should be separated into two separate classes, each with its own responsibility. 
Here are some examples of responsibilities that software components may have:

  • User interface (UI) components are responsible for displaying information to the user and capturing user input.
  • Business logic components are responsible for implementing the business rules and processes that govern the behavior of an application.
  • Data access components are responsible for accessing and manipulating data in a database or other data storage mechanism.
  • Networking components are responsible for managing communication between different parts of an application or between different applications.
  • Security components are responsible for ensuring that an application is secure and protected from unauthorized access or attacks.

Architectural patterns

Some common architectural choices include:

  • Monolithic architecture involves building a single, self-contained application that handles all aspects of the system’s functionality. This can be easier to develop and deploy, but may become unwieldy as the system grows larger and more complex.
  • Microservices architecture implies breaking the system down into small, independent services that communicate with each other over a network. This can make the system more scalable and easier to maintain, but may introduce additional complexity in terms of service discovery, communication protocols, and deployment.
  • Event-driven architecture is about building the system around a set of events or triggers, such as user input or external messages. This can make the system more responsive and adaptable to changing conditions, but may require additional overhead in terms of event management and processing.
  • Service-oriented architecture (SOA) is for building the system around a set of loosely-coupled, reusable services that can be easily combined and composed to create more complex functionality. This can make the system more flexible and adaptable, but may require additional effort in terms of service design and coordination.

When making architectural choices, consider a variety of factors, including the requirements of the system, the available technology stack, the skills and experience of the development team, and the expected future growth and evolution of the system. 

Define your layers

You can create different layers in your application to perform the three main duties. Layers need to be defined carefully so that they guarantee convenient operation and without compromising work.

Good architecture: what is it?

At TBR Group, we follow an architecture pattern that has four layers.

  1. Data Layer. This layer is responsible for interacting with the API.
  2. Domain Layer. This is the one responsible for transforming the data coming from the data layer.
  3. Business logic layer manages the state (usually using flutter_bloc).
  4. Finally, the presentation layer. It renders UI components based on the state.

Each layer contains multiple neurons, or nodes, which perform mathematical operations on the input data and pass the output to the next layer. The first layer, the input layer, receives the raw input data and passes it to the first hidden layer. The output layer produces the final output of the network, which could be a prediction or classification based on the input.

The layer responsible for domain-specific data modeling is known as the domain layer, which transforms unprocessed data into models specific to the domain that are then used by the business logic layer. The business logic layer maintains an unalterable state of the domain models supplied by the repository. Furthermore, this layer responds to user inputs from the UI and interacts with the repository when modifications are required based on the current state.

Say NO to mixed responsibilities

Very often, mixed responsibilities cause chaos in various projects. Without a clear division of duties and priorities, it is very easy to get confused and make a lot of mistakes that are then difficult to find and correct. 

import 'package:firebase_auth/firebase_auth.dart';

class StartPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StreamBuilder<User?>(
      stream: FirebaseAuth.instance.userChanges(),
      builder: (context, snapshot) {
        if (snapshot.hasData) {
          return const ProfilePage();
        }

        return const SignInPage();
      },
    );
  }
}

Be consistent (always)

When working according to a specific template for projects, we advise you not to use labels with layers. Each layer should have a chain of relationships that will prevent interaction between layers that are not directly related. For example, the presentation layer should not call or interact in any way directly with the data-tier APIs.
Establish a consistent naming convention and adhere to it throughout the development process.  In the case of a project with a data layer that is a dependency of the domain layer, it would be beneficial to name the data layer accordingly, such as “data” or “repository”.  

├── lib
| ├── posts
│ │ ├── bloc
│ │ │ └── post_bloc.dart
| | | └── post_event.dart
| | | └── post_state.dart
| | └── models
| | | └── models.dart
| | | └── post.dart
│ │ └── view
│ │ | ├── posts_page.dart
│ │ | └── posts_list.dart
| | | └── view.dart
| | └── widgets
| | | └── bottom_loader.dart
| | | └── post_list_item.dart
| | | └── widgets.dart
│ │ ├── posts.dart
│ ├── app.dart
│ ├── simple_bloc_observer.dart
│ └── main.dart
├── pubspec.lock
├── pubspec.yaml

Reusability in mind

The abstract declaration and concrete implementation approach used in the flutter_todos example from the bloc library is a good way to implement this type of solution. The abstract declaration provides a blueprint for the functionality needed, while the concrete implementation provides the specific details for how it is implemented. This allows for flexibility in adapting the functionality to different use cases while maintaining a consistent API interface.

Balance abstraction

Choosing between creating a repository with a direct dependency or creating an API wrapper for an external package will depend on various factors, including the complexity of the external package’s API, the number of dependencies it requires, and how well it meets the specific needs of the project.

If the external package has a clean and simple API that meets the needs of the project without requiring too many dependencies or configuration, then creating a repository with the package as a direct dependency may be the best approach. This can simplify the codebase and make it easier to maintain, as well as potentially provide better performance.

The chat_location  application provides a good example of how to use this package with a repository, demonstrating how the package can be integrated into the app’s architecture while keeping the repository code clean and maintainable.

In cases where an external package’s API is more complex, creating an API package with a class that wraps that dependency can be a better approach. This can provide a more streamlined interface for the specific needs of the project and abstract away some of the implementation details.

The spacex_demo application is a good example of how to create a custom API package, providing a wrapper for the SpaceX API. This approach allows for a more tailored interface for the project’s specific needs, while also providing flexibility and isolation from any potential issues with the external API.

Don’t over-engineer

Over-abstracting can increase complexity and development time without providing any real benefit.

If the project primarily uses JSON as its data format, then abstracting the base properties of the model to accommodate other formats may not be necessary. In this case, it may be more efficient to simply create the serialization/deserialization functionality for JSON and avoid over-abstracting the model.

However, if there is a possibility of the data format changing in the future, or if there are other reasons for needing a more abstracted model, then it may be worthwhile to invest the time and effort into creating a more flexible model architecture.

Packages: yes or no?

The decision to use packages should be based on the specific needs and constraints of the project. For a small project with a small team, the added complexity of using packages may not be worth the benefits. In this case, it may be more efficient to handle migrations and updates manually.

However, as the project grows and the team expands, the benefits of using packages become more apparent. Component isolation becomes more important as the project becomes more complex, and having different team members working on different parts of the project simultaneously becomes more common.

You can have one teammate migrating the accounting repository to Very Good Analysis 2.4.0 and another migrating the retail API to dio 4.0.0 at the same time, so you can tackle fixing lints and null safety refactors without stepping on each other’s toes.

Choose right tools

When choosing packages or tools, it’s important to have a set of criteria to evaluate them against:

  • Activity on the GitHub repository: a package that is actively being developed and maintained is more likely to be reliable and up-to-date.
  • pub.dev  metrics: pub.dev provides useful information such as the number of downloads, the number of dependent packages, and the percentage of code coverage. This information can help you evaluate a package’s popularity and usefulness.
  • Test coverage: packages with high test coverage are more likely to be reliable and less prone to bugs.
  • Who’s maintaining it: knowing who is responsible for maintaining a package can give you an idea of its reliability and longevity.
  • Other factors that are important to you and your team: this could include factors such as documentation, community support, or compatibility with other tools or packages you’re already using.

Follow best practices

Studying other developers’ repositories is an excellent way to learn and improve. Many open-source projects have an active community of contributors who can help you with any questions or issues you may encounter. 

Refactor

Refactoring is a natural part of the development process, and it’s important to recognize when something needs to be improved and not be afraid to make changes. Additionally, it’s important to maintain a positive attitude towards mistakes and failures, as they provide valuable learning experiences that can lead to growth and improvement. As the saying goes, “fail fast, fail often, fail forward.”

Welcome to our team!

If you are reading this article, then you are interested in the topic of structuring code. If you are ambitious, not afraid of difficulties, you have a lot of ideas, but a little lack of confidence and experience in your business – come to our team! 

Responsive layout article in Flutter

When developing a mobile application, ensuring the layout looks good on all screen sizes is important. In Flutter, there are several ways to implement a responsive layout. In this article, we will go through five different methods, starting with the simplest but with the lowest responsiveness and ending with the most complex one but with the highest responsiveness. By the end of this article, you will better understand how to create a responsive layout in Flutter.

Method 1: Strict layout with fixed sizes of widgets and SizedBoxes as paddings

This is the simplest method to implement a responsive layout in Flutter. This method uses fixed sizes for widgets and SizedBoxes as paddings. The layout looks good only for screens with the same dimensions as the design screen. However, if the actual screen size differs from the design screen size, the layout may not look better.

@override
 Widget build(BuildContext context) {
   return Scaffold(
     appBar: AppBar(
       title: const Text('Responsive Screen'),
     ),
     body: Padding(
       padding: const EdgeInsets.symmetric(horizontal: 16),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.stretch,
         children: const [
           SizedBox(height: 20),
           HeaderText(),
           SizedBox(height: 24),
           ProfileAvatar(),
           SizedBox(height: 16),
           NameText(),
           RoleText(),
           SizedBox(height: 16),
           AddressText(),
           SizedBox(height: 72),
           DescriptionText(),
           SizedBox(height: 24),
           ContactButton(),
           SizedBox(height: 24),
         ],
       ),
     ),
   );
 }

400×715 looks good

375×667 – bottom overflow

428×962 – bottom empty space

Method 2: Using MediaQuery to scale paddings and font sizes based on screen size

This method is more responsive than the first one. In this method, we use MediaQuery to scale paddings and font sizes based on the screen size. The layout looks good if the actual screen size is close to the design screen size. However, on small screens, the text may be hard to read on small screens due to the small font size, and on big screens, we still have empty bottom space because of different aspect ratios.

@override
 Widget build(BuildContext context) {
   const designHeight = 715.0;
   const designWidth = 400.0;
   final screenHeight = MediaQuery.of(context).size.height - MediaQuery.of(context).padding.vertical;
   final screenWidth = MediaQuery.of(context).size.width - MediaQuery.of(context).padding.horizontal;

   final scaleHeightFactor = screenHeight / designHeight;
   final scaleWidthFactor = screenWidth / designWidth;
   final scaleFontFactor = scaleWidthFactor;

   return MediaQuery(
     data: MediaQuery.of(context).copyWith(
       textScaleFactor: scaleFontFactor,
     ),
     child: Scaffold(
       appBar: PreferredSize(
         preferredSize: Size.fromHeight(kToolbarHeight * scaleHeightFactor),
         child: AppBar(
           title: const Text('Responsive Screen'),
         ),
       ),
       body: Padding(
         padding: EdgeInsets.symmetric(horizontal: 16 * scaleWidthFactor),
         child: Column(
           crossAxisAlignment: CrossAxisAlignment.stretch,
           children: [
             SizedBox(height: 20 * scaleHeightFactor),
             const HeaderText(),
             SizedBox(height: 24 * scaleHeightFactor),
             ProfileAvatar(radius: 32 * scaleWidthFactor),
             SizedBox(height: 16 * scaleHeightFactor),
             const NameText(),
             const RoleText(),
             SizedBox(height: 16 * scaleHeightFactor),
             const AddressText(),
             SizedBox(height: 72 * scaleHeightFactor),
             DescriptionText(
               padding: EdgeInsets.symmetric(
                 horizontal: 12 * scaleWidthFactor,
                 vertical: 12 * scaleHeightFactor,
               ),
             ),
             SizedBox(height: 24 * scaleHeightFactor),
             ContactButton(height: 50 * scaleHeightFactor),
             SizedBox(height: 24 * scaleHeightFactor),
           ],
         ),
       ),
     ),
   );
 }

400×715 looks good

375×667 – text is hard to read since the screen size is small

428×962 – bottom empty space

Method 3: Using Spacer widget to make flexible paddings

In this method, we use the Spacer widget to make flexible paddings. Layout looks good on almost all screens, but on tiny screens, the height of all widgets may be bigger than the screen height, and the bottom widgets may not be visible.

@override
 Widget build(BuildContext context) {
   return Scaffold(
     appBar: AppBar(
       title: const Text('Responsive Screen'),
     ),
     body: Padding(
       padding: const EdgeInsets.symmetric(horizontal: 16),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.stretch,
         children: const [
           SizedBox(height: 20),
           HeaderText(),
           SizedBox(height: 24),
           ProfileAvatar(),
           SizedBox(height: 16),
           NameText(),
           RoleText(),
           SizedBox(height: 16),
           AddressText(),
           SizedBox(height: 72),
           DescriptionText(),
           SizedBox(height: 24),
           ContactButton(),
           SizedBox(height: 24),
         ],
       ),
     ),
   );
 }

428×926 looks good

357×667 looks good

It appears to work well on both small and large screens; however, when implementing a responsive layout, it’s important to consider that users may increase the text scale in accessibility settings, which can cause each text widget to enlarge. Let’s do this to see what it looks like:

375×667 with text scale 1.5 – bottom overflow

Method 4: Using ListView to make a scrollable layout

In this method, we use a ListView to make the layout scrollable. We also replace Spacer with SizedBox to return fixed paddings since Spacer doesn’t work inside ListView. This method looks good on small screens, but on big screens, there is a lot of empty space at the bottom of the screen.

@override
 Widget build(BuildContext context) {
   return Scaffold(
     appBar: AppBar(
       title: const Text('Responsive Screen'),
     ),
     body: Padding(
       padding: const EdgeInsets.symmetric(horizontal: 16),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.stretch,        
         children: const [
           SizedBox(height: 20),
           HeaderText(),
           SizedBox(height: 24),
           ProfileAvatar(),
           SizedBox(height: 16),
           NameText(),
           RoleText(),
           SizedBox(height: 16),
           AddressText(),
           SizedBox(height: 72),
           DescriptionText(),
           SizedBox(height: 24),
           ContactButton(),
           SizedBox(height: 24),
         ],
       ),
     ),
   );
 }

357×667 with text scale 1.5 looks good

428×962 – bottom empty space

Method 5: Using CustomScrollView and Slivers

In this method, we use a CustomScrollView and Slivers to create a layout that is scrollable on small screens but has flexible space at the bottom on big screens. This method can be more complex but looks good on any screen size. The key to this approach is determining which parts of the layout should have a flexible or fixed size.

@override
 Widget build(BuildContext context) {
   return Scaffold(
     appBar: AppBar(
       title: const Text('Responsive Screen'),
     ),
     body: CustomScrollView(
       slivers: [
       SliverPadding(
         padding: const EdgeInsets.symmetric(horizontal: 16),
         sliver: SliverList(
             delegate: SliverChildListDelegate(
               const [
                 SizedBox(height: 20),
                 HeaderText(),
                 SizedBox(height: 24),
                 ProfileAvatar(),
                 SizedBox(height: 16),
                 NameText(),
                 RoleText(),
                 SizedBox(height: 16),
                 AddressText(),
               ],
             ),
           ),
         ),
         SliverFillRemaining(
           hasScrollBody: false,
           child: Padding(
             padding: const EdgeInsets.symmetric(horizontal: 16),
             child: Column(
               crossAxisAlignment: CrossAxisAlignment.stretch,
               mainAxisAlignment: MainAxisAlignment.end,
               children: const [
                 SizedBox(height: 72),
                 DescriptionText(),
                 SizedBox(height: 24),
                 ContactButton(),
                 SizedBox(height: 24),
               ],
             ),
           ),
         ),
       ],
     ),
   );
 }

357×667 with text scale 1.5 gets scrollable and looks good

428×926 looks good with flexible space in the middle

In this article, we have gone through five different methods of implementing responsive layout in Flutter. We started with the simplest method, which uses fixed sizes of widgets and SizedBoxes as paddings, and ended with the most complex method, which uses CustomScrollView and Slivers.

In conclusion, creating a responsive layout in Flutter is essential for providing a seamless user experience across various devices with different screen sizes. We have explored five different methods to achieve responsive layouts, each with its pros and cons. Choosing the right method depends on your specific application requirements and desired level of responsiveness.

To ensure a successful implementation, keep in mind the following tips:

  • Prioritize accessibility and test with different settings.
  • Test on multiple screen sizes. Some packages like device_preview can help to quickly change the screen size.
  • Use MediaQuery and textScaleFactor for scaling dimensions.
  • Implement flexible widgets like Spacer, Expanded, and Flexible.
  • Create scrollable layouts with ListView or CustomScrollView when necessary.
  • Avoid fixed-size containers for text content.

By following these guidelines and carefully evaluating the methods discussed in this article, you can create a responsive layout in Flutter that caters to a diverse range of users and devices. 
To check the source code for each method and test on various screens, please follow this repository.

Flutter 3.7 overview: TBR Group expertise

Flutter 3.7 is live! This release contains many updates and improvements. Although Flutter 3.7 was released in January 2023, there are already many blog posts and articles with an overview of the changes it brings. 

Is it really so that with a new release of Flutter 3.7 an open-source programming SDK has brought a more effective outcome compared to other tools for cross-platform development? We can confidently say “yes”.

Overviewing Flutter 3.7: TBR Group expertise

Flutter is a set of user interface tools that allow developers to build mobile, web, and desktop applications from a single codebase. 
The first releases of Flutter provided a set of user interface tools for creating mobile applications on Android and iOS on Windows, macOS, Linux, and the web. With Flutter 3.7, production support for these systems was expanded. 

This release adds new features to create your own menu bars, cascading menus, tools to better support internationalization, new debugging tools, and much more. Elements such as global selection, faster rendering with Impeller, DevTools, and, as always, performance, continue to evolve.
All this is surely going to help developers build more intuitive apps.


 
Let’s take a short trip together to explore the new features of Flutter 3.7 new release.

Support for Material 3 was greatly expanded in version 3.7 by porting the following widgets: Badge, BottomAppBar, Filled & Filled Tonal, SegmentedButton, Checkbox, Divider, Menus, DropdownMenu, Drawer & NavigationDrawer, ProgressIndicator, Radio, Slider, SnackBar, TabBar, TextFields & InputDecorator, Banner.

Anyone can use these new features by enabling the useMaterial3 flag in an application’s ThemeData widget. To fully use the M3, you will need the entire vibrant M3 color scheme. You can provide your own with the new theme creation tool, or Flutter can generate one for you from a single source color using the colorSchemeSeed parameter in the ThemeData constructor. 

Another important point is that now we can expand the menu, namely by adding menu bars and cascading menus.

It should also be emphasized that Impeller performance is likely to match or exceed that of the Skia renderer for most applications, and in terms of accuracy, the Impeller implements all but a few rarely used corner housings. 

Another advantage is iOS release validation. The Flutter new build ipa command now checks some of these parameters and informs you if there are changes that need to be made to your application before release.

You should pay attention to DevTools updates, as this release has several new tools features, and general improvements that you can gladly try out.

With the introduction of the Custom context menus, it is now possible to create custom context menus anywhere in the Flutter application.

Thanks to the scrolling Improvements, all macOS apps will now run with higher fidelity with the addition of new scrolling physics to match the desktop platform.

Looking at internationalization tools and documents, It should be noted that Flutter has completely rewritten the gen-l10n tool for all platforms to support descriptive syntax errors and complex messages involving nested/plural plurals, samples, and placeholders.

Swift migration for plugins offers new links for migration or creation of new plugins using Swift.

Another important point is Bitcode deprecation — Flutter applications do not have bitcode enabled, and this isn’t expected to affect many developers.

With regard to memory management, it is important to note that the collective effect is reducing the noise caused by garbage collection pauses, reducing CPU usage due to allocation speed and background GC threads, and reducing memory capacity.

With custom shader support improvements item, Flutter new has extended support for custom snippet shaders. It’s time to add rave effects to your apps and enhance the user experience to the fullest.

Thanks to reducing animation jank on iOS devices, users should notice more consistently smooth animations on 120Hz iOS devices.

The developers of Flutter 3.7 release do not stop there, already boldly offering a preview of the next wave of innovations that they are already developing and implementing in Flutter new, which include: revolutionary graphics performance, seamless integration for the web and mobile devices, early support for new and emerging architectures and a constant focus on the developer experience. 

And we at TBR Group are ready to implement these innovations to our customers.

Flutter 3.7 developers are gradually showing off their work, which will already be available in the coming months. They impeccably hope that consumers will be even more satisfied with Google Flutter as a powerful toolkit for any developer who wants to create high-quality, beautiful user interfaces that can be applied in any area.

The Flutter ecosystem continues to expand very actively, such as FlutterFlow, a low-code builder for developing native mobile apps, and Widgetbook, which provides designers and developers with flexible tools for collaborative UI development.

TBR Group — a provider of mobile app development services

We’re TBR Group, and we help startups and established businesses evolve through design and development and overcome emerging challenges. We’ll give your product idea an efficient shape and functionality.

Our business approach follows the best industry practices. We build bespoke, well-designed, and feature-rich Flutter mobile applications for both iOS and Android. 

Our expertise covers, but is not limited to telemedicine, healthcare, music, and social network apps. We are always open to new horizons. 
Our target audience includes startups and established businesses of any size and type.

Our solutions address real problems and improve your vital business metrics through beautiful interfaces. When we say “beautiful”, we mean functional, accessible, and intuitive. The product may be completed, but the cooperation is never finished. 

We offer post-launch support and maintenance to help clients continually improve the quality and enlarge the scope of their products. We’re for long-term collaboration.

Our team has already tested Flutter 3.7 too and, based on our experience, we can safely say that this new version will be beneficial both for developers and their clients.

Just like all previous versions, this one brings fresh design elements and tools, which may be helpful in certain dev situations. We’ll be able to share more insights with you soon. Stay tuned!

Summary

So, Flutter 3.7 update contains a weighty range of the latest features and improvements that can help developers create more efficient, vibrant, colorful, and actionable applications.

New features are closely related to issues such as accessibility, localization, and performance. They can ensure that applications built with Flutter can be absolutely easily helpful and used by a significant number of users, regardless of their ability or location, wherever they are.

Besides, the inclusion of Dart 3 will make it easier for developers to test and iterate their code.

Hiring Flutter app developers in 2024: tips and tricks

Intro

Medicine, shopping, banks, music, babysitting services, and pet care — these are just a few market areas where the platform-independent technology Flutter has recently been growing its tremendous rise.

In gaining popularity, Flutter has been at the top over the past six months in Google Trends stats.

Google Trends “Explore what the world is searching for” page.

Flutter has been an amazingly viral topic in the software development community since its official launch in 2018.

TBR Group is going to share some insights on recruiting a Flutter developer. Mainly, we will elaborate on the following:

  • how to hire Flutter developers;
  • which questions could be asked during the job interview;
  • basic Flutter developer requirements;
  • core Flutter developer responsibilities.

As qualified Flutter app developers are scarce, the best practices applied to hire experienced specialists become highly fundamental.

Who is a Flutter app developer?

A Flutter developer — who is this guy? Is this person a computer geek harnessing the power of Flutter and Dart? Well, that’s true.

The Flutter developer is a software engineer who builds platform-independent software programs using the Flutter and Dart bundle.

For more of Flutter features, we are happy to offer our articles:
The fundamentals of Flutter & Dart, and Why choose Flutter for mobile app development in 2022?
Hands-on experience
Qualification-wise, a Flutter developer may demonstrate a track record as follows:

  • a junior or trainee is a newcomer to the industry or a freshman in the company;
  • Flutter engineers with 2-4 years of working knowledge can be considered middle-level developers;
  • senior Flutter and Dart developers are those geeks with more than four years of hands-on experience in the industry.

Flutter developer responsibilities
Flutter engineers could deal with the following:

  • creation of multi-platform apps for iOS and Android using the Flutter development framework;
  • work in a bundle with back-end developers, designers, and the engineering team to deliver well-architected and high-quality solutions;
  • advocate for engineering standards.

So, developers work day and sometimes night to deliver beautifully designed, user-friendly, and highly operational Flutter-crafted mobile apps.

How to hire an experienced Flutter developer

Due to the growing market demand for platform-independent software, app developers in Flutter are of special job relevance.

The openings for a Flutter developer are acutely felt both in start-ups and the technologically advanced company.

Chances are for a developer to get on-boarded by a start-up and accelerate professional growth due to the still-developing corporate and operational rules, procedures, and regulations.

On the other hand, at all times, in a mature company, there is an opportunity to learn quickly inside an already qualified and skilled team working both alone and as a team player.

Speaking of the Flutter developer requirements, here is a list of basic nice-to-have skills for a Flutter software engineer.

Flutter developer requirements

Hard skills:

  • experience in front-end development;
  • experience in building mobile apps in Flutter and Dart;
  • working knowledge of the general mobile landscape, architectures, trends, development lifecycles, including building and automated testing, emerging technologies;
  • solid understanding of mobile app design guidelines like BLoC, MVC, Redux, Singleton, Factory, Delegation, or other patterns;
  • Android Material Components, Cupertino layouts, and awareness of their differences;
  • proficiency in using GitHub, Bitbucket, or similar version control and continuous integration tools.

Soft skills:

  • excellent verbal and written communication skills;
  • self-starter, proactive in resolving issues and removing roadblocks;
  • willingness to learn and improve.

Additional preferred skills:

  • Swift, Objective-C, Java, Dart, or Kotlin;
  • AWS;
  • code review processes;
  • CI/CD;
  • REST, JSON
  • Experience with third-party libraries and APIs.

For app developers aiming to strive professionally, a fast, agile, and multi-functional team environment may appear as a relevant and proper solution.

Flutter interview questions
Briefing on the interview procedure, here comes an outline exemplifying variable interview questions, both verbal and written.

So, you can ask a potential candidate:

  • In which ways could you possibly implement the Skia Graphics Engine into the Flutter-based project?
  • What would you build with widgets?
  • How would you craft stateless and stateful conditions?
  • Tell us what you know about the Dart virtual machine.
  • How could you prove a freshly embedded feature functioning in the designated way?
  • What third-party software tools have you managed to integrate into your Flutter project?
  • Could you please describe your work experience in Dart asynchronous programming?
  • Have you ever implemented a “JavaScript bridge” in the Flutter development piece?
  • What is BLoC Flutter? What approaches for managing various states of the application have you dealt with?
  • Could you please articulate your background in using method channels to invoke native API knowledge?
  • Could you please speak about the usage of tools and techniques related to: code analyzers, layout inspector, performance and memory view, multithreading, networking, and security choices.

Familiarity with the Agile approach is essential. At the same time, the waterfall model may seem a more suitable alternative for a large-scale plan.

All the candidates might be expected to have previously built a complete app using the Flutter tool set and to communicate the app-building process with the in-house team engineers.

TBR Group’s assistance

Our article on Writing a Flutter Web plugin with JavaScript: a step by step guide can appear valuable for enlarging the personal practical tips asset.

Look through these Flutter apps built by TBR Group:

  • Neural Reader is a Text-To-Speech audio reader, and Speech-To-Text transcribing tool;

Neural Reader Flutter mobile app: “Audio Player”, “My Library / Convert from” and “Audio speed” pages.

  • VinciLabs mobile app aimed at handling health care data received by doctors from the patient’s digital medical devices;

VinciLabs mobile app: the onboarding “Mission, Vision, Values”, “Blood pressure” and “Customized Standalone Application” sections.

  • Śpiewnik Wywroty Flutter mobile app allows its users to dive into the music world with more than 25,000 guitar songs and ukulele arrangements;

Wywroty Songbook Flutter mobile app: “Start”, “Search” and “Popular” pages.

  • SwishBOOM Flutter mobile app ensures safe and sound cooperation between the children’s families and babysitters;
  • pingNpay is a micropayment Flutter mobile app. It makes certain money transfers encrypted and well-secured throughout the entire money transfer process.

pingNpay mobile app: “Home”, the onboarding page “Pay” and “Scan QR Code” pages.

Consequently, our Cases page, describing challenges and solutions, may be used as an auxiliary means of getting trained for a job interview.

Where to hire Flutter developers

A Flutter engineer can be hired as an in-house team player. There are likewise Flutter jobs remote offerings.

So, a Flutter developer can be applied as: a freelance programmer, a team player of the outstaffing model, a software engineer in the dedicated team.

More to the Pros and cons of dedicated teams for mobile app development you can read in our Blog section.

Having chosen a model of how to get the mobile app crafted, it is necessary to pick up one particular dedicated team to fulfill the project.

It is possible to search for an appropriate vendor on a number of B2B platforms, such as TopTal and Upwork.

Visiting the software implementation company’s website and tracking down the rate scores, alongside with previously received clients’ reviews, will give you an idea of the company’s business image.

The websites like G2 and Clutch largely represent the aforementioned data.

It’s up to a business owner to decide on any of these cooperation options, depending on the: goals to achieve, project scale, time to project launch deadline, and money to pay off.

Salary
Flutter developers’ hourly rate varies geographically. Depending on the programmer’s qualification level — junior, middle, senior — and type of employment, the average numbers are the following can vary from: Eastern Europe $40–60 and USA $100–200.

The rate differ by type of employment, and hands-on experience.

Summary

TBR Group is a Ukrainian-based software development company. We specialize in app development with Flutter and Dart.

Template generation with Mason : TBR Group experience

1. Template Generation in Flutter.

Code generation allows you to speed up and make the development more convenient by generating ready-made pieces of a code.

This can be used to preset the architecture of an application, for example. If you want to use the wedge architecture pattern, then you will have to spend a lot of time creating all the folders and files.

Template generation will save you this time and enable you to jump right into the development with a quick start.

Also, template generation helps not only with the architecture setup, but also speeds up the development itself.

For example, we used template generation to automatically create repositories to save time and make developers create unit tests for their code, since our template, together with the repository, creates a template with tests for this repository in the test directory.

There are a large number of approaches to generating templates in Flutter, we chose Mason package, because it is the most popular, constantly developing and improving package, which also has its own hub containing bricks (templates) that can be used with this package.

2. About Mason package

Mason is a Flutter code generation tool that helps developers create reusable code blocks, called “bricks”, for their Flutter projects.

These bricks can contain any type of code, from UI elements to business logic, and can be easily imported into any Flutter project using the Mason command line interface (CLI).

One of the main benefits of using Mason is that it allows developers to easily share their code with others, making it easier for teams to collaborate and reuse the code.

Additionally, Mason makes it easy to create and manage code templates, which can save developers a lot of time and effort when starting new projects or adding new features to existing ones.

Using Mason and the Brickhub can provide a number of benefits for Flutter developers, including:

  • Time saving: By using reusable bricks, developers can save a lot of time and effort when starting new projects or adding new features to existing ones.
  • Improved collaboration: Mason makes it easy to share bricks with others, which can improve collaboration within a team and make it easier to reuse code.
  • Consistency: Using a common set of bricks can help to ensure that projects have a consistent look and feel, which can be especially useful for larger projects or teams.
  • Increased efficiency: By using Mason, developers can focus on more important aspects of their projects, rather than spending time writing a boilerplate code.

Overall, Mason and the Brickhub provide a powerful tool for Flutter developers looking to save time and improve their workflow. Whether you’re a seasoned developer or just starting out, Mason can help you create high-quality, reusable code for your Flutter projects.

3. How to install Mason

Official documentation recommend installing mason_cli from pub.dev

# 🎯 Activate from https://pub.dev
dart pub global activate mason_cli

Alternatively, mason_cli can be installed via homebrew

# 🍺 Install from https://brew.sh
brew tap felangel/mason
brew install mason

Once you have successfully installed the mason_cli you can verify your setup by running the mason command in your terminal. If mason_cli was installed correctly, you should see something similar to the following output:

🧱 mason • lay the foundation!
Usage: mason <command> [arguments]
Global options:
-h, --help Print this usage information.
--version Print the current version.
Available commands: ...

4. How to install Mason

We will describe how to create your own break using as example our simple_repository brick.

Use this command to create the new brick:

mason new simple_repositoty

It will create a new, custom brick template in the current working directory.

5. Detail

It should generate such file structure:

├── CHANGELOG.md
├── LICENSE
├── README.md
├── __brick__
└── brick.yaml

The brick.yaml file is a manifest which contains metadata for the current brick. The newly generated brick.yaml should look something like:

name: simple_repository
description: Brick for the simple creating repositories and tests for them.
repository: https://github.com/TBR-Group-software/simple_bricks/tree/main/bricks/simple_repository
version: 0.1.0+2
environment:
mason: ">=0.1.0-dev.26 <0.1.0"
vars:
repository_name:
type: string
description: Repository Name
default: Dash
prompt: What is your repository name?

The __brick__ directory contains the template for your brick. Any files, directories within the __brick__ will be generated when the brick is used via mason make.

In the example brick, our __brick__ directory contains a such files structure:

├── __brick__
│ ├── lib
│ │ ├── {{repository_name.snakeCase()}}
│ │ │ ├── {{repository_name.snakeCase()}}_repository
│ │ │ │ └──{{repository_name.snakeCase()}}
_repository.dart
│ │ │ └──api_{{repository_name.snakeCase()}}
_repository
│ │ │ └── api_{{repository_name.snakeCase()}}
_repository
│ │ └── {{repository_name.snakeCase()}}.dart
│ ├── test
│ │ └── repositories
│ │ └── {{repository_name.snakeCase()}}
_repository_test.dart
└── └──

Templates currently support only Mustache syntax, we will create our template using it.

Mason supports a handful of built-in lambdas that can help with customizing generated code:

NameExampleShorthand SyntaxFull Syntax
camelCasehelloWorld{{variable.camel
Case()}}
{{#camelCase}}{{varia
ble}}{{/camelCase}}
constantCaseHELLO_WORLD{{variable.constant
Case()}}
{{#constantCase}}{{vari
able}}{{/constantCase}}
dotCasehello.world{{variable.dot
Case()}}
{{#dotCase}}{{variable}}
{{/dotCase}}
headerCaseHello-World{{variable.header
Case()}}
{{#headerCase}}{{vari
able}}
{{/headerCase}}
lowerCasehello world{{variable.header
Case()}}
{{#lowerCase}}{{variable}}
{{/lowerCase}}
mustacheCase{{ Hello World }}{{variable.mustache
Case()}}
{{#mustacheCase}}{{variable}}{{/mustacheCase}}
pascalCaseHelloWorld{{variable.pascal
Case()}}
{{#pascalCase}}{{variable}}
{{/pascalCase}}
paramCasehello-world{{variable.param
Case()}}
{{#paramCase}}
{{variable}}{{/param
Case}}
pathCasehello/world{{variable.pathCase()
}}
{{#pathCase}}
{{variable}}{{/path
Case}}
sentenceCaseHello world{{variable.sentence
Case()}}
{{#sentenceCase}}{{variable}}{{/sentenceCase}}
snakeCasehello_world{{variable.snake
Case()}}
{{#snakeCase}}
{{variable}}
{{/snakeCase}}
titleCaseHello World{{variable.titleCase()}}{{#titleCase}}
{{variable}}{{/titleCase}}
upper CaseHELLO WORLD{{variable.upper
Case()}}
{{#upperCase}}
{{variable}}{{/upperCase}}

{{repository_name.snakeCase()}}_repository.dart file:

abstract class {{repository_name.pascalCase()}}Repository {}

{{repository_name.snakeCase()}}_repository.dart file:

/// {@template api_{{repository_name.snakeCase()}}repository} /// [{{repository_name.pascalCase()}}Repository] /// {@endtemplate} 
class Api{{repository_name.pascalCase()}}Repository extends {{repository_name.pascalCase()}}Repository { /// {@macro api{{repository_name.snakeCase()}}_repository} 
}

{{repository_name.snakeCase()}}.dart file:

export 
'api_{{repository_name.snakeCase()}}_repository/api_{{repository_name.snakeCase()}}_repository.dart';
export
'{{repository_name.snakeCase()}}_repository/{{repository_name.snakeCase()}}_repository.dart';

{{repository_name.snakeCase()}}_repository_test.dart file:

import 'package:flutter_test/flutter_test.dart';

void main() {
group("Testing {{repository_name.pascalCase()}} Repository", () {
//TODO: implement the tests

setUp(() {});
test("Test method", () {});
});
}

6. How to publish brick to the Brickhub

To publish a brick to the Brickhub using Mason, you will first need to sign up for an account on the Brickhub website.

To do this, you will need to request access to the site, and then follow the instructions in the email invite to sign up and verify your email.

Once you have an account, you can log in to the Brickhub using the mason login command.

This will prompt you to enter your email and password, and once you have successfully logged in, you will be ready to publish your brick. To publish a brick, you will use the mason publish command, followed by the –directory option and the path to your brick’s directory.

For example:

mason publish --directory ./my_brick

This will start the process of publishing your brick to the Brickhub.
You will be prompted to confirm that you want to publish the brick, and once you confirm, the brick will be bundled and published to the Brickhub.

It’s important to note that you will need to be logged in to an account in order to publish a brick to the Brickhub.

Overall, publishing a brick to the Brickhub is a straightforward process that can be accomplished quickly and easily using the Mason CLI.
By making your bricks available on the Brickhub, you can share them with other Flutter developers and save time and effort when working on your projects.

7. Hooks

Mason supports Custom Script Execution so called hooks.

These hooks are defined in the application’s configuration and can be executed before or after certain events occur, such as the generation of code or the rendering of templates.

Currently, Mason only supports hooks written in the Dart programming language.

These hooks are defined in the hooks directory at the root of the brick and must contain a run method that accepts a HookContext from the package:mason/mason.dart library

There are two types of hooks available in Mason: pre_gen and post_gen, which are executed immediately before and after the generation step, respectively.

These hooks can be used to perform tasks such as logging, modifying the brick variables, or interacting with the logger.

For example, hooks for running dart formatting.

Future<void> _runDartFormat(HookContext context) async {
final formatProgress = 
context.logger.progress('Running "dart format ."');
await Process.run('dart', ['format', '.']);
formatProgress.complete();
}

Future<void> _runDartFix(HookContext context) async {
final formatProgress = 
context.logger.progress('Running "dart fix --apply"');
await Process.run('dart', ['fix', '--apply']);
formatProgress.complete();
}

8. What benefits we have got

Using Mason templates has provided a number of benefits for our development process, including:

  • Faster development: By generating ready-made pieces of code, we were able to speed up development and jump right into creating new features or working on existing ones. This saved us a lot of time and allowed us to focus on more important tasks.
  • More structured code: Using Mason templates helped us create a more structured and organized codebase, which made it easier to maintain and scale our projects. We were able to create a consistent structure for our code, which made it easier for new developers to understand and work with.
  • Forced developers to write unit tests: One of the benefits of using Mason templates is that they can be customized to include certain requirements or best practices. In our case, we used templates to force developers to write unit tests for their code, which helped us to ensure that our code was well-tested and of high quality.

Overall, using Mason templates has helped us to improve the efficiency and quality of our development process, and has made it easier for us to create and maintain high-quality code for our Flutter projects.

Native vs cross-platform app development: what to choose in 2023?

There are questions a mobile app engineer encounters each and every time and has to query about before starting off to write any software product.

How to transform a given idea into a viable market product?
Would it be far better to opt for a cross-platform framework instead of picking up the native development scheme?

For a business owner, there is a dilemma as well. How to create a competitive product in the most economically profitable and time-saving way?

It goes without saying that in either case, the product at the outlet must be of a high programming standard.

So, native vs cross-platform? As each of them can be used to serve different objectives. The competition is tough.

And in the “Interest over time” search queries in Google Trends, cross-platform development has gained popularity over the native model.

Google Trends “Explore what the world is searching” page.

Just as well, both Flutter and React Native have ranked at the top among the most frequently used libraries and frameworks in 2023 in Statista.

Is there a real dilemma native vs cross-platform development?

As both approaches do have their benefits and limitations, we would like to do an overview of these models.

Mobile application development falls into:

  • web
  • native
  • cross-platform / platform-independent:

– hybrid

– native.

Native implies building different mobile app versions for the iOS operating system and Android platform. So:

  • iOS supports Swift and Objective-C as the programming languages;
  • whereas those intended for native Android are based on Java or Kotlin.

The cross-platform approach in mobile programming includes a set of technological solutions as well. Such as:
The Ionic and Cordova frameworks belong to the hybrid cross-platform mobile application development.
React Native, Native Script and Flutter represent the native approach.

Let’s say a few words about web mobile solutions. The apps are coded with HTML, CSS, and JavaScript programming language.

Without having to be installed, the apps are available on all platforms and run directly in browsers of mobile devices. This option is a perfect choice for simple software products.

Native approach

With the totally distinguishable native code base and distinctive UI design elements, these applications demonstrate the highest efficiency in operation.

Advantages:

  • high performance;
  • better user interfaces;
  • an ability to use all the features of mobile devices;
  • intuitive user interface and user experience.

Disadvantages:

  • a pricier solution;
  • posing more challenges in communication and collaboration in teams;
  • hardly going to help implement the same logic of both iOS and Android apps.

Cross-platform/platform-independent approach

Advantages:

  • economically profitable/cost-effective;
  • shareable code base;
  • shared logic;
  • possibly similar UI and user experience;

Disadvantages:

  • possible performance issues;
  • a bit low operational flexibility;
  • UI inconsistencies, etc.

In native cross-platform app development, Flutter and Dart bundle plays a major role.

Flutter offers different models, tools, and patterns for implementing the logic of an app and delivering the relevance of the inquiries.

Hence, the stakeholders are welcome to take an advantage of:

  • a rapid market period;
  • a simpler process of the MVP creation;
  • a payment compensation plan;
  • utilizing in multiple market niches;
  • a shareable code base
  • a low learning curve for a software engineer.

In conclusion

You should choose a native approach if the application is a complex and resource-intensive one, intended to perform heavy calculations. In this case, you should be prepared for an obviously long time-market period, and for high development costs.

You can also aim to

  • relatively quickly, create a stable MVP version of the product;
  • get a scalable application;
  • obtain one shareable code-base;
  • save on expenses and time.

In this scenario, you should go for a native / hybrid cross-platform option.

For entrepreneurs, it would be advisable to opt for a dedicated development team to get the mobile app crafted. We have an article: “Pros and cons of dedicated teams for mobile app development” articulating this topic.

If you feel like being provided with extra details on this relatively new, however famous tool set, you are invited to visit our Blog page.

Cross-platform mobile app development with Flutter: TBR Group’s experience

TBR Group has focused on cross-platform framework programming, rather than picking up an option of native development.

Having completed software implementations with Flutter and Dart, we feel certain to highlight the benefits being offered by the native cross-platform app development.

We have applied Flutter cross-platform to program mobile apps for various intended purposes and market sectors. Such as

  • baby care babymates;
  • babysitting network Swishboom;
  • veterinary Vetsie;
  • digital payment pingNpay;
  • online medicine VinciLabs;
  • productivity/work Neural Reader;
  • music Wywroty Songbook.

Below goes a description of some of them.

VinciLabs is a healthcare mobile app built with Flutter.
The app has been designed to transfer data received from the patient’s devices to the health care providers.

The devices could range as follows:

  • a pulse oximeter;
  • a blood glucose monitor;
  • a blood pressure measurer;
  • other similar devices.

Hence, after being received, medical records are kept and elaborated by the health care organization.

VinciLabs mobile app: “Blood Pressure”, “Measure” and “Take a picture” pages.

VinciLabs enables users to

  • send a photo with measurements;
  • proceed with the optical character recognition option;
  • organize statistical data for a display in the form of charts and graphs;
  • notify the doctors about higher or lower-than-normal indicators;
  • insert indicators manually;
  • create a user’s profile;
  • get help in the FAQ section.

Vetsie is a veterinary application designed in 2 versions:

  • for the pet parent;
  • for the veterinary staff.

Vetsie mobile app: “Book Consultation”, “Book and Pay” and “Add Vets” pages.

Users can favor from the following functionalities:

  • user authentication;
  • video and audio calls;
  • push notifications;
  • chat, text, and voice messages;
  • subscription;
  • payment opportunities;
  • history of interactions;
  • etc.

pingNpay relates to the sphere of digital payments. Designed for all those willing to process the smallest donations, it allows up to £20 payment in one go.

As blockchain technology has been implemented, these small online payments have been made profitably available to users without increasing security risks.

pingNpay mobile app: “Home” and “Home/History” pages.

pingNpay makes it possible for users to:

  • have a quick onboarding;
  • choose QR codes for making payments;
  • have a list of contacts;
  • store the transaction history;
  • indicate the payment due date;
  • work out payment requests.

babymates is a mobile application designed for dads on how to be a father in the most exciting way. babymates is built to digitally connect dads with the service created.

There is user authentication, and it is possible to set up a member profile and join the community.

Babymates mobile app: “Start” and “Chat” pages.

The users can take advantage of the following features:

  • user’s profile;
  • building a personal network;
  • sharing photos;
  • online chat;
  • map integration;
  • events;
  • contact form;

The dad joke generator section will ensure a good mood for the rest of the day.

Wywroty Śpiewnik is a musical application, containing around 25,000 guitar and ukulele arrangements of Polish and internationally famous songs.

Wywroty Śpiewnik mobile app: “Start”, “Lyrics and notes of the song” and “Popular” pages.

Wywroty Śpiewnik allows users to:

  • authorize into the user account via Facebook, Google account, or Apple ID credentials;
  • create a list of favorite songs;
  • search for singles;
  • active Day/Night mode;
  • benefit from Google Ads.

In every case, TBR Group aimed to ensure a smooth workflow of the app for each user. So that the users could feel comfortable running the interface alongside the variety of functionalities.

You are invited to our Case study page to obtain more details on the peculiarities and challenges we had to overcome.

Summary

TBR Group is a Ukrainian software development company. Our activity is centered around platform-independent mobile app programming with Flutter and Dart.

We have chosen Flutter cross-platform because it allows creating fast, reliable, and scalable and powerful software products, with a stable MVP version of the application.

Our track of implemented mobile solutions can exemplify the potential of the technology, as well as our expertise in it.

You are welcome to get connected to TBR Group and to communicate the objectives of your existing or future product with our team. Feel free to contact us at your convenience and in any timely manner of yours.

Using Flutter BLoC pattern: TBR Group experience

MVC, MVP, MVVM, Vanilla, Scoped Model, and BLoC Flutter… These are the architectural patterns, the models, which appear to be rather popular among software engineers nowadays.

But what type of mobile app structural organization to choose and which approach to the architecture should be applied?

This article will be centered around the practical approach of BLoC pattern implementation to the mobile crypto app niche.

The ABC of Flutter BLoC pattern

Being a declarative framework, Flutter implies using one of the state management approaches to build the UI and therefore reflect the current state of the application.

Flutter BLoC can be specified as a state management system belonging to the family of stream/observable-based patterns.

The main advantage of state management: it helps the developer to separate business logic from the presentation layer. It makes the codebase more clear, reusable and indepenend.

Key pros of BLoC over other state management models:

1. It’s a very popular state management system, and, as a result, there is big amount of live projects and a big dev community who is willing to share their experience.

2. It comes with easy-to-understand and well-detailed documentation. It contains lot’s of examples helpful to kick-start with BLoC.

3. Frequent updates and regular support from the authors.

4. It has the extension for Android Studion and VSCode that speed up the development process

We’re going to expand the topic, by articulating more practical aspects of this technology.

Using Flutter BloC for developing mobile apps: TBR Group’s case study

You can freely find the bitty official documentation and tons of info concerning the topic on the web.

But alongside such a diversity of information, there’s a lack of real case studies and Flutter BLoC examples.

We are going to demonstrate the BLoC pattern in action on the example of a single use case — a Crypto Aggregator mobile app.

Crypto Aggregator is a mobile app designed to browse through cryptocurrencies and market data.

The users can check how the data is changing with the help of the line and pie charts.

The Crypto Aggregator’s settings screen provides its users with a set of features allowing them to switch:

  • the fiat currency;
  • between the night and day mode;
  • the language of the application.

The Crypto Aggregator mobile app: the “Settings” page.

While implementing the BLoC pattern, the first step is to determine the states and events classes.

State implies the output data. Actually, the state class will represent what a user will see on the screen.

Event is the input data for the BLoC. It can act either as a trigger to start loading data. Or it can represent any actions performed by the user, such as pressing a button, a text input, a page scrolling, and so on.

The “state” class describes such finals as status, fiatCurrency, themeType, and error.

The “state” class describes such finals as status, fiatCurrency, themeType, and error.

@immutable
class SettingsState {
 final BlocStatus status;
 final String? fiatCurrency;
 final ThemeType? themeType;
 final Object? error;
 const SettingsState(
   this.status, {
   this.fiatCurrency,
   this.themeType,
   this.error,
 });
}
 
enum ThemeType {
 day,
 night,
}

Respectively:

  • status can be in a “Loading”, “Loaded” or “Error” state in order to show the loader, the loaded data, or an error message on the screen.
  • fiatCurrency is the currency selected by users from the dialog. The monetary value of the cryptocurrencies is shown according to that parameter.
  • themeType is the enum presented with 2 values: “day” and “night”. Changing this parameter updates the dark/light mode of the app.
  • error implies the data used to show the error message on the screen. Typically, it is merely a string and in case no errors occur, the field remains null.

As the language change with BLoC is covered by the “easy_localization” package, we have not handled it in the current implementation.

The “event” is shown in the picture below.

@immutable
@freezed
abstract class SettingsEvent with _$SettingsEvent {
 const SettingsEvent._();
 
 const factory SettingsEvent.getFiatCurrency() = GetFiatCurrencyEvent;
 
 const factory SettingsEvent.selectFiatCurrency(String fiatCurrency) =
     SelectFiatCurrencyEvent;
 const factory SettingsEvent.getTheme() = GetThemeEvent;
 
 const factory SettingsEvent.selectTheme(ThemeType themeType) = SelectThemeEvent;
}

The event is built with help of the “freezed” package. There are:

  • getFiatCurrency renders an event to load the currently selected currency.
  • selectFiatCurrency stands for an event that is called when a user selects a particular currency.
  • getTheme indicates an event to load the currently selected theme.
  • selectTheme refers to the event called when a user selects a particular theme.

As soon as the event and state are completed, we continue with the Settings BLoC class implementation as displayed on the screenshot.

class SettingsBloc extends Bloc<SettingsEvent, SettingsState> {
 final GetFiatCurrencyUseCase _getFiatCurrencyUseCase;
 final SelectFiatCurrencyUseCase _selectFiatCurrencyUseCase;
 final GetThemeUseCase _getThemeUseCase;
 final SelectThemeUseCase _selectThemeUseCase;

As the project is built with Clean Architecture, BLoC contains four use cases for each action.

 SettingsBloc(this._getFiatCurrencyUseCase, this._selectFiatCurrencyUseCase,
     this._getThemeUseCase, this._selectThemeUseCase)
     : super(
         const SettingsState(
           BlocStatus.Loading,
         ),
       ) {
   on<GetFiatCurrencyEvent>(_getFiatCurrency);
   on<SelectFiatCurrencyEvent>(_selectFiatCurrency);
   on<GetThemeEvent>(_getTheme);
   on<SelectThemeEvent>(_selectTheme);
 }

The BLoC constructor contains the initialization of the use cases and the initial state. The initial state can work as loading, which is the first state the users encounter, and the event handlers, which are extracted in separate methods.

Future<void> _getFiatCurrency(
   GetFiatCurrencyEvent event,
   Emitter<SettingsState> emit,

 ) async {
   emit(_loadingState());
   emit(await _getFiatCurrencyUseCase()
       .then(
         (String fiatCurrency) => SettingsState(
           BlocStatus.Loaded,

           fiatCurrency: fiatCurrency,

           themeType: state.themeType,

         ),

       )
       .catchError(_onError));
 }

Let’s take a look at the callback triggered on the GetFiatCurrency event. Initially, we emit the loading state to show the loader indicator. Just after the data is loaded, the new state appears. It contains the newly loaded fiat currency as well as the current theme type. To handle the errors, we catch them by means of using the _onError method.

Future<void> _selectFiatCurrency(
   SelectFiatCurrencyEvent event,
   Emitter<SettingsState> emit,
 ) async {
   emit(_loadingState());
   emit(await _selectFiatCurrencyUseCase(event.fiatCurrency)
       .then(
         (String fiatCurrency) => SettingsState(
           BlocStatus.Loaded,
           fiatCurrency: event.fiatCurrency,
           themeType: state.themeType,
         ),
       )
       .catchError(_onError));
 }

Now, let’s explore the callback triggered by the SelectFiatCurrency event. The algorithm is mostly the same as the on “_getFiatCurrency” method. The only difference lies in the fact that the fiat currency on the loaded state is received from the event.

SettingsState _loadingState() => SettingsState(BlocStatus.Loading,
     fiatCurrency: state.fiatCurrency, themeType: state.themeType);
 
 Future<SettingsState> _onError(Object error) async => SettingsState(
       BlocStatus.Error,
       fiatCurrency: state.fiatCurrency,
       themeType: state.themeType,
       error: error,
     );

_loadingState and _onError methods help to simply create the error and respectively loading states.

The last step is to integrate the SettingsBloc into the app screen. To meet such a purpose, flutter_bloc provides a particular list of widgets.

The default widget is BlocBuilder. However, we use BlocSelector on this screen, since it allows us to focus on particular fields. Thus, if a user updates the fiat currency, there is no reason to rebuild the Day/Night mode switcher.

At first, comes the BLoC initialization.

 final SettingsBloc settingsBloc = di.sl.get();

 
 @override
 void initState() {
   super.initState();
   settingsBloc.add(const SettingsEvent.getFiatCurrency());
 }

Before the page is built, we need to add SettingsEvent.getFiatCurrency to load the selected fiat currency. In the project, we use get_it for the BLoC dependency injection, but the more usual way is to use BlocProvider.

Next comes the fiat currency switcher.

GestureDetector(
   onTap: () async {
     final String? selectedCurrency =
         await showBottomSheetCurrencySelector(
             context: context);
     if (selectedCurrency != null) {
       settingsBloc.add(
           SettingsEvent.selectFiatCurrency(selectedCurrency));
     }
   },
   child: Row(
     children: <Widget>[
       BlocSelector<SettingsBloc, SettingsState, String>(
         bloc: settingsBloc,
         selector: (SettingsState state) =>
             state.fiatCurrency ?? '-',
         builder: (BuildContext context, String fiatCurrency) {
           return Text(
             fiatCurrency.toString().toUpperCase(),
             style: TextStyles.overlay3Bold14,
           );
         },
       ),
       SizedBox(width: 4.w),
       const ChevronIcon(),
     ],
   ),
 ),

As soon as a user selects the currency from the bottom sheet, we need to send it to the BLoC wrapped with the SettingEvent.selectFiatCurrency event.

On the selector method, we are able to receive the required data. If the string returned from the selector method changes, everything inside the builder method is rebuilt.

And the final is the Day/Night mode switcher.

 BlocSelector<SettingsBloc, SettingsState, ThemeType?>(
   bloc: settingsBloc,
   selector: (SettingsState state) => state.themeType,
   builder: (BuildContext context, ThemeType? themeType) {
     return GestureDetector(
       onTap: () {
         if (themeType == ThemeType.night) {
           settingsBloc.add(
               const SettingsEvent.selectTheme(ThemeType.day));
         } else {
           settingsBloc.add(
               const SettingsEvent.selectTheme(ThemeType.night));
         }
       },
       child: Row(
         mainAxisAlignment: MainAxisAlignment.spaceBetween,
         children: <Widget>[
           Text(
             themeType == ThemeType.night
                 ? 'switch_to_day_mode'.tr()
                 : 'switch_to_night_mode'.tr(),
             style: TextStyles.semiBold14
                 .copyWith(color: Theme.of(context).hintColor),
           ),
           Icon(
             themeType == ThemeType.night
                 ? CupertinoIcons.sun_max
                 : CupertinoIcons.moon,
             color: Theme.of(context).hintColor,
           )
         ],
       ),
     );
   },
 ),

It works in the same simple way as the fiat currency switcher does. On tap, BLoC updates the state with the new themeType that updates the corresponding text and icon.

The following screenshots demonstrate the UI updates. There come selecting fiat currency and updating the color mode.

The Crypto Aggregator mobile app: “Selecting fiat currency” option.

The Crypto Aggregator mobile app: “Updating the color mode” option.

The Crypto Aggregator project is based on Clean Architecture and the BLoC state management. You can check our GitHub repository, where extra details on the topic have been given out.

Flutter cross-platform has proved to be applicable for crafting mobile apps for meeting various purposes.

You can get more insights on this topic from our articles:
The fundamentals of Flutter & Dart, and Why choose Flutter for mobile app development in 2023?

TBR Group has carried out such software implementations as:
VinciLabs — a platform for providing digital medical solutions for healthcare entities;
SwishBOOM and Babymates are child care mobile apps;
pingNpay will describe the digital payment options based on blockchain technology;
Wywroty Śpiewnik — a musical mobile app — will make you privy to the Polish guitar songs’ performance.

A complete list of the designed mobile apps is presented on our Case Study page.

Summary

Operating in the sphere of platform-independent mobile app engineering, TBR Group targets Flutter app development.

Web, iOS, and Android mobile app developers are welcome to get in touch with TBR Group.

Whether you are an experienced engineer, a junior coder, or an enterprise willing to establish your presence online — feel free to contact TBR Group and articulate any concept directly with the development team.

Flutter for building mobile app MVP: is the game
worth the candle?

Annual global mobile app consumer spending in the App Store and Google Play is projected to reach nearly $233 billion by 2026. It is going to hit a 76 percent expenditure increase when compared to 2021.

Offering a diversity of mobile applications, the app stores get to distribute them by category. Within each and every category, there are dozens of apps operating immensely dissimilar at times.

Therefore, a brand-new app should in fact be distinguishing to yield good results and bring something to the table.

Here comes an MVP. Hence, it is actually quite reasonable to get down to work by crafting an MVP version of the emerging product.

Setting up one’s own business does matter too much and could obviously become a real challenge at times.

In practical terms, in order to produce a product of high quality, you will need to make an effort.

An MVP — which stands for a minimal viable product — is a newly created market product that incorporates the minimum of most important features and targets to meet consumers’ needs in all the possibly relevant areas.

In this article, we are going to cover the basics of mobile app MVP creation. And why building an MVP mobile app in Flutter will definitely be a game that is worth the candle.

Why Use Flutter for MVP mobile app development

Chances are you have really heard of Flutter. It is a framework for building cross-platform mobile applications.

You must be familiar with such corporations as:

They did go for the Flutter-based MVPs before having the full version of the product successfully created.

The applications built with this framework can run on mobile, desktop, and web solutions. They are fast, productive, and flexible.

What else can make Flutter for mobile app MVP become a powerful tool for any kind of software programming works?

An open-source code base, inviting all those interested to the Flutter community, might be an attractive reason to think over. So, there are:

Flutter executes Dart. Unlike some other programming languages, Dart appears to be the one quite easily manageable.

Therefore, software specialists will seek a low learning curve in either mastering this language or improving the existing skills.

The article ”The fundamentals of Flutter & Dart” in our blog allows the reader to dive deeper into the domain.

Advantages of creating mobile app MVP with Flutter

Any stakeholder is expected to benefit significantly just from opting for Flutter in mobile app MVP.

You can learn about the tendencies in the mobile software domain in our article “Why choose Flutter for mobile app development in 2023?”.

Building MVP mobile app in Flutter will be suitable for crafting apps in various industries. Including, but not confined to :

  • music and audio;
  • parenting;
  • productivity;
  • artificial intelligence;
  • machine learning;
  • education/teaching;
  • medicine;
  • pet care.

And software engineers are enabled to expedite the MVP app creation due to:

  • the Just In Time compilation and a stateful Hot Reload;
  • a comprehensive set of functionalities combined with Flutter DevTools;
  • Flutter engine;
  • basic widget components;
  • Material design and Cupertino layouts;
  • dispensing with native elements, XML, and “JavaScript bridge”;
  • leveraging the Skia graphic engine;
  • Firebase integration;
  • Ahead Of Time compilation, ensuring the fast and smooth performance of the ready-made application;
  • GPU-accelerated API;
  • easily added software integrations.

Simplifying elaboration, Flutter for MVP allows business owners to:

  • create a sustainable MVP version of the product;
  • freely opt for various niches;
  • precisely allocate the project budget;
  • pick up a dedicated team or an out staff model with no need of hiring standalone Android and Apple teams;
  • add and implement special unique functionality;
  • integrate the 3rd party services and API;
  • EHR or sensitive data storage;
  • save on expenses;
  • reduce time to market period;
  • receive a natively felt, multi-platform and niche adaptive mobile apps;
  • build exclusively user-friendly mobile apps;
  • to bring in more investors.

Judging by the above, business owners and entrepreneurs can significantly maximize the chances of an early MVP delivery.

So by choosing Flutter for MVP development, they get not only a scalable product of high quality, but also push a project to a jump start.

TBR Group — an expert in building MVP mobile apps in Flutter

TBR Group is a Ukrainian Flutter cross-platform mobile app development company.

Having launched a number of projects in the efficient MVP versions, we considered maximizing the user experience by adding extended functionality.

A variety of technological decisions performed by TBR Group may serve as a confirmation of Flutter’s suitability for the MVP version.

Our team has implemented:

  • a verified network feature in the Swishboom mobile app;
  • deep-linking, branded QR codes, and a QR scanner, the blockchain technology in pingNpay;
  • support of various file formats and enhanced web article text extraction in Neural Reader;
  • the VMP version of Śpiewnik Wywroty was completed within 2 months and when the app proved to be a success, our team added new features;
  • an algorithm for scanning and analyzing data from the 3rd party devices was implemented in VinciLabs;

Our Cases page gives a detailed description of the jobs performed. We will look at just a few of them to showcase different niches Flutter is applicable to.

SwishBoom

Swishboom is an online spot for providing baby care services.

Swishboom mobile app: “How it works”, “Your Job” and the onboarding “Schedule your babysitters faster” pages.

The users can benefit from an additional range of features as well. Among them, there are:

  • contacts integration;
  • Google map integration;
  • push notifications;
  • promotional offering for AppStore;
  • personal or Swishboom care providers network;
  • posting an upcoming babysitter job offer;
  • claiming a babysitter job;
  • in-app purchases;
  • reviews and ratings.

Neural Reader

Neural Reader Most Natural TTS is a mobile application operating as a Text-To-Speech audio reader, and a Speech-To-Text live transcriber.

Neural Reader mobile app: “My Library”, “Dictation” and “Profile” pages.

The key features available for users are:

  • various types of import files;
  • audio reader and player;
  • audio/text conversion;
  • text transcription;
  • data storage;
  • dictation options;
  • voice selection;
  • language selection;
  • text size modification;
  • audio playback speed.

pingNpay

The pingNpay is a software solution for processing micropayments.

TBR Group used Amplify toolset kit and implemented the GraphQL connection with the AWS services, as well as added the Cognito user authentication.

pingNpay mobile app: “Home”, “Contacts” and “Receive” pages.

In the member area, a user can track down and utilize the following functionality:

  • Amplify Cognito authentication;
  • Amplify AppSync GraphQL communication;
  • branded QR codes;
  • a QR scanner;
  • app deep-linking;
  • push notification integration and handling;
  • encryption and decryption;
  • Native Share for QR codes and links;
  • a QR code on-device saving option.

pingNpay will soon be downloadable from the app stores.

VinciLabs

Vinci Labs is a mobile application created for medical organizations.

VinciLabs company is focused on providing a modular API solution to get the 3rd party digital medical devices integrated into particular software products or services.

VinciLabs mobile app – the onboarding “Mission, Vision, Values”, “EHR Data Storage and Analytics” and “Customized Standalone Application” sections.

Vinci Labs is responsible for:

  • the device updates;
  • sensitive data protection;
  • secure storing the EHR data.

All the above confirms that a bunch of technological decisions and functionalities could be implemented with the help of Flutter and Dart bundled together.

Summary

Flutter makes its way to truly becoming the best option to build an MVP mobile application due to its low cost, quick time to market, and scalability. It could be the right choice for a start-up as well.

Providing services to business entities of any scale, TBR Group has been mainly focused on Flutter development.

Whatever project size you may have, do not hesitate to contact us for getting it evaluated. We will render any assistance to you with any kind of concern, dilemma, or inquiry.

Top Flutter mobile app examples

Information technology spending on enterprise software worldwide has already been on the rise for a decade. In 2022, the expenditures in the market area were expected to reach $672 billion, arriving at even a higher number of $752 billion by the year 2023.

The Flutter framework, and respectively the Dart programming language, are among the leaders in mobile application development.

Chances are, you might have already posed a question to yourself:
How about creating a project built with Flutter?

  • Is Flutter suitable for a telehealth mobile data processing program?
  • Will an e-commerce or online babysitting application or even cryptocurrency software be run on mobile devices as well as their alternatives on desktop or web solutions?
  • Is Flutter suitable for an online social media application?

In meeting these challenges, Flutter and Dart bundled together have composed an ultimate solution for crafting cross-platform mobile applications.

Flutter app development ensures a platform-independent operation for the entire range of native, web, and desktop software applications.

The Best Flutter projects to copy

With the number of Flutter app examples considerably growing by now, their sophisticated diversity has been impressive.

Among Flutter projects are such giants as Abbey Road Studios, Google Pay, eBay, and Toyota.

Below, just a few of them exemplify the most popular Flutter hybrid apps. They are:

Reflectly

Falling under the category of health and fitness, Reflectly is an AI-powered personal journal app.

By helping users to cope with negative thoughts, the app aims to nourish a positive alignment and discover the science of how to feel comfortable and happy.

Reflectly App Store / Google Play mobile app: “Home screen”, “Progress” and “Amazing! What’s making your evening super awesome?” pages.

By offering users structured audio reflections, Reflectly ensures learning from the world’s major experts in the area. Thus, a user obtains tools as well as a mindset to improve health and state of mind, building the closest way to happiness — a merry spirit.

CryptoGraph

CryptoGraph is a cryptocurrency market application aiming to provide the user with all the essential data required for a successful crypto market engagement.

CryptoGraph App Store / Google Play mobile app: “Cryptograph”, “Ethereum” and “Feedback” pages.

The user interface is specifically designed for mobile screen resolutions so that all the charts and diagrams could be properly viewed.

The application offers the following features:

  • more than 2,500 cryptocurrencies and tokens available;
  • comprehensive data set on every coin;
  • an exchange rate graph;
  • a list of favored coins;
  • extensive search and filter options;
  • increasing community participation;
  • customizable market cap and display functionalities;
  • a feedback page.

Hookle

Hookle is a social media assistant app that can be readily procurable by all kinds of businesses.

Hookle App Store / Google Play mobile app: “Statistics”, “Planner” and “New post” pages.

The application comes in with relevant and workable solutions. Respectively, in one single place and one go, the application user can:

  • operate multiple social network channels;
  • release posts, images, and videos to numerous network channels;
  • share content directly from the local drive, virtual disk spaces, or the web;
  • create, preview, finalize and issue publications;
  • customize, edit or delete publications;
  • schedule or hold off any content as well as prospective events;
  • search and pick out the previously used hashtags;
  • receive detailed analytic data on the channels;
  • share the social media channels with all the Hookle users and therefore collaborate.

Over and above, such instruments as Social Score, Hookle Planner, and Unsplash will nicely complement and enhance the previously listed functionality.

Being a time-saving practice, Hookle allows entrepreneurs from anywhere in the world to enlarge commerce opportunities and have their businesses scaled up.

Xdrop

Xdrop is a file transfer mobile application.

The main features the customer benefits from:

  • multi-platform sharing;
  • customer-oriented UI/UX;
  • an advantage of much speedier operation;
  • files, photos, videos, and application exchange;
  • privacy and sensible data protection.

Xdrop App Store / Google Play mobile app: “Profile” “Hey” and “FAQ” pages.

As a Flutter-based mobile application, Xdrop may become a perfect choice to meet the need for data sharing.

Slice

Slice is a no-fee Visa credit card mobile application. The main advantage secured by Slice is ensuring reliable and easily accessible online shopping, supported by having an opportunity of splitting the payments.

Slice App Store / Google Play mobile app: “Spark”, “Rewards” and “Spends” pages.

Slice allows users to:

  • shop now and pay later;
  • use passbook to control spending;
  • track and manage expenditures;
  • receive cashback and discounts;
  • funds transferring to the bank or Paytm accounts.

The advantages of using Slice:

  • no user fees;
  • a flexible credit limit;
  • spending habits data analysis.

Providing opportunities to slice the payment submitted, Slice has become a reliable solution for online shopping.

Holywings

Falling under the category of Food & Drink, Holywings mobile app is focused on reservation services and offers multiple services. They include:

  • an online reservation;
  • a minimum charge fee;
  • online reservation;
  • a delivery option;
  • membership advantages.

Holywings App Store / Google Play mobile app: “Profile” “Event” and “Home” pages.

The application is user-friendly and comfortable to use.

Obviously, Flutter is a powerful tool for any kind of development work. Flutter created apps are fast, reliable, and beautifully designed.

Flutter and Dart mobile app examples vividly illustrate a rapid increase in popularity among these powerful software tools.

TBR Group — your tech partner for mobile app development

The IT Development company — TBR Group — is a group of Ukrainian software engineers specializing in platform-independent software and Flutter and Dart programming tools.

There is a set of cross-platform mobile applications built with Flutter and Dart in the TBR Group’s portfolio. In this piece, we will take a closer look at:

mobile apps.

Vetsie for Vets

Vetsie for Vets is a pet care mobile application built with Flutter and Dart. Vetsie for Vets offers both the pet parent and the vet professional sides for application usage. The admin panel option enables the software administrator to supervise the entire app’s performance and provide any assistance needed.

Vetsie for Vets mobile app: “Book Consultation / Payment” and “Audio Call” pages.

More details on the software development peculiarities you can get in Vetsie case study.

Providing an exceptionally user-friendly interface and a set of functionalities, Vetsie for Vets is essential to ensure a comfortable workflow for each of the takers.

Swishboom

Swishboom — a platform-independent mobile application in the category of parenting and lifestyle.

The application is designed to run in two versions — the first for caregivers and the other for caretakers. Families, experiencing a need for babysitting services, can choose a caregiver whose profile may seem the most applicable for the position. Meanwhile, babysitters and various care providers are able to advertise the caregiving services they offer.

Swishboom enables subscribers to:

  • schedule babysitting services;
  • build a personal network;
  • advertise open positions;
  • send event invitations;
  • post jobs into the calendar;
  • validate, and therefore secure and protect each party involved.

Swishboom App Store / Google Play mobile app: “How it works” and “Find a sister” pages.

Further details of the Swishboom project are presented in the Swishboom case study, which you are most welcome to review.

Wywroty Songbook

Wywroty Songbook is specifically developed by guitarists for guitarists.

Originally designed for musicians in Poland, the app has started gaining popularity offshore.

Wywroty Songbook Apple Store / Google Play mobile app: “Start” and “Popular” pages.

As the largest database of arrangements of Polish and foreign songs, Wywroty Songbook enables its user to:

  • create a collection of your favorite songs;
  • browse the most popular and daily played compositions;
  • transpose the chords into the corresponding keys;
  • switch between the guitar and ukulele chord charts;
  • activate automatic text scrolling;
  • to easily search for pieces of music;
  • activate a night mode feature.

A detailed case study description, as well as a complete functionality set overview, can be checked out at Wywroty Songbook case study.

Summary

If you have already got your idea outlined, although a lack of how-to-implement clear understanding is still there, you are most welcome to get in touch with the TBR Group IT Development company.

We will be happy to assist you in clearing up technical aspect details, the look of the application, and the scope of work to be done.

The fundamentals of Flutter & Dart

Smart screens are everywhere. Embedded into the watch on your hand or installed into the mirror in your bathroom or functioning as a roadmap at a bus stop — the screens have already been enriching the life of the entire society.

But multiple functions, as well as convenient usability, are the core features that outline smart mobile phones as leaders in the technological field. The number of smartphone holders is expected to continue growing worldwide.

And here is where Flutter comes in. It strives not just to make sure the power of the device is maintained, but also to enhance its capacity.

Mobile applications, distinguished by functional characteristics, tend to be multi-platform supporting a variety of formats.

As one of the most popular frameworks for mobile app development nowadays, Flutter has steadily gained leadership. As well as Dart — a language it is based on.

Cross-platform mobile frameworks used by developers worldwide 2019-2021

Statista: Cross-platform mobile frameworks used by developers worldwide 2019-2021

Before taking up Flutter mobile app development, you should understand the nature of Flutter and Dart.

Let us dive deeper and discover the topic.

What is Flutter? Is Flutter a framework?

Flutter is a framework for cross-platform mobile app development

In 2018 at the WeAreDevelopers conference in Berlin, Flutter was presented to the IT professional viewership. The speaker, Martin Aguinis, said: “A lot of times when we usually talk about Flutter, we do it with four pillars. Flutter is beautiful, Flutter is fast, Flutter is productive, and Flutter is open”.

The Flutter diagram displayed at the WeAreDevelopers conference

The Flutter diagram displayed at the WeAreDevelopers conference

A brief description of the technology

Flutter is a framework for cross-platform mobile app development

In 2018 at the WeAreDevelopers conference in Berlin, Flutter was presented to the IT professional viewership. The speaker, Martin Aguinis, said: “A lot of times when we usually talk about Flutter, we do it with four pillars. Flutter is beautiful, Flutter is fast, Flutter is productive, and Flutter is open”.

Flutter is a framework for crafting platform-independent applications. And here comes a question: “Is Flutter a programming language?” This issue bothers a great number of curious natures. And the answer will be: “No”.

Flutter itself is not a programming language. It is an SDK – a tool kit – that operates being bundled with either a text editor or an IDE, as a better option, such as Android Studio, IntelliJ IDE. To write the code, Flutter uses the Dart programming language.

The development is started out with the Flutter SDK installation.
Once installed on the chosen desktop operating system, Flutter runs inside the Dart virtual machine.

Respectively, Flutter alongside with Dart allows creating:

  • Android and iOS mobile apps;
  • web applications;
  • graphical applications for desktop Windows, macOS, and Linux solutions.

The benefits primary stakeholders get.

A business owner, by opting for Flutter, can save both on money and time.

So, with Flutter, compared to its native equivalent, it will be easier and considerably cheaper to:

  • build the software;
  • create the MVP;
  • to follow-up with the product support.

Program engineers will appreciate:

  • the documentation, community, and the package repository of the Flutter;
  • an open-source programming;
  • a well-structured toolset;
  • the stateful Hot Reload feature enabled by the JIT compilation;
  • an elegantly designed work environment.

Why will a user enjoy the smooth performance of the application built with Flutter? The answers are:

  • Ahead-of-Time compilation;
  • powerful basic stateful and stateless widgets;
  • Skia graphics engine;
  • out of the box functionalities;
  • no native elements.

Besides, Flutter has also been used to create the user interface of Fuchsia – a new operating system developed by Google.

As described above, no dilemma “Dart vs Flutter” exists any longer, since both terms are interconnected.

Our article “Why choose Flutter for mobile app development in 2024?” helps you much better understand the domain, the benefits, and downsides of the technology.

What is Dart?

Developed by Google and chosen as a programming language for Flutter, Dart is the foundation of this framework.

Embedding an extensive set of basic libraries and packages, Dart:

  • allows using essential elements for daily programming tasks;
  • makes it possible to provide tons of API solutions.

The technology allows Dart to:

  • compile the code into multiple programming languages; 
  • ensure its usage on several platforms.

Given this, Dart is targeting native and web operating devices.

Native solutions

The Dart runtime system is required to execute the code natively. By default, the Dart runtime is included in the Dart VM.

Dart VM is a virtual machine, a collection of components for executing Dart code natively.

To render the machine code, Dart VM applies:
just-in-time compilation (JIT);
ahead-of-time compilation (AOT).

Thus, expediting the start time of the application, the AOT enables an efficient performance of the mobile or desktop application.

Whereas, the JIT is Flutter’s famous Hot Reload feature.

Web solutions

Through the use of particular compilers, Dart is translated into the JavaScript language, which enables its use in the browser. This way web solutions are realized.

Development and Production toolchain for Dart Native and Dart Web solutions

Dart overview diagram: Development and Production toolchain for Dart Native and Dart Web solutions

So, it is incorrect to say: “Flutter coding language” or “Dart SDK”. As Flutter is an SDK or a framework, and Dart – a programming language.

TBR Group: your tech partner in Flutter mobile app development

Just a few words to outline the TBR Group expertise section.

TBR Group is a software company based in Ukraine.

Cooperating with enterprises all over the globe, the TBR Group team has undertaken and successfully carried out a set of projects in platform-independent mobile app software programming.

Vetsie for Vets App Store / Google Play and Swishboom App Store / Google Play may serve as relevant examples.

Vetsie for Vets is a pet care mobile application targeting mainly the USA and Canada market areas. Having been introduced in 2 versions — for the pet parent and the medical workers – Vetsie for Vets perfectly suits both. Outstanding performance has been achieved due to the technology stack of Flutter and Dart realized by the TBR Group team.

Vetsie for vets: “New bookings” and “Upcoming consultation” page. Vetsie for Vets: “Chats” page.

Vetsie for vets: “New bookings” and “Upcoming consultation” page. Vetsie for Vets: “Chats” page.

To learn more on how to craft a pet care mobile app, check “Building a pet care app with Flutter: TBR Group guide”. And to dive into the details of the Vetsie for Vets project realization, you are welcome to read “Vetsie case study page”.

Swishboom App Store / Google Play is another case – a platform-independent mobile app built with the Flutter and the Dart.

Swishboom functions as a web-based spot for parents to order babysitting services. Similar to Vetsie for Vets, according to the functionality assigned, Swishboom has just as well been implemented in 2 software solutions. The first one is specifically designed for families, the other meets the needs of the caregivers and the babysitters engaged in the service.

Swishboom mobile app: “Your job” page and “Find a sister” page.

Swishboom mobile app: “Your job” page and “Find a sister” page.

Find the technical aspects of the project on Swishboom case study.

If you feel like specifying your project requirements, we will be happy to assist.

In a process of dialogue, we will go over the guidelines and terms of the upcoming project, without enforcing solutions. Every peculiarity will be discussed and agreed on with you to ensure an entire case understanding.

You are most welcome to reach out to us and leave your message via our contact form. Looking forward to assisting you at any time.

Why choose Flutter for mobile app development in 2024?

The mobile app industry has already been on the rise, and it will keep increasing its revenues by 10 times, according to Statista.
That’s wow! App stores are crowded with tools for every human need, be it – a song directory, pet vet app, or a sales store.

In recent years, Flutter and React Native have been the leading frameworks in cross-platform development. Occupying the first position in the diagram, Flutter has started to steadily drive the lead.

Though being the front-runner, Flutter has still challenges to work with. In this article, we will describe the pros and cons of the framework, the difficulties we faced, and the solutions we took.

So, let’s go.

Flutter mobile development fundamentals

The framework architecture of Flutter is designed for a cross-platform development process.

It is implemented by deploying several core components, such as Dart programming language, Flutter engine, design-specific widgets, development tools kit, and foundation library.

Let’s dive into the domain and gain an insight into what Flutter actually is.

The upsides of the Flutter framework

Flutter is an open-source framework released by Google in 2018. It is basically a tool kit, an SDK, for the developer to create applications. It contains libraries, widgets, and the required tools for the work process to flow quickly, smoothly, and efficiently.

The list of the big companies’ apps built by Flutter cross-platform is presented in Flutter Apps in Production and An open list of apps built with Flutter.

Advantages of Flutter

A single code base


Flutter runs the code written in Dart. Dart is an object-oriented programming language launched by Google and picked up to implement Flutter.

Dart allows for a single code base to be reused for every platform. The API is stable and well-supported.

It supports Ahead Of Time as well as Just In Time options of code compilation.

During the Flutter app development process, the JIT compilation enables Flutter’s stateful Hot Reload.

With Dart, the flow of development cycles is extremely fast. Respectively, with the changes applied, Flutter app developers can see the actual look of the application in less than a second.
Fast development flow and smooth performance.
The Flutter mobile application becomes AOT-compiled as soon as it has been created and ready to be released.

AOT option allows you to efficiently compile the Flutter mobile app code into the binary native code. Just like with natively coded applications, the start time is speedy and further performance is smooth.

Widget customization


In Flutter, everything is a widget. Using various compositions of widgets, you can draw the user interface, introduce changes into the outer look of the application or even execute the data transmission process.

Developers can create totally customizable widgets. By painting every pixel to the screen, you gain complete control over the application.

Concerning the design-specific widgets, Flutter holds both Cupertino layouts resembling Apple’s iOS Human interface guidelines design language and Android Material Components of the Material Design, which is a design language developed by Google in 2014.

The layouts are defined by using the Dart code only. There is neither XML nor templating language in the Flutter development kit, just as there is no visual designer tool either.

All graphical elements, such as buttons, backgrounds, and texts are written by the graphic Flutter engine.
Compilation flexibility
Due to its compilation flexibility, Dart may be used in a combo with JavaScript and, thus, implemented in the browser or even on the server side by either being compiled natively or into the JavaScript programming language.

There are other benefits of Flutter development, such as:

  • a low learning curve;
  • it is app-oriented, not platform-oriented;
  • it is well-documented;
  • suitable for various niches;
  • Flutter engine and Flutter DevTools have ever-growing capacities;

it’s great for MVPs.

The downsides of Flutter

Dependence on the IT community

To interact with certain native features, Flutter has to use third-party libraries and plugins. Once built by iOS and Android developers, they need to be constantly updated.
The IT community has actively been growing since Flutter was released, and tons of important plugins have come into widespread use.
File size
The file built by Flutter is more disk space-consuming than the one coded natively. The Flutter application that goes into the App store is heavier than its native equivalent.
This file size challenge has already been faced by the Flutter developers and the file size reduction is underway. Performance & Optimization documentation may appear to be a viable solution.

Instability


As Flutter was released from the beta version not so long ago, some sort of operating instability may still occur. Google has already focused on gaining stable and reliable framework performance.

Now let’s compare Flutter and other cross-development mobile frameworks.

Flutter vs React Native vs Native

React Native is an open-source JavaScript framework released by Facebook and applied to build cross-platform applications.

The framework interacts with native platforms by using a so-called “JavaScript Bridge”. This is a context that may cause a jank. A noticeable choppiness of the application performance is detected. And the performance of critical applications may get affected.

In the React Native framework, developers cannot get full control over the software tool and prevent possible security issues and data leakage.

Flutter vs React Native comparison reveals the main differences both in the Dart language capabilities and in Flutter’s new framework architecture itself.

Flutter applications have a faster start-up time and a quicker performance. Looking natively and performing efficiently, they provide a perfect user experience. They are secure enough to be used in any market niche your business belongs to.

If you set the cross-platform approach represented by Flutter vs Native (Kotlin, Java, Swift, Objective-C) or any other native coding option, the differences will at large lie in the development process and become obvious during post-launch support.

The need to hire a doubled number of specialists and run a project in a time- and resource-consuming way will probably make such a project a pricey one.
Maintenance and considerable support costs for two separate applications should as well be considered.

With so many benefits, Flutter appears to be one of the most popular and capable technologies to build cross-platform applications.

Building cross-platform apps with Flatter: TBR Group’s expertise

Here comes a true industry showcase of the apps created by TBR Group which have already been published in the app stores.

TBR Group is a company that specializes in web and mobile programming development.

Swishboom

This Flutter mobile app is available only in the App Store.

Swishboom mobile app – “How it works”, “Find a Sister” and “Your Job” pages.

Swishboom mobile app – “How it works”, “Find a Sister” and “Your Job” pages.

Swishboom connects the families in want of babysitting service to the baby care providers available for job employment. The application allows for creating personal networks for both families and babysitters, scheduling working hours, extending the existing network, and making the babysitter jobs easy to apply for.

Neural Reader Most Natural TTS

Flutter for mobile app development was considered a perfect technology to accomplish Neural Reader Most Natural TTS mobile app project.

Neural Reader Most Natural TTS mobile app – “My Library”, “Reading” and “Dictation” pages.

Neural Reader Most Natural TTS mobile app – “My Library”, “Reading” and “Dictation” pages.

Available on the App Store, Neural Reader is designed to be the most human-like Text-To-Speech audio reader, and the most accurate Speech-To-Text live transcribtion tool. The app provides several subscription plans.

Śpiewnik Wywroty

The Wywroty Songbook is the largest database of Polish and international song arrangements. It was originally created by guitar player for guitar players.

Śpiewnik Wywroty mobile app – “A prompter booth”, “The most favorite Polish Songs” and “Chord charts” pages.

Vetsie for Vets

Vetsie for Vets belongs to pet care telemedicine. It is cross-platform and cloud-based.

Vetsie for Vets – “Book Consultation” feature and “Add Vets” feature.

More information on the app is available at Building a pet care app with Flutter: TBR Group guide.
The challenges of the development process and their solutions

Below there is a list of issues and the solutions we faced while crafting the apps.

  • not all the existing Dart packages support the Null Safety guarantee sound. Due to this reason, some packages have to be manually rewritten to obtain the Null Safety sound support;
  • Flutter applications have bigger sizes than native ones. Since the Flutter app contains the core engine, framework, ICU data, and LICENSE file it will take some space on a disk. For example, for Android, a min Flutter app size is 4MB while the Kotlin app can take 550 KB. However, this is a default drawback for all cross-platform solutions.;
  • to implement Video & Audio chat, a Vetsie application core feature, the TBR Group used a powerful Agora SDK platform. This is similar to FaceTime conversations technology and ensures reliable and secure communication. The app Vetsie for Vets itself has been written using a Flutter web plugin in combination with the JavaScript programming language. Such a programming combination was rooted in Agora SDK itself. Agora SDK does not support chat features for Flutter web options.

For more information and details on how we did it, please, refer to the Writing a Flutter Web plugin with JavaScript: a step-by-step guide.

Summary

Flutter has already been redefining the software development for mobile, web and desktop solutions applicable for projects of any kind and scope.

Having a bunch of numerous benefits and out-of-the-box capabilities, Flutter dares to challenge projects of any complexity.

Flutter’s potential weak points can practically be avoided with a proper development approach.

Flutter app development costs may vary and depend on the preferences of your business projects, goals, and priorities.

What technology to use for mobile app development in 2024 – Flutter or alternative solutions?

This is a dilemma you might have already faced as a business owner and mobile developer, walking the way to your mobile app creation.

Get your unique project communicated and discussed. Find a comprehensive solution. We are always here to assist you!

Building a pet care app with Flutter: TBR Group guide

The world of IT is rapidly dashing forward. Incredible things have become a reality, and the future promises more and more ahead at a quicker pace.

COVID-19 has added its extensive input by applying restrictions and imposing new rules on all the market players. Such conditions force tons of businesses to go online.

The vet tech industry is not an exception to this technological race. There has been an ongoing market demand for online diagnostics of pets’ possible ailments.

Swiftly developing, the pet industry market is expected to enlarge its market share in Global Veterinary Diagnostics from $2.23 billion in 2018 up to $4 billion by 2023 according to the Global veterinary diagnostics market size 2023 forecast.

Pet healthcare centers have been establishing their internet presence. The vet telemedicine busts out, developing digitally and thus discovering new opportunities for businesses involved. Both web and mobile solutions are thriving.

If you are one of the veterinary business holders who have already got a functional website and ponder over creating a vet-on-demand app, you are down the right path.

This is a convenient choice for a pet parent.
Having them both is cool and beneficial and lets your business grow more efficiently. So, here comes a brief outline of how to build a pet care app.

How to build an app for pets?

You need to have your idea shaped up into a concept with clear outlines.

You need to have your idea shaped up into a concept with clear outlines.

Taking into account the number of applications available in the app stores today, you need to apply your creativity to work out an idea to launch a potentially successful vet application.

You can study the most favored pet care apps. Combine their best features, introduce relevant improvements, and generate your own unique application outline.

The majority of the existing apps have arisen due to such a technique.

Perform substantial market research and define the distinctive features. What exactly will make it possible for your application to outgrow eventual competitors?

Draft a proper business plan and outline the marketing strategy to launch your app and keep it efficiently running.

Once you have obtained a perfect understanding of what exactly you want as an outcome and the relevant designs have been made, it’s time for the app coding to get started.

At this stage, you may encounter certain pain points of choosing between either a platform for mobile pet care app development or a custom solution to hire a team of developers who will build a pet services app for you.

Here is a short description of both options:

To code the app by yourself.

If this option appeals to you, you are apparently the one who has already been creating apps.

Using a software builder platform.

You have become aware of the latest tendencies in the chosen domain and stay familiar with the already available solutions to emerging issues.

This tool allows the user to create a pet services app without having to be an expert in programming.

This can be a way out for some small and plain applications which do not require much of smartphone resources.

You will hardly be able to seriously customize the pre-created functionality as well as the template design.

Moreover, one day you can come across a very similar app out there, as the chances are another internet traveler makes his choice on the same template.

The manufacturer platform usually charges on a monthly basis to support running the application and get it operational at all times.

To get additional info as for the Drag and Drop software, please, visit Compare Drag and Drop App Builder Software.

Consuming a white label program.

The option of consuming a white label program – a pre-created software produced by one company and then rebranded by the other – may also deepen the sense of insecurity.

Even though a client purchases a ready-made vet app, still there is a necessity to employ a developer to personalize and adapt it to precisely articulated requirements.
For more information, please, check What is white labeling?, and a list of Frequently asked questions about the white label app builder.

Hiring a development company.

You can hire a team of developers specializing in mobile development to have that unique application coded for you.

This is the most reliable way of embedding your idea into a functional vet on-demand application.

The development company houses its own capacity, which includes a team of highly qualified code programmers, bug testers, project managers as well as quality hardware.

The team members are entirely focused on delivering high-rate products and the project managers closely supervise the working flow to eliminate any inaccuracy in the outcome.

Although it is more expensive compared to the other alternatives, applying to a development company is the fastest, safest, and most nerve-saving option.

The coding language appears to be another challenge for the veterinary or pet health care center owner.

You might have already faced the problem of picking up the best technical stack suitable for creating your pet services app. Indeed, the diversity of coding languages is obviously bewildering.

Vetsie – a pet vet app built with Flutter

TBR Group assisted the Canadian start-up Vetsie in making their idea come true and built a mobile application, Vetsie for Vets.

The vet app Vetsie for Vets belongs to veterinary telemedicine. It is cross-platform and cloud-based, with the interaction taking place on a single platform.

We have developed two types of applications, each has embedded a different set of functionalities.

One of them is comfortably suited for pet owners and the other one — is for the vet clinic.

These two applications are constructed to meet the needs of their owners in the best way possible.

On the Pet Parents’ side, Vetsie for Vets is designed for people owning cats, dogs, and other household pets. It searches for reputable specialists qualified to advise on the pet’s proper ailment.

Vetsie mobile app - Add Vets feature and Sign up page

Vetsie mobile app — Add Vets feature and Sign up page

All the required information about the vet doctor who will render a consultation is shown to the pet parent.

The pet owners can also see the history of correspondence, proceed with payment and buy a consulting service from the vet.

To book an appointment, the pet parent is expected to specify a disturbing issue, opt for a vet professional to refer to, and select a time and date for the call or visit.

Vetsie mobile app — Add Vets feature and Sign up page

The pet owner can communicate their pet’s case to the veterinarian by text, voice, or video messaging.

On the medical workers’ side, Vetsie for Vets is indispensable for veterinary clinics in their interaction with the client – a pet owner. It has got a user-friendly dashboard.

All the statistical data, such as earnings, appointments of each vet professional, etc. are easily seen and analyzed. It displays incoming requests and new bookings, and briefs on the pet parent and the pet itself.

The vet doctors can choose to either accept or deny the requests received.

Vetsie for Vets pet care app is fast, smooth, and easy to run. It contains the following set of key functionalities helping to ensure an efficient interaction process:

  • Video&Audio calls (Agora RTC, RTM, Agora web library);
  • Chat (file uploading, unread messages, voice messages);
  • Book consultation;
  • Google map integration;
  • Charts;
  • Reviews;
  • PDF reports;
  • Push notifications;
  • Stripe payment integration;
  • Facebook events.

Vetsie mobile app — Text / Audio Call feature.

TBR Group company has made a user-friendly app, easy to handle for both — by pet owners and medical workers. It enables the vet staff to balance out their work and time off and ultimately enhance pet care performance.

In Vetsie for Vets we have used Flutter, a brand-new framework produced and backed by Google, for cross-platform mobile and web dashboard development.
It is an open-source software based on the Dart programming language, and the SDK uses a C++ rendering engine.

Flutter provides widgets out of the box with an architecture grounded on reactive programming, which means that web and mobile apps built with Flutter are extremely responsive.

The code written with Flutter can be deployed onto different platforms. Providing high performance and building an amazing experience for the user, Flutter is an extremely user-friendly environment.

In 2021 Vetsie was selected by “Best Startup Canada” as one of the most promising start-ups.

It emerged in two articles: Care Startups and Companies in Alberta, and 10 Top Pet Startups and Companies in Alberta has given a considerable boost to a brand-new business.

Summary


TBR Group is a rapidly evolving company that specializes in web and mobile programming development.

We deliver custom mobile application solutions to bespoke complex projects within the timeline and at a sustainable budget. You are welcome to contact us at any time. The consultation is free, but it gives you a chance to move forward instantly.