Android Jetpack masterclass in Java

Install Android Studio on a Mac from android.com, open the app, start a project, and use an emulator with a Nexus 6 and Oreo images for testing.

Learn to debug and run apps on a real Android device by enabling developer options and USB debugging, then connect your device to Android Studio to test directly on hardware.

Understand Android X, the new repository for Google support libraries linked to jetpack, and learn to switch from the old support libraries. Android X libraries are independent and backwards compatible.

Create a new Android Studio project using the empty activity template in Java, set API level 15, enable AndroidX, and explore main activity, layout, manifest, and Gradle files.

Import and configure external libraries for the project by editing module and project Gradle files, defining version variables, and syncing to integrate AndroidX, navigation, retrofit, room, and other dependencies.

Delve into Android navigation with Jetpack, managing screen transitions between one activity and multiple fragments, and leveraging back stack, argument passing, transitions, and deep linking via a navigation graph.

Set up the navigation foundation by creating a navigation graph with two fragments (list fragment and detail fragment) and a host in the main activity.

Update the list and detail fragment layouts with constraint layout, center a text view in each, and add a floating action button to navigate between the two screens.

Wire the floating action button to a generated navigation action using a nav controller and directions, binding with butter knife and a click listener to move to details.

Wire the detail fragment's floating action button using butter knife. Set an on click listener to trigger the action list and move to the list fragment.

Attach an action to the detail fragment's floating action button and navigate to the list via an on click listener using the navigation component.

Discover how the Android Jetpack navigation system uses arguments to transfer data between list and detail fragments, including a dog id, and enables deep links and animations.

During cleanup, the lecture removes the floating action button and text views from the list and detail fragments, while preserving the dog ID argument and binding, leaving the navigation intact.

Discover how Android layouts define a UI screen by organizing views and view groups with linear, relative, and constraint layouts, plus efficient RecyclerView, using XML and the visual editor.

Create a fragment list layout with a swipe refresh layout, a recycler view for dogs, an error message, and a centered loading indicator, enabling pull-to-refresh and clean state transitions.

Design a reusable list item using a horizontal linear layout with an image and two text fields (name and lifespan), leveraging weights, padding, and styles for a responsive user interface.

Design a details fragment layout for a dog screen with a top image and stacked text views using a relative layout. Align elements and explore image scaling.

Understand Android lifecycles by exploring activities, fragments, and view models, and implement live data for lifecycle-aware data streams within the mvvm architecture.

Create the model layer in the Android Jetpack masterclass by defining a dog breed pojo with public fields and a generated constructor, ready for Retrofit API data and database use.

Create a Java recycler view adapter for a dog list, including a view holder, get item count, binding name and lifespan, inflating item_dog layout, and updating the list with notifyDataSetChanged.

Build a simple list view model that extends Android view model and uses mutable live data to expose a dog breed list, loading, error states, and a refresh method.

Complete the a.T.M architecture by wiring a view model and live data to the dogs list fragment, display data in a recycler view, and handle loading and errors.

Implement the detail screen in Android Jetpack masterclass in Java by creating a detail view model, navigating to the detail fragment, and binding dog breed data: name, purpose, temperament, lifespan.

Discover how Retrofit, a third‑party library, simplifies fetching data from a backend API in Java Android apps, mapping responses (JSON or XML) to Podio objects.

RxJava is a reactive, asynchronous library for Android that uses observables and observers to react to events, with single emitting a value or error, used with retrofit and view model.

Implement Retrofit in Java to fetch dog breeds from a backend API, defining the dogs API interface and a Retrofit service with a base URL and Gson converter.

Learn to fetch remote data with retrofit and RxJava, wiring a dogs API service to display dog breeds and lifespans while managing loading states and errors.

Explore Glide, a lightweight third-party library for image loading and caching in Android, which loads images from a URL into an ImageView on a background thread.

Implement Glide to load images with a circular progress drawable as a per-image placeholder and an error icon, using request options and an adapter call to display backend image URLs.

Learn how the Room library provides a local database abstraction with entities, DAOs, and generated classes to store, retrieve, and manage data with compile-time checks and background-thread access.

Map the dog breed model to a room database by annotating fields with columnInfo, defining column names, and allowing a database-generated primary key for unique ids.

Store dog data in a local database via a background async task, deleting old records, inserting new ones, and updating the UI on completion while preventing memory leaks.

Retrieve data from the Room database and display dog breeds on screen using a dedicated async task, with a loading indicator and post-execute update.

Learn how to use shared preferences in Jetpack to store key-value configuration across app restarts, using default or custom locations and committing changes via lambda expressions.

Implement a simple caching mechanism using shared preferences to switch between remote and database data, ensuring fresh data within a five-minute cache window and singleton access.

Implement a swipe-to-refresh that bypasses the cache and fetches data from the remote endpoint, updating the timestamp and showing a loading indicator during refresh.

Implement list-to-detail navigation by wiring item click to a detail action, pass the dog UUID, and fetch dog data asynchronously in the detail view model to display info and image.

implement the detail screen by retrieving a dog by id from the database using a view model, observe live data, and display the breed information and image URL.

Explore data binding in Android Jetpack masterclass, a library that attaches data and methods to layouts, reducing boilerplate and tightening the separation of concerns.

Implement data binding in the item dog layout to display breed and lifespan directly from the dog object, replacing findViewById usage in the adapter.

Create a binding adapter using the binding adapter annotation to load images by adding an image-url parameter to an image view and using Glide to load the URL with caching.

Learn to bind UI events to methods using a click listener, pass a dog id from the layout, and navigate to a detail fragment with data binding.

Take on a challenge to implement data binding for the detail fragment, mirroring the item dog setup by updating the layout to inherit a layout type and bind variables.

Bind the detail fragment with data binding, inflate the layout, and populate dog attributes such as image, name, purpose, temperament, and lifespan from a dog breed.