A sample app to demonstrate the building of a good, modular and scalable Android app using Kotlin, Android Architecture Components (LiveData, ViewModel & Room), Dagger, RxJava and RxAndroid among others.

Features

Some of the features of the app include

• Effective Networking - Using a combination of Retrofit, Rx, Room and LiveData, we are able to handle networking in the most effective way.

• Modular - The app is broken into modules of features and libraries which can be combined to build instant-apps, complete apps or lite version of apps.

• MVVM architecture - Using the lifecycle aware viewmodels, the view observes changes in the model / repository.

• Kotlin - This app is completely written in Kotlin.

• Android Architecture Components - Lifecycle awareness has been achieved using a combination of LiveData, ViewModels and Room.

  • Offline first architecture - All the data is first tried to be loaded from the db and then updated from the server. This ensures that the app is usable even in an offline mode.

  • Intelligent sync -Intelligent hybrid syncing logic makes sure your Android app does not make repeated calls to the same back-end API for the same data in a particular time period.

  • Dependency Injection - Common elements like context, networking interface are injected using Dagger 2.

  • Feature based packaging - This screen-wise / feature-wise packaging makes code really easy to read and debug.

Working

Networking

Activity

viewModel.getPosts()

ViewModel

fun getPosts() {
    if (postsOutcome.value == null)
        repo.fetchPosts()
}

Repository

val postFetchOutcome: PublishSubject<Outcome<List<PostWithUser>>> = PublishSubject.create<Outcome<List<PostWithUser>>>()

override fun fetchPosts() {
    postFetchOutcome.loading(true)
    //Observe changes to the db
    local.getPostsWithUsers()
            .performOnBackOutOnMain(scheduler)
            .doAfterNext {
                if (Synk.shouldSync(SynkKeys.POSTS_HOME, 2, TimeUnit.HOURS))
                    refreshPosts()
            }
            .subscribe({ retailers ->
                postFetchOutcome.success(retailers)
                }, { error -> handleError(error) })
            .addTo(compositeDisposable)
}

override fun refreshPosts() {
    postFetchOutcome.loading(true)
    Flowable.zip(
            remote.getUsers(),
            remote.getPosts(),
             zipUsersAndPosts()
    )
            .performOnBackOutOnMain(scheduler)
            .updateSynkStatus(key = SynkKeys.POSTS_HOME)
            .subscribe({}, { error -> handleError(error) })
            .addTo(compositeDisposable)
}

private fun zipUsersAndPosts() =
        BiFunction<List<User>, List<Post>, Unit> { users, posts ->
            saveUsersAndPosts(users, posts)
        }

override fun saveUsersAndPosts(users: List<User>, posts: List<Post>) {
    local.saveUsersAndPosts(users, posts)
}

override fun handleError(error: Throwable) {
    postFetchOutcome.failed(error)
}

ViewModel

val postsOutcome: LiveData<Outcome<List<Post>>> by lazy {
    //Convert publish subject to livedata
    repo.postFetchOutcome.toLiveData(compositeDisposable)
}

Activity

viewModel.postsOutcome.observe(this, Observer<Outcome<List<Post>>> { outcome ->
    when (outcome) {

        is Outcome.Progress -> srlPosts.isRefreshing = outcome.loading

        is Outcome.Success -> {
            Log.d(TAG, "initiateDataListener: Successfully loaded data")
            adapter.setData(outcome.data)
        }

        is Outcome.Failure -> {
            if (outcome.e is IOException)
                Toast.makeText(context, R.string.need_internet_posts, Toast.LENGTH_LONG).show()
            else
                Toast.makeText(context, R.string.failed_post_try_again, Toast.LENGTH_LONG).show()
        }

    }
})

Testing:

To run all the unit tests, run ./gradlew test. This would test the repositories and the viewmodels.

To run all the instrumented tests, run ./gradlew connectedAndroidTest. This would test the LocalDataSources (Room)

Build info:

• Android Studio - 3.1 Canary 8
• Compile SDK - 28
• MinSDK - 16, Target - 28

Articles

To read more about the architecture choices and the decisions behind this project, kindly refer to the following articles:

• Effective Networking On Android using Retrofit, Rx and Architecture Components
• Writing a modular project on Android
• To Synk or not to Synk

Talk to the developer about this project: @karntrehan

Other samples

Below are some of the other samples I have opensourced:

• Starwars : 2019 - A sample modular Android app written in Kotlin using Rx, Koin, Coroutines, Dagger 2 and Architecture components
• Agni : 2019 - Android app template for modular apps with Dagger 2, Coroutines, LiveData, ViewModel and RxJava 2.
• Talko : 2019 - A sample messaging UI app for Android writen in Kotlin with a working local persistence layer.

Libraries used

• Android Support Libraries
• Dagger 2
• Retrofit
• OkHttp
• Picasso
• Stetho
• Room
• ViewModel
• LiveData
• RxJava
• RxAndroid

License

Copyright 2018 Karan Trehan

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.