The Complete Android 16 Course [Part 3] - Become a Master

Add and customize markers on a Google map in Jetpack Compose, using marker state to track position and visibility, set Singapore as the marker, and configure title and snippet.

Customize map markers by applying a downloaded png icon with bitmap factory decode resource using context and drawable, then set the marker icon via bitmap descriptor factory from bitmap.

Implement marker click events in Google Maps for Android using onClick callbacks. Return true to consume the event and suppress the info window; return false to show it.

Explore how to create and customize polygons on Google Maps using the polygon composable, defining lat/long points, fill and stroke colors, and click events for interactive map regions.

Learn to create a ground overlay on an Android map using latlong bounds or a latlong anchor, with a bitmap descriptor for image, transparency, bearing, and clickability in map composables.

Learn to navigate Android updates and composable changes by implementing a ground overlay position from lat long bounds, then render a map overlay for historical maps.

Master map gesture handling by implementing single-tap clicks to place markers and capture lat long coordinates using a marker list and marker state in Google Map.

Master the map long click gesture in android, capture lat long from long clicks, and log positions in logcat while placing blue markers with customized icons.

Explore configuring google map UI settings to control zoom, gestures, compass, my location button, and location permissions, then display a marker at your current position.

Explore rotate and tilt map gestures using two-finger twist and vertical drag, with emulator controls (Ctrl and left click; right-click) and UI settings to enable or disable each motion.

Learn to customize marker interactions on Google Map by handling info window clicks and long clicks to remove markers, display toasts, or show images, using marker positions.

Enforce Manhattan bounds on Google Maps by using lat long bounds for the camera target, and restrict zoom with map properties to prevent scrolling outside the area.

Learn to customize the Google Maps camera position, including target lat long, zoom, tilt, and bearing, and animate to new markers with a one-second transition.

Add floating action buttons and user interface overlays inside a box layout for maps. Animate the camera position state to Paris with lat long and zoom.

Create a custom surface overlay on the map with material theming and rounded corners to host icons for map type toggle, current location, and reset camera controls.

Create a custom info window for map markers using mutable selected marker; handle click and long-click to add markers and display a card with title, lat, lon, and close button.

Learn to remove markers dynamically using a selected marker with a custom info window, handling both single-tap and long-press markers and updating the markers lists accordingly.

Learn to customize Google Maps with a personalized style by adjusting roads, landmarks, and labels, and applying color schemes via styling tools, JSON files, and Android Studio integration.

Apply a custom retro map style in Android by loading a retro_style.json from resources and using map style options to style roads, water, labels, and landmarks on Google Maps.

Learn to implement a Google Maps scale bar in Jetpack Compose by adding the widget, configuring camera position, and placing the overlay outside the map for reliable integration.

Create dynamic polylines and polygons on map by tapping to add markers, update a mutable lat-long list, render a blue polyline when two points exist, and reset with current location.

Create dynamic polygons on a map by extending dynamic polylines with a mutable lat-long state, adding points on long clicks, and enforcing a minimum of three points with magenta fill.

Fetch and display the current device location in Google Maps by adding the location services dependency, integrating Jetpack Compose with the activity lifecycle, and handling runtime location permissions.

Create a mutable location state and a permission launcher using activity result contracts in Jetpack Compose, request location permission at runtime, and fetch the current location if granted.

Implement a fetch current location function using the fused location provider client and context to obtain the last known location asynchronously, then invoke a callback to handle the result.

Fetch the current location with a callback, update the my location variable, and request the permission to display a marker and a 200m blue circle on Google Maps.

Fetch the current and live updated location using the fused location provider, building a high accuracy location request with a 10-second interval and a location callback.

Explore geocoding and reverse geocoding with the Android Google Maps integration, converting addresses to latitude and longitude and vice versa using the Geocoder and Play Services Location.

Learn to set up geocoding variables in Jetpack Compose, manage a search query and location with remember coroutine scope, and display a marker when location is non-null.

Design a geocoding overlay and implement a search bar that fetches geocoding results, moves the map camera to coordinates with zoom 15, and displays the address.

Master reverse geocoding by converting lat long to an address with a suspend function, using Geocoder.getFromLocation, dispatchers.io, and coroutine scopes to avoid UI blocking.

Geocoding and reverse geocoding with map gestures to fetch addresses and coordinates on marker clicks, updating the selected marker card and showing unknown addresses when needed.

Learn to enable and integrate the Google Places API in your Android app, enabling autocomplete and place details (name, address, photos, ratings) via build.gradle, manifest, and app initialization.

Learn to integrate the places API with Google Maps in Jetpack Compose, manage query and predictions with mutable state, and show autocomplete results in a lazy column.

Initialize a places client with the Google places API, fetch autocomplete predictions, and update a composable lazy column to display results as the user types.

Fetch place details via the Google Places API when a prediction is clicked, using fields like name, lat long, and address, then move the map camera to the selected place.

Learn marker clustering to reduce map clutter by grouping nearby markers at high zooms, expanding into individual markers as you zoom, using Google Maps libraries.

Master marker clustering in a composable function for Google Maps, define a clustering items list, handle cluster and cluster item clicks, and address type mismatches by creating a cluster item.

Create a Kotlin data class that implements cluster item, wrapping markers with position (lat long), title, snippet, and z-index, and pass a list to clustering to show markers and clusters.

Learn how to build a cluster items list in Android using cluster item data class, create 14 cluster item instances, and set up a cluster manager in the main activity.

Create and remember a cluster manager that handles clustering and rendering of marker items for Google Maps, utilizing Android context and compose local context.

Build a custom clustering workflow by defining a circle cluster composable with color, size, and text, then apply it to cluster content and visuals on maps.

Build an android maps app using Google Maps SDK, Firestore markers, MVVM with Hilt, fetch user location to draw routes between markers and enable map interactions with Jetpack Compose.

add firebase to an android studio project to store map markers and destinations in firestore. configure google services json and necessary gradle dependencies for seamless integration.

Add the Google Maps Platform SDK to your Android app by integrating maps, location, clustering, and polyline utils. Learn to fetch the current location and prepare for places API integration.

Add runtime permission handling and animations by integrating accompanist permissions, compose animations, and ViewModel with lifecycle 2.9.1, then include coroutines, and prepare for retrofit in upcoming steps.

Explore using Hilt for dependency injection and KSB for Kotlin symbol processing, set up plugins, apply the Hilt Android plugin, and integrate Hilt with navigation and view models for composables.

Learn to build a Google Maps composable in Jetpack Compose by creating an Uber Clone map, configuring camera position state with remember, and integrating map properties, styles, and UI elements.

Create a Google Cloud project for the Uber clone, enable Maps and Places APIs, obtain and restrict an API key with SHA1, and declare it in the Android manifest.

Create an expandable floating action button using a composable expandable fab with an expanded state, and reveal content with animated visibility featuring fade-in and vertical expansion at the bottom end.

Implement an expandable floating action button with two extended FABs and a main collapsed FAB, controlling expanded state, icons, text, and paddings via modifiers and animated visibility.

Add a disappearing scale bar to the maps compose widget that shows feet and meters when zoomed in and miles and kilometers when zoomed out, appearing on zoom changes.

Implement a marker repository using MVVM to upload latlong coordinates and names to firebase firestore, with a repository interface and a concrete implementation injected via hilt.

Add a marker by saving a latlong map to Firestore's markers collection, using document ID as the marker name with await in a suspend coroutine and custom exception handling.

Create a map view model annotated with Hilt view model for constructor injection of a marker repository, then add a marker via repository in Firebase and handle success or failure.

Define a Hilt module to provide Firebase Firestore and the marker repository via dependency injection with provides and singleton annotations, installed in the singleton component.

Inject a map view model with Hilt to test add marker, using a marker repository, lifecycle-aware scoping, and Android entry point annotation for dependency wiring.

Annotate the application class with Hilt Android app and declare its manifest name to enable singleton dependency injection container, supporting mvvm, clean architecture, Firestore markers latitude and longitude, design patterns.

Fetch all markers from the Firestore markers collection by implementing a suspend function that maps documents to destination markers with id, latitude, longitude, and title, applying defaults.

Load markers from Firestore into a ViewModel using a private mutable state flow, expose a public state flow, and display them on the Google Map via collect as state.

Learn how to manage map markers in Jetpack Compose using snapshot state list for recomposition, loading markers from Firestore, and updating the UI with add, remove, and clear operations.

Learn how to fetch real-time data from Firestore using Flow in Android Jetpack Compose, harnessing Kotlin coroutines for asynchronous, lifecycle-aware UI updates that recompose on data changes.

Learn to implement real-time updates with a Firestore markers snapshot listener, map documents to destination markers, and emit changes through a Kotlin Flow for the map UI.

Learn how callbackFlow, trySend, and awaitClose bridge Firebase Firestore callbacks to Kotlin flows, enabling non-blocking emissions and safe resource cleanup when a flow is canceled.

Enable real-time map markers by subscribing to Firestore with flow in the Android view model, using a single listener flag, and updating a snapshot state list of markers.

Define a location repository interface in Kotlin using StateFlow and mutable state to manage real-time location updates and permissions, with start and stop updates for an Android Jetpack Compose app.

Implement a location repository by implementing the interface, injecting dependencies, and exposing user location as a read-only state flow while managing a mutable has location permission flag.

Create a fused location provider client and a custom location callback to fetch location updates, update a mutable state flow with the latest latitude and longitude, and trigger UI updates.

Implement location updates using the fused location provider API by building a high-accuracy location request (10s interval, 5s fastest), and manage updates through a location callback and fused location client.

Update map view model to use location repository for fetching user location and handling permissions, then start or stop location updates on cleared and display a blue marker.

Discover how to request runtime location permissions in a Jetpack Compose app using remember multiple permission state for fine and coarse location, launching requests, and updating view model when granted.

Display the current user location on a Google map by wiring a view model to a location repository, requesting permission, and rendering a blue marker from location updates.

Build a Hilt location module that provides a singleton location repository using the application context, decoupling implementation from usage and enabling runtime permissions and Google Maps location updates.

Enable the Google Maps directions API, integrate Retrofit for fast, type-safe requests, and use a JSON converter (Moshi or Jackson) to serialize and deserialize directions data.

Learn how the directions API from Google Maps computes efficient routes for driving, walking, transit, and bicycle modes, and implement it with retrofit for type-safe http requests in Android.

Transform a messy directions API response into visible routes on the map by implementing a retrofit-based directions service, with base URL, endpoint, origin, destination, and API key.

Learn to model Google Maps directions responses with three Kotlin data classes: directions response, route, and polyline; encode and decode polylines for efficient, extensible route data.

Create a retrofit provider as a singleton that builds a directions service with a parameterized base URL and JSON converter. Centralize retrofit setup for directions API calls.

Create a directions repository with suspend functions to fetch routes from origin to destination and via waypoints, returning all markers as a polyline while honoring the 24-marker limit.

Implement the directions repository with javax.inject.Inject, inject api key and directions surface, convert origin and destination to strings, call the directions service, and decode polyline into lat/long.

Define a Dagger Hilt directions module to provide a singleton directions service via Retrofit, with Google Maps base URL, and repository injected with Maps API key using a named qualifier.

Run the app to display a route from the current position to a selected marker, fetch route points, and draw a red polyline on the map.

Learn to save map markers to Firestore, fetch them on launch, and draw a route from the current location to a selected marker using corrected logic.

implement a multi-marker routing feature by adding waypoints to the directions service, formatting intermediate points, and returning a polyline of lat long coordinates for map rendering.

Implement a map view model workflow to build a multi-point route by managing a mutable points list, adding markers, and fetching a route using origin, waypoints, and destination.

Learn to control multiple markers on a map using expandable floating action buttons to add markers, toggle placement, and draw routes between markers with a view model and mutable state.

Display user location and Firestore markers on a map, enable adding markers to a multiple points route, render a magenta polyline between points, and showcase multiple marker details and icons.

Add clear map functionality by implementing clear route, clear multi markers, and view model updates to reset route points, clear markers, and test the app.

Master machine learning with Android by exploring fundamentals and TensorFlow. Train models, run on-device inference with TensorFlow Lite, and integrate machine learning into Android apps with custom or prebuilt models.

Explore how machine learning, a subfield of artificial intelligence, learns from data to build models that make predictions in fraud detection, computer vision, autonomous vehicle predictive analytics, and personalized marketing.

Explore real-world machine learning applications such as facial recognition, self-driving cars, natural language processing, social media optimization, spam filtering, and product recommendations.

Learn how a trained model uses features to predict the target, and how training teaches the model by showing many examples.

Explore how supervised, semi-supervised, unsupervised, and reinforcement learning drive descriptive, predictive, and prescriptive analytics in fraud detection, computer vision, and autonomous systems.

Master supervised learning by using labeled data to train models, perform classification and regression, and evaluate accuracy on 80% training and 20% testing to predict unseen data.

Semi-supervised learning trains models using both labeled and unlabeled data, then retrains on labeled data to boost accuracy, aiming to predict outputs from inputs with minimal labels.

Explore unsupervised learning, analyzing data without labels to discover hidden patterns, grouping with clustering, dimensionality reduction like PCA, and association rule mining.

Reinforcement learning trains agents to maximize rewards through trial and error in an environment, with the agent observing states, taking actions via a policy, and updating an MDP value function.

Learn to use Google Colab, a free cloud platform to write and run Python in your browser, using notebooks, GPUs/TPUs, and popular ML libraries for data analysis and prototyping.

Discover Google Colab features, GPU and TPU access, notebook uploads to Drive, and preinstalled machine learning libraries like TensorFlow, PyTorch, and OpenCV. Be aware of free-tier limits and paid GPUs.

Master basic Python data types including integer, float, string, and boolean. Explore the type function, casting between types, string literals, and boolean expressions.

Explore arithmetic operators in Python, including addition, subtraction, multiplication, division, floor division, modulus, and exponentiation. Apply practical examples with a and b to see how these operators compute results.

Learn about comparison operators and boolean logic in Android, including equals, not equals, greater than or equal, less than or equal, and, or, and not to combine conditions.

Learn to print outputs and create strings in Python using concatenation with plus and string literals. Explore the len function for string length and f-strings for formatted values like names.

Complete a practice exercise by prompting for two numbers, converting inputs to integers, and displaying their sum with a formatted print, illustrating data type awareness and avoiding string concatenation.

Recap covers creating variables and basic data types, arithmetic, comparison and logical operators, printing and formatting strings, and getting user input, forming the foundation of Python programming.

Learn to make decisions with if, elif, and else; repeat tasks with for and while loops; store items in lists; and create reusable code with functions, using notebooks and resources.

Master Python conditional statements using if, elif, and else to decide with nested conditions and permission checks, showing age-based messages like you are old enough to vote.

Learn to use for loops to iterate over lists, tuples, dictionaries, sets, and strings, and to control iterations with range and break.

Master while loops in Android by running code while a condition is true, avoiding infinite loops, with else blocks and user input prompts exiting when quit is typed.

Learn to create and manipulate lists by adding, removing, and accessing items, including negative indexing. Print lists, determine length with len, modify elements, append, remove, and loop through items.

Explore how functions organize code with def, parameters, and return values in Python. Learn how to call functions, pass arguments, use default parameters, and handle errors when arguments mismatch.

Create a simple calculator using four functions: add, subtract, multiply, and divide, perform arithmetic operations, guard against division by zero, and test the results.

Master decisions with if, elif, else; loop with for and while; store data in lists and dictionaries; handle errors with try/except, and work with files.