State of the Art Android app development in Java

Install Android Studio on a Mac by downloading from developer.android.com/studio, opening the installer, and dragging it to applications; then create a Nexus 6 with Oreo 8.1 to test.

Install Android Studio on a Windows PC from developer.android.com/studio, create a test project, and configure a virtual device with Oreo and Lollipop images; rebuild to fix errors.

Enable developer options and USB debugging on your real device, connect it to Android Studio, and run apps directly on your phone for testing instead of an emulator.

Create a new Android Studio project in Java with an empty activity, name your app, set min API level 15 and AndroidX artifacts, and explore build.gradle and the project structure.

Add and configure libraries by updating the module and project Gradle files, set Java 1.8, enable data binding, define library versions, add dependencies, then sync and verify the build.

Explore how Android navigation, a Jetpack component, simplifies fragment travel. Use navigation graphs, the nav host fragment, and the nav controller to manage destinations, back stack, and deep linking.

Learn navigation for an Android app by building two fragments and moving between them with a navigation framework. Organize the project with a model view viewmodel structure and packages.

Create a navigation element, add fragment list and fragment detail, define actions to go to details and back to list, then attach the navigation graph to a nav host fragment.

Bind the list fragment's floating action button with Butter Knife, use a generated directions action to go to details, and navigate with findNavController; test the details and back navigation.

Take on a hands-on challenge to implement the retrieve action in the details fragment, renaming the on click button and wiring its action, building on previous lessons.

Navigate between detail and list fragments using a floating action button, pass animal id arguments, and enable up navigation and default animations with the navigation framework.

Clean up the project by removing unused UI elements and bindings in the fragment list and details screens, leaving empty placeholders while preserving navigation for future lectures.

Explore Android lifecycles, life data, and MVVM architecture, focusing on lifecycle aware view models and how they prevent memory leaks and manage configuration changes for robust apps.

Create an animal model and a list view model in the MTM architecture, supplying animal data to the view and managing loading and error states with mutable live data.

Build the screen with a recycler view inside a swipe refresh layout, including a spinner and error text. Create an item layout for each animal with image and name.

Create an adapter class to bind a list of animal models to a recycler view, using a view holder and item layout, updating names (and future images) from the backend.

Finish wiring the list fragment by integrating the model, layout, adapters, and view model, enabling swipe refresh, grid layout, and loading and error state handling.

Integrate retrofit with a Java app to fetch data from a backend API, map it to pojo objects via an interface of endpoints and service class, and handle json data.

Learn to fetch a key from a backend api and use it to request animal data, mapping api fields to Java models with Retrofit and SerializedName annotations.

Create an animal api interface and service to fetch api key and animals with retrofit. Configure base url, converter factory, and the call adapter factory to return single observables.

Retrieve backend data by calling get key to obtain a key, then fetch animals with that key using retrofit and RxJava, showing a loading spinner and using a composite disposable.

Load images with Glide in a Java Android app via a YouTube utility, show a circular progress spinner and placeholder, then integrate in the list adapter and remove edge margins.

Store the API key in shared preferences and reuse it to fetch animals, reducing network calls while validating the key when an error occurs.

Set up the detail fragment layout for an animal with a vertical linear layout, centered content, an image, and text views for name, location, lifespan, and diet.

Display animal details on the detail screen by passing a full animal object via navigation, making the animal model Parcelable, and populating image, name, location, lifespan, and diet.

Explore how the Android Jetpack palette library extracts colors from images to drive app theming and apply vibrant or muted tones to UI elements, including the detail fragment background.

Use the palette library to extract a color from the animal image via glide and apply it as the detail background. Guard against missing swatches and try alternate colors.

Explore data binding in Android app development, binding variables and methods to layouts, using binding adapters and custom adapters to bind image URLs and reduce boilerplate code.

Enable data binding in the Android app by converting the item layout to a data binding layout, declaring an animal variable, and binding the animal name to the text view.

Create a binding adapter to load images into an image view via a custom android:image you are attribute, enabling memory-efficient loading without glide.

Bind method calls in Android app development with data binding to handle animal item clicks, retrieve items by tag, and navigate to a detail fragment.

Apply the data binding model to transform the details screen layout, bind text and image views in the fragment and its java class, and rebuild to regenerate binding classes.

Implement the detail fragment with data binding to populate the animal detail screen and apply a color palette for the background.

Explore dependency injection in Android using Dagger 2 to separate object creation from usage, enabling testing and flexibility with modules, components, and annotations like @Inject, singleton, qualifiers, and shared preferences.

Learn to inject the animal api service with dagger 2 by using a module and component. This approach separates object creation from use and supports unit testing of specific functionality.

Extend your learning by injecting an animal API service into the listing model and view model, reusing the module and creating an interface for the new model.

Inject the animal API service into the list view model using Dagger, by adding a provides method in the API module and a view model component, then verify successful injection.

Explore advanced dagger features by injecting a shared preferences helper through app and preferences modules. Use a context qualifier to select app vs activity context and implement a singleton.

Unit tests verify existing code by automating checks to ensure current functionality remains correct when the app changes. They test business logic with the Mosquito library and avoid Android components.

This lecture covers setting up android java unit tests in the test package, testing list view model functions like get key and get animals, with immediate schedulers for threads.

Create mock objects by overriding dagger modules to supply fake shared preferences and a mocked animal API service, then inject them into the list view model for isolated unit testing.

test the animals api success path by simulating a valid key, mocking get animals responses, and verifying the listing model reflects a single animal without loading or errors.

Test the animals API failure path by simulating get animals and get key calls to trigger the error loop and verify the loading and error states.

Implement test for the get key functionality by creating two functions for success and failure, ensuring preferences are set and correct animals information is assigned when get animals is reached.

Test the get API key flow with unit tests, covering success and failure using mocks, refreshing the listing model to trigger get animals, and ensuring independent, fast tests.

Practice what you learned by refactoring your Android app into an MVNO architecture, implement dependency injection, and write unit tests to future-proof your project while exploring libraries that reduce boilerplate.

Celebrate completing the course - you've joined the top 5 percent of students - by implementing the code, building the Android app locally, and mastering the concepts discussed.