Android Jetpack masterclass in Kotlin

Download and install Android Studio on a Mac from developer.android.com/studio, then launch Android Studio and create a new project with a Nexus 6 emulator using Oreo API 27 for testing.

install Android Studio on a Windows PC from developer.android.com with default settings; create an avd emulator (Nexus 6P, Oreo API 27, and Lollipop) and rebuild the project if errors occur.

Connect your device to Android Studio and run apps on a real device by enabling developer options and USB debugging, testing directly on hardware rather than an emulator.

Discover Android X, the location for all Jetpack libraries, and understand its role replacing the old support libraries while preserving backward compatibility and library independence.

Create a new Android Studio Kotlin project with an empty activity, set API 15 and AndroidX Jetpack, and customize the app icon through an image asset and manifest.

Define and add project dependencies in Gradle, wiring navigation, Room, Retrofit, RxJava, Glide, Palette, and Preferences. Enable data binding and Safe Args to streamline Jetpack integration in Kotlin.

Learn how Android Jetpack navigation streamlines moving between fragments within one activity, handling back stack, arguments, and transitions while supporting deep linking and patterns like bottom tabs and app drawer.

Learn to implement Android navigation between two fragments in a Kotlin app using a navigation graph, destinations, and actions within an mvvm structure.

Build the interface for list and detail fragments using a constraint layout, center text, and add a floating action button with a vector asset to navigate between fragments.

Wire button clicks to navigation actions in Kotlin using the Jetpack navigation component and generated directions, then manage back navigation with a toolbar back arrow and the nav controller.

Transfer parameters between screens using the new navigation library, define arguments in the navigation graph or XML, and observe animated transitions between list and detail fragments.

Remove nonessential navigation code and UI elements such as text views and floating action buttons from the list and detail fragments, leaving only a clean constraint layout.

Learn how Android layouts use view groups and views to build screens, exploring linear, relative, constraint layouts and recycler views, with XML and visual editor workflows.

Learn to build the fragment list layout by wrapping a constraint layout in a swipe refresh layout, adding a recycler view, an error message, and a loading spinner.

Create an item_dog layout using linear layouts with weight-based proportions to display a dog image, name, and lifespan in a horizontal arrangement.

Learn to build a detail fragment layout with a relative layout, placing an image at the top and stacking text views below using relative constraints and margins.

Define the mvvm foundations by creating a Kotlin data class named dog breed as the model, with nullable fields for id, name, lifespan, breed group, temperament, and image url.

Build a Kotlin Android recycler view adapter to convert dog breed models into list items, using a dog view holder, binding name and lifespan, and updating the list with data.

Learn how to implement a lifecycle-aware ViewModel with LiveData to drive a dog breeds list in a fragment, include loading and error states, and observe data to update the UI.

Implement a detail view model and enable list-to-detail navigation, populating a dummy dog with name, purpose, temperament, and lifespan in a Kotlin Jetpack app.

Create a detail view model class extending view model with a mutable live data for a dog breed, then observe it in the detail fragment and bind key fields.

Explore how retrofit enables seamless backend communication in Android Kotlin, handling networking and threading automatically. Use Pojo, interface endpoints, and a service class with RxJava for Json or Xml data.

Explore RxJava in Android development, learning its reactive, asynchronous paradigm with observables and observers, including the single emission concept, and how it powers network calls via Retrofit.

Implement retrofit in a Kotlin Android app by modeling dog breeds, wiring serialized names to backend fields, and using a JSON converter factory with RxJava to fetch data.

Learn to fetch remote data using retrofit and rxjava, wiring a viewmodel to observe a dog breeds list via live data, with proper threading, error handling, and mvvm separation.

Explore Glide, a lightweight third-party library for Android that loads and caches images in the background, reduces boilerplate, and offers placeholders, error images, resize options, and palette library integration.

Explore Kotlin extensions from the KTX library that extend Android components without subclassing. Learn to batch edit shared preferences and load images with Glide using view extensions.

Learn to load images with Glide in an Android Kotlin app by creating an image view extension and a circular progress drawable, wiring placeholders and error icons in the adapter.

The room library abstracts SQL to store data locally, using compile-time generated entities and DAOs. It supports insert, update, delete, and query with checks and runs on a background thread.

Define a Room database entity in Kotlin, customize column names, and configure an auto-generated primary key, building a simple cache-like data model for backend data in Android Jetpack.

Create a Room database with a dog breed entity by defining a dog dao interface, inserting and querying data using suspend functions, and implementing a singleton dog database.

Enable database access on a background thread with a base view model and coroutines, then store dog data locally by deleting records, inserting new ones, and updating the user interface.

Explore shared preferences, a simple key-value storage that persists configuration data across restarts. Learn about default and custom locations and editing with commit in the Cotton Extensions Library.

Implement a singleton shared preferences helper to store the time a dog list is updated, using the default shared preferences to enable cache-aware data retrieval.

Retrieve dog data from a remote endpoint or database based on a five-minute refresh window. A ViewModel uses nanoseconds timing and a bypass-cache option to compare cache versus network.

Implement the detail screen by fetching the dog from the database using its uuid, and populate its image, name, and details via the ViewModel.

Implement detail screen by wiring the detail view model to fetch a dog by uuid from the database, then load the dog's image with a progress drawable and observe updates.

Learn how data binding attaches variables and methods to layouts, reduces boilerplate, and enables image loading and onClick navigation with binding adapters in Android Jetpack Kotlin.

Bind a dog item to its layout with Android data binding, replacing findViewById and populating name and lifespan via a dog variable.

Implement image loading in the binding library with a binding adapter, loading a url into an image view via an extension function and integrating it into the layout.

bind method calls in a kotlin android app using data binding. implement a dog click listener and expose a hidden id to navigate to the detail fragment.

Apply the data binding approach to wire variables and layout elements in the detail fragment by instantiating the binding there, then experiment and prepare for the next lecture.

Bind the detail fragment using Android data binding to populate the UI with a dog’s image URL, breed, temperament, and lifespan, simplifying code and avoiding direct view access.