Professional Android in Kotlin

Learn to design android layouts with constraint layout, card view, and text view, using the layout editor to drag and drop UI elements, set text, color, and elevation.

Explore how to display images with drawable resources in Android Kotlin by configuring ImageView properties, setting height and width constraints, margins, and alignment to achieve the final layout.

Define and implement click listeners in the main activity to update the title and email views when clicked, wiring onClick events to IDs and updating text.

Explore Kotlin data class concepts by comparing data classes with regular classes. Learn how data classes store name and quantity, use copy, and compare by value instead of reference.

Learn how to programmatically update view properties in Android with Kotlin by modeling UI data in a data class and binding resources and text to UI elements.

Learn to extract and reuse a card view layout for a RecyclerView, creating a separate item layout isolated from the activity layout using Android Studio.

Learn to create a recycler view and its adapter, define a view holder, bind data to ui elements, and display a list using a layout.

Wire the previously defined adapter to a recycler view and set a linear layout manager to display a list of items, then run the app to verify rendering.

learn to add a new item to an existing recycler view adapter in Android Kotlin by using a mutable list, defining an update function, and notifying item changes.

Refactor code to improve stability and manageability in Android Studio, leverage shortcuts, create an editor file, import UI elements, and separate data from UI for a leaner, more organized project.

Implement a view model in an Android Kotlin app, expose lifecycle-aware data to the main activity, and drive a to-do list UI via an adapter.

Learn to use LiveData to observe a background video upload and update the UI when it completes, and distinguish MutableLiveData from LiveData exposed via a view model.

learn to use live data in an Android Kotlin app by exposing private mutable data as public live data and observing changes to refresh the user interface adapter.

Connect an Android Kotlin app to the internet, fetch JSON data from an endpoint, parse it into data classes, and display results while handling permissions.

Learn to configure coroutine dependencies for Android, use a CoroutineScope with a Dispatcher, and launch coroutines on the default background dispatcher for efficient processing.

Create and manage a custom coroutine scope with a background dispatcher, cancel resources automatically, and use supervisor job to prevent one failed child from canceling others.

learn to implement suspending functions in Kotlin to encapsulate network calls inside a coroutine scope, highlighting how to mark functions with suspend and call them from within coroutines.

Learn to instantiate a view model with a custom constructor using a view model factory, and move dependencies like a service into the constructor to improve testability and maintainability.

Refactor the android app by packaging code into ui and service modules, organizing main activity, todo list display adapter, and a view model with data classes.

Move the UI logic from the main activity to a new fragment, consolidating the title and layout, and use lifecycle methods like onCreate and onCreateView, noting that arguments are optional.

Create fragments programmatically in the main activity, organize them into a fragment family, and manage them with a fragment manager to ensure compatibility across older Android versions.

Learn to implement the Android navigation component by creating a navigation graph, adding fragments, and controlling navigation with a nav controller for seamless screen transitions.

Create a new add-to-do fragment and wire it to navigate from the current fragment using a nav controller and a default transition animation.

Learn how to share a view model across fragments with activity view models, connect edit texts to a unified UI, and navigate between fragments using a common activity scope.

Use Glide in a Kotlin adapter to load circular-cropped internet images and handle clicks to show a larger image; configure the Gradle dependency and adapter initialization in a fragment.

Move remote calls to a remote service, making it the single source of todo data, while the view model handles UI logic and the model maintains the list.

Navigate from the home screen to the edit screen, implement a singleton to manage the edit fragment, and apply reactive data flow to ensure changes appear on return.

Apply unidirectional data-flow to fix the edit screen update, propagating changes through the model and remote service with reactive streams that update the display fragment.

Integrate the database with the Android app using layered architecture, expose data via a remote service, and connect it to activities and fragments for smooth, decoupled data flow.