Content

• Why start with the database layer for testing?
• An overview of the data-layer
• Classifies the types of data in the database systems, and
• Testing them using the popular existing libraries(Jetpack, Rx, and Coroutines).

Firstly, Why Start Testing With the Database Layer?

Whichever architecture you choose, be it the MVVM, MVP, MVC, or MVI, the data-layer is the one that goes through minimal changes. It almost remains the same during architectural migrations.

The data-layer has minimal dependencies, which makes it very easy to test. It can be unit-tested using Robolectric (saves time)

What Is a Data-Layer?

It is the layer responsible for providing the data for the app with the help of network…

Creating loosely-coupled Reactive Feature Components

Overview

Re-usability is a pattern that solves the problem of duplication. It can be as simple as creating Functions, Classes, Interfaces to more complex UI-Components and Feature-Components.

The article focuses initially on the re-usability of UI-Views(UIComponents) and then the FeatureComponents. Emphasis is on the Dependency-Inversion Principle, where both the Low-level(Feature Component) and High-level component (One incorporating the low-level components) both depend on abstraction, to create loosely-coupled systems.

A peek into UI Component [UI-level]

Before proceeding to Feature Components, we’ll start with a brief overview of UI-Components(re-usability of Views).

What is the meaning of scope?

Scope refers to the lifetime of an object. Consider an example of a simple class.

• largeScope — Its scope is tied to the lifetime of the class. It can be accessed anywhere in the class.
• smallerScope — Its scope is limited to the lifetime of a function. It can only be accessed inside the myFunction block. It is not recognized outside this function.
• Scopes are meant to define the Object’s lifetime.

Why is scoping important and what are its uses in Dagger?

Scopes in dagger are nothing different. Consider a shopping app where you browse through the different screens(👇), add the products in the cart, and finally make payment.

Model-View-Intent (MVI) is a popular architecture in the Android world. It was introduced by Hannes Dorfmann. You can find it here. For the purpose of this article, a brief introduction to MVI is presented below.

MVI is a cyclical and unidirectional data-flow architecture.

• The Model represents the state of the application. It contains the properties necessary to render the screen.
• An Intent is an event to change the state of the system — e.g., user click is an event to change the state of the system. Also, call it [Interaction].
• View observes the state change and updates itself accordingly.

Graphical representation:

In my previous article, we created reusable UIComponents using Jetpack Compose:

It had limited capability, as UIComponents could only be laid out on the screen. This article will cover user interactions, like click events, that were not handled.

What Is Interaction?

It is an event on the UIComponents (e.g. a click event on the MovieUI component).

The interaction on the UIComponent will be handled by the ComposeActivity class that includes UIComponents. For example, a click event on the MovieView in the HomeScreen is handled by HomeScreen Activity.

What Are We Building?

We have HomeScreen and MovieDetailScreen. Both of them contain movies (MovieView). …

Motivation: You might have run through apps like Netflix/Amazon Prime, where an individual screen contains a lot of views that are re-used throughout the application. For example, consider the Amazon Prime Video application.