SpaceX prepare for Clean Architecture liftoff🚀

The purpose of this project is to consolidate some of the learned insights throughout the years about the Clean Architecture principles and reflect those lessons on Android, taking advantage of the Kotlin programming language features too.

This project summarises some of the general use cases and demands on a typical production project using: Jetpack Compose, Functional Programming,MVVM, Kotlin Coroutines and Kotlin Flows (check the branches section for more information).

Libraries Used 📚

• Compose Toolkit for building native UI (in a declarative way - 100% Kotlin).
• Coroutines Library support for Kotlin coroutines.
• Flows Stream processing API, built on top of Coroutines.
• Compose Navigation for tabs navigation using Jetpack Compose.
• Dagger Hilt Dependency injection library for Android.
• Retrofit Type-safe REST client for Android to consume RESTful web services.
• Timber Logger with a small API which provides utility on top of Android's normal Log class.
• Espresso Android UI Testing framework.
• MockK mocking framework for testing.
• MockWebServer A scriptable web server for testing HTTP clients, used for Instrumentation tests in this project.
• Coil Compose Image downloading and caching library supported by Jetpack Compose.
• Lottie Compose Library that provides that parses Adobe After Effects animations exported as json with Bodymovin and renders them natively on mobile.
• JodaTime Date library that lets manage more extensively and easily dates
• Shot Shot is a Gradle plugin and a core android library thought to run screenshot tests for Android.

Modules 📑

• app - The application module with access to all the application
• data - Android module that can only access domain module
• data-api - Android module that can only access data module
• domain - Kotlin module that cannot access any other module

And two extra modules:

• core - Base classes module (factories, events, etc.) that cannot access any other module
• core-android-test - Tests classes module (rules, date builders,etc.) that cannot access any other module

Branches

There are three options depending on different tech-stack desired. The latest codebase will be updated in master. These are the three options available (all of them maintained):

• master

  • Jetpack Compose (declarative UI)
  • Dagger Hilt
  • VM approach using UI States and Effects
  • Kotlin Flows (removed LiveData)
  • Modules simplification
  • The rest of modules remain the same (Tests)

• SpaceX-Coroutines-Flows

  • Imperative UI
  • Dagger2
  • Kotlin Coroutines and Flows
  • Granular modularisation (CleanArchitecture approach)
  • Unit Tests + UI Tests + MockWebServer + Robot Pattern

• SpaceX-RxJava

  • VMs and Fragments communication via RxJava
  • Dagger2
  • Granular modularisation (CleanArchitecture approach)
  • Unit Tests + UI Tests + MockWebServer + Robot Pattern

Testing 🔍

Unit Testing

There are some highlights:

• Every layer in the architecture has been tested.
• MockK has been used for mocking | stubbing.
• Given | When | Then code presentation order, in order to give a more structured style.
• Code Coverage (WORK IN PROGRESS).

UI Testing (Compose)

I opted to use three types of approaches:

• MockWebserver, where real connection scenarios are setup. More information in my MockWebServer Medium Article!
• Tests in Isolation, where it's possible to mock and set any content, UI state, etc. Which allows to emulate very specific edge cases.
• Screenshot Testing 📸

In the two first types of tests I used Robot Pattern to improve cleanliness and ease of readability. More information in my RobotPattern Medium Article!

License 🚔

Copyright 2022 Fernando Prieto Moyano

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.