Now In Android with Koin — half 2 | by Arnaud Giuliani | Dec, 2022


Now In Android is an open-source Android software that covers Trendy Android Improvement greatest practices. The challenge is maintained by the Google Android group.

I suggest to proceed our tour with the model constructed with the Koin dependency injection framework. This can be a good time to refresh practices, from customary parts construction to extra superior instances.

Let’s make a walkthrough into the widespread core parts, giving us the important constructing blocks to allow us to write our options.

The screens of the NowInAndroid app are developed with Jetpack Compose and use repository & usecase parts:

  • Repository to entry knowledge (community, database …)
  • Usecase to deal with enterprise logic

Let’s open the DataKoinModule.kt to see our Repository parts definitions:

Frequent Information Parts

All of the repository parts are declared utilizing the singleOf key phrase plus a bind() part to specify the sure kind. It will create every one as a singleton occasion.

It’s a great apply to make use of the consists of() operate to checklist explicitly any Koin module that might be wanted for any definition of the present module. This additionally expresses a powerful hyperlink, that can be utilized by the confirm() API to confirm our Koin configuration.

Parts from the Information layer may be declared as singleton situations. The Information layer is impartial of the UI layer: there isn’t any have to affiliate them to a lifecycle.

For Usecase area parts, we’ll see about them intimately within the part later.

Structure layers from https://developer.android.com/matter/structure

The primary knowledge modules we’ll take a look at, are the database parts indaosKoinModule.

The challenge is utilizing Room. To declare a Room database occasion, we have to create it with the Room.databaseBuilder() builder operate. This occasion will probably be registered as singleton and referred by DAO parts.

Under, the databaseKoinModule declares the definition of the database occasion:

Declaring Room Database

We merely use a single definition, adopted by a operate to be executed. Observe right here that we use the androidContext() operate to retrieve the Android context from Koin.

Subsequent in daosKoinModule, is pretty simple to declare every DAO. Every of them is referenced from the NiaDatabase interface. We will reference every DAO as comply with. We use the get<NiaDatabase>() expression to retrieve our database occasion, and use it to name our DAO occasion as comply with:

Declaring DAOs

Every of these DAO is outlined with the single key phrase (singleton occasion). We embody the database definition module.

In Dagger Hilt, the philosophy stays the identical nevertheless it’s nonetheless verbose:

Hilt NiaDatabase Declaration
Hilt DAOs declaration

Let’s proceed with the DataStore parts within the following part.

On this half, we have to put together the creation of theDataStoreFactory occasion to learn offline knowledge. Let’s open the dataStoreKoinModule to see these parts:

DataStore Module

We’d like a number of singletons right here:

  • UserPreferencesSerializer to be handed to our DataStore, to serialize knowledge from UserPreferences
  • DataStoreFactory the DataStore occasion itself
  • NiaPreferencesDataSource Datasource element, which makes use of the DataStore to learn native knowledge

On this module, we have to inject the Kotlin coroutines “default dispatcher”. This one is included in our module, and may be written like this:

Declaring Default Coroutines Dispatcher

Observe that we will simply override such a definition in a take a look at surroundings by offering a brand new definition that can override the default one. You probably have a number of definitions of the identical kind, you may also add a qualifier.

The community module is an attention-grabbing case: we have to load totally different definitions of implementation relying on the flavour of the module. We now have 2 flavors: demo (static demo content material) & prod (content material requested over the community).

The best way to dynamically use the fitting taste implementation?

Let’s first write the networkKoinModulefile first. This module will embody youngster implementation:

The community module

We will declare right here, all widespread definitions utilized by the included modules (just like the JSON serializer occasion).

The decision toconsists of(networkFlavoredKoinModule) will load the acceptable Koin module. From there, let’s write the networkFlavoredKoinModule module for every taste. Naturally, the challenge will hyperlink and compile the fitting file.

The demo taste folder:

Demo Taste

The demo taste networkFlavoredKoinModule file, declaring a pretend implementation:

Demo Community Module

The prod taste folder:

Prod taste

The prod taste networkFlavoredKoinModule file, declaring a Retrofit implementation:

Prod NiaNetworkDataSource implementation

Every implementation will present a NiaNetworkDataSource element. We don’t have to declare nor embody any Json definition, as Koin will discover it from the father or mother module.

Now that we have now core parts to assist work with our knowledge, we will have parts devoted to enterprise logic and permit us to reuse them on the UI layer.

Let’s open the domainKoinModule file to see our Usecases definitions:

Use-cases definitions

Every use-case element is outlined as a “manufacturing facility” right here. Why? We need to guarantee that we’ll have a “stateless” enterprise logic unit, and keep away from conserving in reminiscence something linked to the UI. These use-case parts are launching Coroutines Flows to hearken to incoming knowledge updates. We don’t need to preserve Circulate reference between screens.

GetFollowableTopicsStream Usecase

The usage of factoryOf guarantee that we’ll recreate an occasion, every time we’ll ask for it and rubbish gather beforehand used situations (let the occasion be destroyed).

Lastly, one particular and necessary element of this challenge is the SyncWorker class, devoted to resyncing knowledge to repositories. That is serving to get knowledge for the “offline first” technique: we take a look at knowledge domestically and remotely. We will show already-fetched knowledge whereas asking for brand spanking new knowledge remotely, and keep away from displaying empty content material to the person.

As you see, this class is demanding nearly all our widespread parts:

SyncWorker Class — To assist sync knowledge repositories

Let’s open the syncWorkerKoinModule file to declare our WorkManager. You may even see that we merely have to declare our element with workerOf key phrase, and that’s it:

Declaring Sync Employee

Don’t neglect to begin WorkManager Koin manufacturing facility on the Software begin, with the workManagerFactory()operate:

WorkManager setup with Koin

The decision to Sync.initialize() asks to initialize the information sync for offline content material.

Don’t hesitate to examine the documentation for extra particulars: https://insert-koin.io/docs/reference/koin-android/workmanager

We at the moment are able to inject the whole lot in a single Jetpack Compose composable operate. In our AuthorRoute display screen composable, we use the koinViewModel() operate to get the ViewModel.

injecting ViewModel in Compose

To declare a ViewModel element, we merely want the viewModelOf key phrase following by our class constructor:

Declaring AuthorViewModel

With such a key phrase, your ViewModel may be robotically injected with SavedStateHandle parameter if you happen to want.

AuthorViewModel class constructor

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest Articles