Modern Android app using Kotlin, MVVM, Dagger2, RxJava &more

Explore how the MVVM architecture separates data presentation logic from business logic with model, view, and viewmodel roles, enabling flexible development and unit-tested, readable code.

Begin your Android app with a Kotlin-based empty project, define a country data model, and set up MVVM by creating model, view, and ViewModel components for the list of countries.

Import and configure project libraries in the app Gradle file by defining version variables and declaring dependencies like Retrofit, Dagger, Glide, RxJava, and Lifecycle Extensions.

Implement a view model using live data for countries, loading, and error states; populate with mock data and provide a refresh method that calls a private fetchCountries.

Build the view layer by using a swipe refresh layout for country lists. Add a recycler view, a centered error text, a loading spinner, and an item layout for countries.

Implement the country list adapter to display a list of countries by binding data to a view holder and updating the list when data changes.

Implement the view in a Kotlin MVVM Android app by wiring the main activity to a view model and observing the countries list in a recycler view; show loading state.

Explore how Retrofit simplifies Android network communication by defining interfaces and endpoints to fetch JSON data, while RxJava handles asynchronous streams with observables and observers in the view model.

Implement retrofit to fetch a list of countries from a GitHub endpoint, defining a Countries API interface and a service, using a Json converter and RxJava call adapter.

Map backend country data to a Kotlin mvvm app, loading capital, name, and flag from the api using RxJava, with proper threading, error handling, and manifest permission.

Update the country item layout by adding an image view and a vertical section for the country name and capital. Extract a standard padding and apply weight-based sizing and styles.

Implement the country list view by binding data in a view holder, add an extension function to image view for loading a flag with Glide and a circular progress drawable.

Implement swipe-to-refresh by wiring the swipe refresh layout's on-refresh listener to the ViewModel's refresh method, control the refreshing indicator, and leverage retrofit caching for efficient data loading.

Discover how dependency injection separates object creation from use by injecting a network service into the ViewModel, using Dagger 2 with inject annotation, module, and component.

Implement dependency injection with dagger 2 by creating an API module and a component, then inject the API into the countries service.

Execute a hands-on dependency injection challenge by extracting the country service and injecting it into the list view model with Dagger 2, then build and verify the country list.

Extract the country service as a dependency and inject it into the list view model using dagger, enabling easy unit testing and scalable architecture for Android apps.

Learn how unit tests validate business logic in isolation from the view and the model, with automated success and failure path tests in the view model using a country service.

Learn to write unit tests for a view model by isolating business logic from the UI and backend through dependency injection, and configure RxJava schedulers to run synchronously in tests.

Implement a failure path test for the get countries flow, ensuring on error variables update correctly. Try writing get countries test failed function before the next lecture reveals the solution.

Implement an error path unit test for the countries service by returning an error as a single, then assert the view model flags load error true and loading false.

Implement a mvvm architecture for an Android app, using retrofit and Json to fetch data, Glide for images, RxJava for communication, and dependency injection with unit testing.