Learning Android MVVM Architecture in 14 stress free days.

Introduction:

• Learning Architecture is an important step when learning software development.
• Architectures are hard to learn since there are so many of them.
• Most of tutorials found in Internet introduce too many concepts at the same time and it is hard to follow for most of beginners.

What you should already know:

• You should have some basic knowledges of Object-Oriented programming.
• You should have some basic knowledges of Android development.
• You should have installed all required development tools for Android development on your machine.

What you'll learn:

Hands-on coding:

• Kotlin
  • Coroutines
• Android platform:
  • Navigation component
• Android's Jetpack:
  • RecyclerView
• Android's Architecture Components:
  • View Binding
  • Handling App Lifecycles
  • LiveData
  • Paging Library
  • ViewModel
  • Room Persistence Library
• Testing

What you'll do:

We will implement a cat images browsing app with the following features:

• Fetching list of cat images from TheCatAPI.
• Displaying fetched images in a grid layout.
• Using recommended techniques and frameworks from Google to implement the app using MVVM architecture step by step.
• Implementing the app in an incremental process, starting with a pure Kotlin implementation to a full-blown MVVM-based implementation using frameworks in Android's Architecture Components and popular 3rd-party frameworks.

What's next:

After finishing the course, you'll have hopefully learned intuitively how the MVVM Architecture works by implementing a simple app by using different popular frameworks provided by Google and 3rd parties. Depending on your motivation and the level of knowledge, you can follow different paths forward to learn more about Android development.

A small step:

Try to apply what you have learnd in another app that uses the dog api instead. With this approach, you will have more or less the same structure for you app but you have to deal with a different data model, a different api.

A medium step:

There are two options to learn even more:

• Extending the current cat app by implementing additional features such as:

  • users can favorite images, the information of favorite images should be persisted locally in some kinds of database, and there should be an additional screen to show such favorite images

• Implementing a completely different app using public or private APIs to try out different techniqures:

  • Github App using Github API
  • News App using newsapi.org
  • Image browsing apps using Unsplash or Pixabay APIs
  • ....

There are a list of public APIs that you can use to implement your next sample app here https://github.com/public-apis/public-apis

A giant step:

Everyone of us has an idea (or multiple ideas) for a killer app (or apps). Go forward and realize your dreams. You will be proud of yourself afterward :)

Curriculum:

Day 1: Raw kotlin without any external libraries

This basic project is implemented in pure Kotlin and built-in frameworks from the Android SDK and doesn't use any 3rd party frameworks.

---

Day 2: Volley + Gson + Picasso

• Volley is used for Networking.
• Gson is used for Deserializing of JSON response.
• Picasso is used for displaying & caching of image data.

---

Day 3: Retrofit + Moshi + Glide

• Retrofit is used for Networking.
• Moshi is used for Deserializing of JSON response.
• Glide is used for displaying & caching of image data.

Resources:

• How-To: Retrofit, Moshi, Coroutines & Recycler View for REST Web Service Operations with Kotlin for Android
• Using Glide with Kotlin

---

Day 4: Retrofit + Moshi + Glide + RxJava

---

Day 5: Retrofit + Moshi + Glide + Coroutines

Resources:

• Kotlin Coroutines and Retrofit

---

Day 6: Retrofit + Moshi + Glide + RxJava + Dagger

---

Day 7: Retrofit + Moshi + Glide + Coroutines + Dagger

---

Day 8: Retrofit + Moshi + Glide + Coroutines + Dagger + ViewModel + LiveData

Resources:

• HOW TO SET UP DAGGER WITH VIEWMODEL & SAVED STATE MODULE
• Android ViewModel injection with Dagger

---

Day 9: Retrofit + Moshi + Glide + Coroutines + Dagger + ViewModel + LiveData (Refactored)

Inject the repository directly into the ViewModel

---

Day 10: Retrofit + Moshi + Glide + Coroutines + Dagger + MVVM

• Folder structure
• Multiple ViewModels
• Multiple Dagger modules
• Caching using Room

Resources:

• Imagining your Repository Layer with Coroutines

---

Day 11: Retrofit + Moshi + Glide + Coroutines + Dagger + MVVM + PagedList

• PagedList Component.
• NetworkState in ImageDataSource

Resources:

• Android Paging Library with Kotlin Coroutines
• Exploring Paging Library from Jetpack

---

Day 12: Testing

---

Day 13: Apply further advanced techniques:

• Clean architecture with interfaces for use cases.
• Inject key from gradle and BuildConfig: https://github.com/PhilippeBoisney/GithubApp/blob/master/app/build.gradle
• View binding.
• MultiBinding with Dagger: (used to inject a viewmodel into its corresponding Activity/Fragment)
  • Using Dagger2 IntoMap API for Android ViewModel Injection
  • Dependency Injection of ViewModel with Dagger 2
  • Android ViewModel and FactoryProvider: good way to manage it with Dagger Multibindings
  • Dagger 2 MultiBinding - Inject into ViewModels using MVVM,Dagger and Kotlin
• Check Internet connection
  • https://proandroiddev.com/android-architecture-components-network-awareness-using-livedata-1a8d3749734d
• Multi-modules
• Add SurpervisorJob into ImageDataSource
  • https://github.com/PhilippeBoisney/GithubApp/blob/master/app/src/main/java/io/github/philippeboisney/githubapp/pagination/datasource/UserDataSource.kt
  • https://proandroiddev.com/playing-with-4f21bc67a7f9
• Cache the list in Room

---

Day 14: Use Koin instead of Dagger

• Build-time code generation (Dagger) vs Runtime dependency injection.

Resources:

• Playing with… Paging Library, Retrofit, Coroutines, Koin & Testing.
• Boost your Android apps with Koin and Coroutines using MVVM in Kotlin

Additional Resources:

Architectures:

• Android Architecture starring Kotlin Coroutines, Jetpack (MVVM, Room, Paging), Retrofit and Dagger 2
• Android - MVVM using Dagger,room,navigation controller,Rx,Livedata,Retrofit
• Android MVVM with Dagger 2, Retrofit, RxJava, Architecture Components
• MVVM with Kotlin — Android Architecture Components, Dagger 2, Retrofit and RxAndroid

Dagger:

• LearnDagger
• Awesome Dagger

Completed apps:

• https://github.com/android/architecture-samples
• https://github.com/android/sunflower
• https://github.com/Eli-Fox/LEGO-Catalog
• https://github.com/theozgurr/LibraryApp