📚 Android Components Architecture in a Modular Word
Mobile Senior Software Engineer && Freelancer
Marvel kotlin sample application using android components architecture in a modular project
Over years Android architecture evolved to support production-quality apps on any scale focused on helping developers to design robust, testable, and maintainable apps. For that Google has promoted in the last years Kotlin
as an official Android programming language impulse via a series of community-led events like Kotlin/Everywhere
and programmers Udacity courses Kotlin Bootcamp
. And it is not for less since the advantages are endless with respect to Java offering modern statically typed programming language that will boost your productivity and increase your developer happiness.
But first of all, if you want to check directly the project before continuing reading the introduction, you can do by accessing the following link:
The programming paradigm in android has seen a drastic turn with the introduction of Android Jetpack
a suite of libraries, tools, and guidance to help developers write high-quality apps easier. These components help you to follow best practices, free you from writing boilerplate code, and simplify complex tasks. That has ended up giving rise to what is known today as Modern Android Development
Android Architecture Components
are part of Jetpack and are a collection of libraries that help you design robust, testable, and maintainable apps. Start with classes for managing your UI component lifecycle and handling data persistence.
The below diagram demonstrates how would an application that uses this software design technique, although if you want to see more, I recommend the following link
Modularized app with multiple independent features what share or not the same libraries.
Yet when it comes to combining all architecture puzzles together into simple client application it is difficult to find open-sourced app sample to follow. For this reason, I decided to build one based, apply and strictly complies with each of the following 5 points:
The project presents a modern, 2019 approach to Android
application development using Kotlin
and latest tech-stack
The goal of the project is to demonstrate best practices, provide a set of guidelines, modular application, scalable, maintainable and testable. This application may look simple, but it has all of these small details that will set the rock-solid foundation of the larger app suitable for bigger teams and long application lifecycle management.
One of the key benefits of modularization architecture is supposed to be clear navigation throughout the app and source code. Looking at the root folder of the project, the following structure becomes clear:
Interaction between modules
Between the modules is established a dependency relationship that allows us to make an API request, access to DDBB or use a certain initialized library. Reusing the code in this way and avoiding duplicating. The below graph shows the app dependency between modules:
- :app depends on :core and indirectly depends on :features by dynamic-features.
- :features modules depend on :commons, :core, :app and some specific utils:library that will use.
- :core and :commons only depends on possible utils on :libraries.
- :libraries don’t have any dependency.
module is a com.android.library
for serving network requests or accessing to the DDBB. Providing the data source for the many features that require it.
module are a com.android.dynamic-feature
is essentially a gradle module which can be downloaded independently from the base application module. It can hold code and resources and include dependencies, just like any other gradle module.
modules are a com.android.library
only contains code and resources which are shared between feature modules. Reusing this way layouts, views, and other components in the different features modules, without the need to duplicate code.
modules are a com.android.library
, basically contains different utilities that can be used by the different modules.
Ideally, ViewModels shouldn’t know anything about Android. This improves testability, leak safety and modularity. ViewModels have different scopes than activities or fragments. While a ViewModel is alive and running, an activity can be in any of its lifecycle states. Activities and fragments can be destroyed and created again while the ViewModel is unaware.
Passing a reference of the View (activity or fragment) to the ViewModel is a serious risk. Let's assume the ViewModel requests data from the network and the data comes back sometime later. At that moment, the View reference might be destroyed or might be an old activity that is no longer visible, generating a memory leak and, possibly, a crash.
The communication between the different layers follows the above diagram using the reactive paradigm, observing changes on components without the need of callbacks avoiding leaks and edge cases related to them.
With App Modularization we want to gain fine-grained dependency control but we also need to make sure we don’t end up maintaining multiple configuration files.
For that we have the following common configuration files:
The following android-dynamic-feature.gradle.kts is applied to every feature module with the following line:
Things to consider
Of course, nothing is perfect, especially if it has recently come out. Here are some issues what I found during development:
- Navigation component don’t support multiple back-stack for the moment. Exist different workarounds but not officially solution to this. (issue)
This is project is a sample, to inspire you and should handle most of the common cases, but obviously not all. If you need to take a look at additional resources to find solutions for your project, visit these interesting projects:
A collection of very interesting articles related to last android community tendencies and recommendations for starting to take in consideration for your current/next project:
The open-source community create and maintains tons of awesome libraries making your job easier, giving the opportunity to use them in your developments. Here is a very important collection of them:
Avoid reinventing the wheel by following these guidelines:
There are certain benefits in writing or migrating to Modular App and using Architecture Components with them.
- Faster build times.
- Fine-grained dependency control.
- Improve reusability across other apps.Improves the ownership & the quality of the codebase.
- Stricter boundaries when compared to packages.
- Encourages Open Source of the newly created libraries.
- Makes Instant Apps & Dynamic Features possible (improving discoverability).
Remember, keeping modules Clean
improves testability and eases future refactoring in case it needs to be shared between multiple user-facing features.
The aim of this article was to provide a brief overview of how to combining all architecture puzzles together into your current/next project. If you have any questions, improvements, recommendations about modularisation and architecture components please add your response 🙂.
The full open-source code can be found on GitHub:
Thanks for your time and reading.
Subscribe to get your daily round-up of top tech stories!