Skip to main content
Mapagam

60 SECTIONS · 1755 TOPICS

Android Kotlin Roadmap

  1. Working with Kotlin Fundamentals

    1. 1. Declaring Variables
    2. Example: Variable Declaration
    3. 2. Understanding Null Safety (?, !!, ?:, ?.let)
    4. Example: Safe Navigation with
    5. Example: Using the Elvis Operator
    6. Example: Using
    7. 3. Using Type Inference and Explicit Types
    8. Example: Type Inference in Action
    9. Example: Explicit Type Declaration
    10. 4. Working with String Templates ($variable, ${expression})
    11. Example: Escaping Dollar Sign
    12. 5. Creating Data Classes
    13. Example: Using Data Classes
    14. 6. Using Extension Functions (fun Type.functionName)
    15. Example: Adding a method to List
    16. Example: Extending a Class with Properties
    17. 7. Implementing Higher-Order Functions
    18. Example: Using Higher-Order Functions Together
    19. 8. Using Scope Functions
    20. 9. Working with Sealed Classes and Interfaces
    21. Example: Sealed Class Usage
    22. Example: Sealed Interface Usage
    23. Key Points
    24. 10. Understanding Object Declarations and Companion Objects
    25. Example: Object Declaration
    26. Example: Companion Object
    27. Object Declaration vs Companion Object
    28. 11. Using Inline Functions
    29. Example: Basic Inline Function
    30. Example: Using
    31. Example: Using
    32. 12. Working with Type Aliases
    33. Example: Defining a Type Alias
    34. Example: Using Type Aliases for Complex Types

  2. Understanding Kotlin Control Flow

    1. 1. Using If Expressions
    2. Example: Nested If Expressions
    3. 2. Working with When Expressions
    4. Example: Using When with String Values
    5. Example: When with Type Checks
    6. 3. Implementing For Loops
    7. Example: Looping with Index
    8. 4. Using While and Do-While Loops
    9. Example: While Loop
    10. Example: Do-While Loop
    11. Key Differences
    12. 5. Applying Break and Continue
    13. Example: Using break in nested loops
    14. Example: Using continue in nested loops
    15. 6. Using Return with Labels (@label)
    16. Example: Using Labels to Break Nested Loops
    17. Example: Using Labels with Return
    18. 7. Implementing Try-Catch as Expression
    19. Example: Try-Catch Expression
    20. 8. Using Safe Calls and Elvis Operator (?., ?:)
    21. Example: Safe Calls in a Function
    22. Example: Chaining Safe Calls
    23. 9. Working with Not-Null Assertion (!!)
    24. Example: Using !! to Force Non-Null Value
    25. Example: Runtime Exception with !!
    26. 10. Implementing Smart Casts
    27. Example: Smart Cast in Conditional
    28. Example: Using

  3. Working with Kotlin Data Types

    1. 1. Using Primitive Types
    2. Example: Declaring and Using Primitive Types
    3. 2. Working with String Type
    4. Example: String Concatenation
    5. Example: String Templates
    6. Example: Multiline Strings
    7. Example: String Manipulation
    8. 3. Understanding Number Conversions
    9. Example: Safe Conversion with Range Checks
    10. 4. Using Arrays
    11. Example: Declaring and Initializing Arrays
    12. Example: Modifying Mutable Arrays
    13. Example: Array Operations
    14. 5. Working with Nullable Types (Type?, safe calls)
    15. Example: Safe Call Usage
    16. Example: Elvis Operator
    17. 6. Implementing Ranges
    18. Example: Using Ranges in a Loop
    19. Example: Checking Membership in a Range
    20. Example: Creating a Char Range
    21. 7. Understanding Nothing Type
    22. Example: Function Returning Nothing
    23. Example: Infinite Loop
    24. 8. Using Any and Unit Types
    25. Example: Using Any for Polymorphism
    26. Example: Using Unit in Functions
    27. 9. Working with Pair and Triple
    28. Example: Creating and Using Pair
    29. Example: Creating and Using Triple
    30. Example: Destructuring Pair and Triple
    31. Example: Pair and Triple in Functions
    32. 10. Implementing Type Checks and Casts
    33. Example: Type Checking and Casting

  4. Working with Kotlin Object-Oriented Programming

    1. 1. Creating Classes
    2. Example: Basic Class Usage
    3. 2. Implementing Constructors
    4. Example: Using Primary Constructor with Initialization
    5. Example: Secondary Constructor with Delegation
    6. 3. Working with Properties
    7. Example: Delegated Properties
    8. Example: Computed Properties
    9. Example: Mutable vs Read-Only Properties
    10. 4. Implementing Inheritance
    11. Example: Basic Inheritance
    12. 5. Using Abstract Classes
    13. Example: Implementing Abstract Class
    14. 6. Creating Interfaces
    15. Example: Implementing an Interface
    16. Example: Multiple Interface Implementation
    17. Key Points About Interfaces
    18. 7. Implementing Visibility Modifiers
    19. Example: Using Visibility Modifiers
    20. 8. Using Data Classes
    21. Example: Data Class Usage
    22. 9. Implementing Enum Classes
    23. Example: Using Enum in Switch-like Logic
    24. Example: Enum with Constructor Parameters
    25. Key Points About Kotlin Enums
    26. 10. Working with Sealed Classes
    27. Example: Sealed Class Usage
    28. Key Points About Sealed Classes
    29. 11. Using Nested and Inner Classes
    30. Example: Nested and Inner Classes
    31. 12. Implementing Delegation
    32. Example: Interface Delegation
    33. Example: Property Delegation

  5. Working with Kotlin Generics

    1. 1. Creating Generic Classes
    2. Example: Basic Generic Class
    3. Example: Generic Class with Constraints
    4. 2. Implementing Generic Functions
    5. 3. Using Variance
    6. Example: Covariance in Collections
    7. Example: Contravariance in Function Types
    8. 4. Implementing Covariance
    9. Example: Covariant Producer
    10. Example: Contravariant Consumer
    11. 5. Implementing Contravariance
    12. Example: Using Contravariance in Function Parameters
    13. Example: Contravariance in Collections
    14. 6. Using Type Projections (star projection *)
    15. Example: Star Projection in Lists
    16. Example: Star Projection in Function Parameters
    17. 7. Applying Generic Constraints
    18. Example: Using Upper Bound Constraint
    19. 8. Understanding Type Erasure
    20. Example: Runtime Type Check Limitation
    21. Key Points
    22. 9. Using Reified Type Parameters
    23. Example: Using Reified Type Parameters
    24. 10. Working with Generic Extensions
    25. Example: Safe List Access

  6. Understanding Kotlin Collections

    1. 1. Working with Lists
    2. Example: Filtering Lists
    3. Example: Mapping Lists
    4. 2. Working with Sets
    5. Example: Set Operations
    6. 3. Working with Maps
    7. Map Operations Summary
    8. 4. Using Collection Functions
    9. Example: Filtering and Mapping
    10. Example: Reducing Collections
    11. Example: Sorting and Ordering
    12. 5. Iterating Collections
    13. Example: Using
    14. Example: Using
    15. 6. Transforming Collections
    16. Example: Using map and flatMap together
    17. 7. Searching Collections
    18. Search Methods Summary
    19. 8. Sorting Collections
    20. 9. Using Sequences for Lazy Evaluation
    21. Example: Lazy Evaluation with Sequences
    22. 10. Converting Between Collection Types
    23. Example: Converting List to Set
    24. Example: Converting List to Map
    25. 11. Partitioning Collections
    26. 12. Working with Collection Operations
    27. Example: Filtering and Transforming Collections
    28. Example: Using fold to Build a String

  7. Working with Kotlin Coroutines

    1. 1. Understanding Coroutine Basics
    2. Example: Basic Coroutine Usage
    3. Key Points
    4. 2. Using Dispatchers
    5. Example: Using Dispatchers.IO for Network Call
    6. Example: Switching Dispatchers
    7. 3. Implementing Suspend Functions
    8. Example: Basic suspend function usage
    9. Example: Suspend function with exception handling
    10. 4. Using CoroutineScope
    11. Example: Creating and Using CoroutineScope
    12. Example: Using GlobalScope
    13. 5. Handling Coroutine Exceptions
    14. Example: Catching Exceptions in Coroutines
    15. Example: Using SupervisorScope for Exception Isolation
    16. Exception Handling Best Practices
    17. 6. Using Flow for Streams
    18. Example: Basic Flow Usage
    19. Example: Flow with emit()
    20. Key Features of Flow
    21. 7. Transforming Flows
    22. 8. Combining Flows
    23. 9. Working with StateFlow and SharedFlow
    24. Example: Using StateFlow
    25. Example: Using SharedFlow
    26. Key Differences
    27. 10. Using Channel for Communication
    28. Example: Producer-Consumer Pattern
    29. Example: Using BroadcastChannel
    30. Key Points
    31. 11. Implementing Deferred Results
    32. Example: Using Deferred to Fetch Data
    33. Example: Handling Deferred with Timeout
    34. 12. Cancelling Coroutines
    35. Example: Canceling a Coroutine

  8. Setting Up Project Configuration

    1. 1. Configuring build.gradle Files
    2. Example: Adding a dependency
    3. 2. Setting Kotlin Version and Compiler Options
    4. Example: Gradle Configuration
    5. 3. Configuring Android SDK Versions
    6. Example: build.gradle.kts (app level)
    7. 4. Setting Up Build Types
    8. Example: Configuring Build Types in build.gradle.kts
    9. 5. Configuring Product Flavors
    10. Example: Defining Product Flavors
    11. Example: Adding Flavor-Specific Resources
    12. Key Points
    13. 6. Managing Dependencies
    14. Example: Adding Dependencies to build.gradle.kts
    15. Dependency Management Best Practices
    16. 7. Setting Up ProGuard Rules
    17. Example: Basic ProGuard Configuration
    18. ProGuard Rule Categories
    19. 8. Configuring Build Features
    20. Example: Build Types Configuration
    21. Example: Product Flavors
    22. 9. Setting Application ID and Version
    23. Example: app/build.gradle.kts
    24. 10. Configuring Signing Configs
    25. Example: Signing Config in build.gradle.kts
    26. 11. Using Version Catalogs
    27. Example: Defining a version catalog in
    28. Example: Using version catalog in
    29. 12. Configuring Compose Compiler
    30. Example: Configuring Compose Compiler in build.gradle.kts

  9. Managing App Configuration

    1. 1. Using BuildConfig
    2. Example: Accessing BuildConfig in Kotlin
    3. 2. Creating Build Variants
    4. Example: Build Variant Configuration in build.gradle.kts
    5. 3. Setting Application Class
    6. Example: Custom Application Class
    7. Example: Registering Application Class in Manifest
    8. 4. Initializing in Application
    9. Example: Application Class Initialization
    10. 5. Using AndroidManifest.xml
    11. Example: Declaring an Activity
    12. Example: Declaring Permissions
    13. 6. Setting Activity Attributes
    14. Example: Declaring Activity in Manifest
    15. 7. Configuring Application Theme
    16. Example: Define a Custom Theme
    17. Example: Apply Theme in Manifest
    18. 8. Using Metadata Tags
    19. Example: Reading Metadata in Kotlin
    20. 9. Setting Up Deep Link Handling
    21. Example: Declaring Deep Link in Manifest
    22. Example: Handling Deep Link in Activity
    23. 10. Managing Feature Flags
    24. Example: Feature Flag Usage in Kotlin

  10. Managing Activity Lifecycle

    1. 1. Understanding Lifecycle States
    2. Example: Lifecycle Callbacks in Kotlin
    3. 2. Implementing onCreate() Method
    4. Example: Implementing onCreate()
    5. 3. Implementing onStart() and onStop() Methods
    6. Example: Implementing onStart() and onStop()
    7. 4. Implementing onResume() and onPause() Methods
    8. Example: Implementing onResume() and onPause()
    9. 5. Implementing onDestroy() Method
    10. Example: Implementing onDestroy()
    11. 6. Handling Configuration Changes
    12. Example: Handling Screen Rotation
    13. Example: Manifest Declaration
    14. 7. Saving Instance State
    15. Example: Saving and Restoring UI State
    16. 8. Restoring Instance State
    17. Example: Saving and Restoring State
    18. 9. Using Lifecycle Observers
    19. Example: Implementing Lifecycle Observer
    20. Example: Attaching Observer to Lifecycle
    21. Key Points
    22. 10. Managing Activity Launch Modes
    23. Example: Setting Launch Mode in Manifest
    24. 11. Implementing Predictive Back Gesture
    25. Example: Enabling Predictive Back Gesture
    26. 12. Using Edge-to-Edge Display
    27. Example: Enabling Edge-to-Edge Display
    28. Example: Setting Status Bar Color

  11. Working with Fragments

    1. 1. Creating Fragment Classes
    2. Example: Basic Fragment Class
    3. 2. Implementing Fragment Lifecycle Methods
    4. Example: Implementing Lifecycle Methods
    5. 3. Adding Fragments
    6. 4. Replacing and Removing Fragments
    7. Example: Replacing a Fragment
    8. Example: Removing a Fragment
    9. 5. Managing Fragment Backstack
    10. Example: Adding Fragment to Backstack
    11. Example: Clearing Backstack
    12. Backstack Management Tips
    13. 6. Passing Data Between Fragments
    14. Example: Passing Data Using Bundle
    15. Example: Receiving Data in FragmentB
    16. 7. Communicating with Activity
    17. Example: Accessing Activity from Fragment
    18. Example: Handling Activity Callbacks
    19. 8. Using Fragment Result API
    20. Example: Sending and Receiving Fragment Results
    21. 9. Handling Fragment Transactions
    22. Example: Basic Fragment Transaction
    23. Example: Fragment Transaction with Animation
    24. 10. Using DialogFragment
    25. Example: Creating a Custom DialogFragment
    26. Workflow: Showing a DialogFragment

  12. Working with Intents and Navigation

    1. 1. Creating Explicit Intents
    2. Example: Launching an Activity with Intent
    3. Example: Passing Data with Intent
    4. 2. Creating Implicit Intents
    5. Example: Opening a Web Page
    6. Example: Sharing Text
    7. 3. Starting Activities
    8. Example: Starting an Activity
    9. Example: Starting an Activity with Data
    10. 4. Passing Data with Intents
    11. 5. Using Intent Filters
    12. Example: Handling Intent Filters in Android Manifest
    13. Example: Filtering for Web Content
    14. 6. Handling Intent Results
    15. Example: Using registerForActivityResult
    16. Key Points
    17. 7. Using Activity Result Contracts
    18. Example: Using Activity Result Contracts to Request Permissions
    19. 8. Implementing Deep Links
    20. Example: Deep Link Intent
    21. 9. Using PendingIntents
    22. Example: Using PendingIntent in Notification
    23. 10. Sharing Data with ShareSheet
    24. Example: Sharing Text
    25. Example: Sharing an Image

  13. Using Navigation Component

    1. 1. Setting Up Navigation Graph
    2. Example: Basic Navigation Graph Setup
    3. 2. Configuring NavHost Fragment
    4. Example: NavHost Fragment in XML
    5. 3. Navigating Between Destinations
    6. Example: Navigation in Kotlin
    7. 4. Passing Arguments
    8. Example: Passing Arguments in Navigation
    9. Example: Passing Arguments in Navigation Graph
    10. 5. Using Navigation Actions
    11. Example: Using Navigation Actions in a Fragment
    12. 6. Handling Deep Links
    13. Example: Define Deep Link in Navigation Graph
    14. Example: Handle Deep Link in Activity
    15. 7. Implementing Conditional Navigation
    16. Example: Conditional Navigation in Fragment
    17. 8. Using Bottom Navigation with NavController
    18. Example: Setting up Bottom Navigation with NavController
    19. Key Points
    20. 9. Managing Navigation Backstack
    21. Example: Clearing the Back Stack
    22. Example: Adding to Back Stack
    23. Workflow: Managing Back Stack
    24. 10. Navigating with Animations
    25. Example: Slide Animation
    26. Example: Fade Animation
    27. 11. Using Navigation Compose
    28. Example: Basic Navigation Compose Setup
    29. Example: Passing Data Between Screens
    30. Example: Navigation with Deep Links

  14. Building Traditional UIs

    1. 1. Creating Layouts
    2. Example: LinearLayout with Vertical Orientation
    3. Example: ConstraintLayout with Basic Constraints
    4. 2. Using Common Views
    5. Example: Layout with Common Views
    6. 3. Setting View Properties
    7. Example: Setting View Properties in XML
    8. Example: Setting View Properties Programmatically
    9. 4. Handling Click Events
    10. Example: Basic Click Handler
    11. Example: Handling Different Views
    12. 5. Using ViewBinding
    13. Example: Enabling ViewBinding in a Module
    14. Example: Using ViewBinding in an Activity
    15. Example: Accessing Views with ViewBinding
    16. 6. Using Data Binding
    17. Example: Basic Data Binding Setup
    18. Example: Layout with Data Binding
    19. 7. Using LayoutInflater
    20. Example: Inflating a Layout
    21. 8. Setting View Dimensions
    22. Example: Setting Fixed Dimensions
    23. Example: Using Match Parent
    24. 9. Applying Styles and Themes
    25. Example: Applying a Custom Theme
    26. Example: Using Theme Attributes in Layout
    27. Theme Application Summary
    28. 10. Creating Custom Views
    29. Example: Custom Circle View
    30. Key Concepts
    31. 11. Implementing ViewGroups
    32. Example: Custom ViewGroup with Layout Logic
    33. Key Concepts

  15. Building UIs with Jetpack Compose

    1. 1. Creating Composable Functions
    2. Example: Basic Composable Function
    3. Example: Composable with State
    4. 2. Using Basic Composables
    5. Example: Simple Text Display
    6. Example: Button with Action
    7. 3. Implementing Layouts
    8. Example: Basic Column and Row
    9. Example: Using Box for Overlays
    10. Example: Nested Layouts
    11. 4. Managing State
    12. Example: Basic State with mutableStateOf
    13. Example: State with ViewModel
    14. State Management Best Practices
    15. 5. Using Modifiers
    16. Example: Combining Modifiers
    17. 6. Handling User Input
    18. Example: Handling Text Input
    19. Example: Handling Button Clicks
    20. 7. Using LazyColumn and LazyRow
    21. Example: Basic LazyColumn
    22. Example: LazyRow with Horizontal Layout
    23. Key Points
    24. 8. Implementing Navigation
    25. Example: Basic Navigation Setup
    26. Navigation Workflow
    27. Navigation vs. Activity/Fragment
    28. 9. Applying Theming
    29. Example: Defining a Custom Theme
    30. Example: Using Theme in UI
    31. 10. Using Side Effects
    32. Example: Using LaunchedEffect to Fetch Data
    33. Best Practices for Side Effects
    34. 11. Implementing Animation
    35. Example: Basic Fade Animation
    36. Example: Size Change Animation
    37. Example: Rotation Animation
    38. 12. Interoperating with Views
    39. Example: Using AndroidView

  16. Managing Compose State

    1. 1. Using remember for State Preservation
    2. Example: Basic State with remember
    3. Example: State with rememberSaveable
    4. 2. Creating Mutable State
    5. Example: Creating Mutable State
    6. 3. Using rememberSaveable
    7. Example: Saving a simple value
    8. Example: Saving a complex object
    9. 4. Implementing State Hoisting
    10. Example: State Hoisting in a Counter Component
    11. Best Practices for State Hoisting
    12. 5. Using derivedStateOf
    13. Example: Derived State in a Composable
    14. 6. Working with produceState
    15. Example: Using produceState to load data
    16. 7. Managing Complex State
    17. Example: State Hoisting with ViewModel
    18. Example: Using ViewModel for Complex State
    19. Best Practices for Complex State
    20. 8. Using rememberUpdatedState
    21. Example: Using rememberUpdatedState in LaunchedEffect
    22. 9. Implementing snapshotFlow
    23. Example: Using snapshotFlow to observe state changes
    24. 10. Understanding Recomposition
    25. Example: State Change Triggers Recomposition
    26. Key Points

  17. Implementing Compose Side Effects

    1. 1. Using LaunchedEffect
    2. Example: Fetching Data with LaunchedEffect
    3. 2. Implementing DisposableEffect
    4. Example: Using DisposableEffect to manage a timer
    5. 3. Using SideEffect
    6. Example: Logging in SideEffect
    7. 4. Working with rememberCoroutineScope
    8. Example: Using rememberCoroutineScope to launch coroutines
    9. 5. Implementing rememberUpdatedState
    10. Example: Using rememberUpdatedState in LaunchedEffect
    11. 6. Using produceState
    12. Example: Fetching User Data
    13. 7. Handling Back Press
    14. Example: Basic BackHandler Usage
    15. 8. Managing Lifecycle Effects
    16. Example: Using LaunchedEffect for Network Requests
    17. Example: Using DisposableEffect for Resource Management
    18. 9. Using Effect Handlers Best Practices
    19. Best Practices for Effect Handlers in Jetpack Compose
    20. Example: Using LaunchedEffect with Keys
    21. Example: Using DisposableEffect for Listener Registration
    22. 10. Implementing Custom Effects
    23. Example: Custom Side Effect for Network Requests
    24. Example: Using DisposableEffect for Lifecycle Management

  18. Building Advanced Compose UIs

    1. 1. Creating Custom Layouts
    2. Example: Custom Vertical Layout
    3. Example: Custom Horizontal Layout
    4. 2. Implementing Intrinsic Measurements
    5. Example: Custom Composable with Intrinsic Measurements
    6. 3. Using SubcomposeLayout
    7. Example: Using SubcomposeLayout
    8. 4. Implementing ConstraintLayout in Compose
    9. Example: Basic ConstraintLayout Setup
    10. 5. Creating Custom Modifiers
    11. Example: Custom Padding Modifier
    12. Example: Custom Border Modifier
    13. 6. Building Reusable Components
    14. Example: Reusable Button Component
    15. Example: Reusable Card Component
    16. Best Practices for Reusable Components
    17. 7. Implementing Gesture Handling
    18. Example: Tap Gesture
    19. Example: Drag Gesture
    20. 8. Using Nested Scrolling
    21. Example: Nested Scroll in List
    22. 9. Creating Compose Animations
    23. Example: Basic Fade Animation
    24. Example: Scale Animation
    25. Example: Custom Easing Function
    26. Animation Types Overview
    27. 10. Implementing CompositionLocal
    28. Example: Defining and Using CompositionLocal
    29. Key Points
    30. 11. Using Shared Element Transitions
    31. Example: Defining a Shared Element Transition
    32. Example: Using Shared Element in Composable
    33. Example: Transitioning Between Composables
    34. 12. Optimizing Compose Performance
    35. Example: Using LazyColumn for Performance
    36. Example: Avoiding Unnecessary Recompositions
    37. Performance Best Practices

  19. Working with RecyclerView

    1. 1. Creating RecyclerView Adapter
    2. Example: Basic RecyclerView Adapter
    3. 2. Implementing ViewHolder Pattern
    4. Example: Basic ViewHolder Implementation
    5. 3. Binding Data to Views
    6. Example: Binding Data to Views in RecyclerView
    7. 4. Setting Layout Manager
    8. Example: Setting LinearLayoutManager
    9. Example: Setting GridLayoutManager
    10. Example: Setting StaggeredGridLayoutManager
    11. 5. Handling Item Click Events
    12. Example: Click Listener in ViewHolder
    13. Best Practices for Click Handling
    14. 6. Using DiffUtil for Updates
    15. Example: Using DiffUtil to Update RecyclerView
    16. 7. Implementing ListAdapter
    17. Example: Basic ListAdapter Implementation
    18. Example: Using submitList()
    19. 8. Adding Item Decorations
    20. Example: Divider Decoration
    21. 9. Implementing Swipe to Dismiss
    22. Example: Swipe to Dismiss Implementation
    23. Setup Steps
    24. 10. Using Multiple View Types
    25. Example: Defining View Types
    26. Example: ViewHolder Implementations
    27. 11. Implementing Pagination
    28. Example: Basic Pagination Setup
    29. Workflow: Implementing Pagination
    30. Comparison: Pagination Approaches
    31. 12. Handling Drag and Drop
    32. Example: Basic Drag and Drop Setup
    33. Example: Custom Drag Handle
    34. Key Concepts

  20. Implementing Material Design

    1. 1. Using Material Components
    2. Example: Using MaterialButton
    3. Example: Using TextInputLayout
    4. 2. Implementing App Bar
    5. Example: Basic App Bar
    6. Example: App Bar with Navigation Icon
    7. 3. Using Bottom Navigation
    8. Example: Bottom Navigation Setup
    9. Example: Menu Resource
    10. 4. Implementing Navigation Drawer
    11. Example: Navigation Drawer Setup
    12. Key Steps to Implement Navigation Drawer
    13. 5. Working with Floating Action Button
    14. Example: Basic FAB Usage
    15. Example: FAB with Click Listener
    16. 6. Using Material Dialogs
    17. Example: Basic Material Dialog
    18. Example: Dialog with List Items
    19. 7. Implementing Snackbar
    20. Example: Basic Snackbar
    21. Example: Snackbar with Action
    22. Example: Customizing Snackbar Appearance
    23. 8. Using Chips
    24. Example: Basic Chip
    25. Example: Chip with Icon
    26. Chip Usage Guidelines
    27. 9. Implementing Bottom Sheets
    28. Example: BottomSheetBehavior
    29. Example: Layout Configuration
    30. 10. Applying Material Theming
    31. Example: Define Material Theme Colors in
    32. Example: Apply Theme in
    33. 11. Using Material You Dynamic Colors
    34. Example: Applying Dynamic Colors in Theme

  21. Working with Advanced UI

    1. 1. Using Custom Attributes
    2. Example: Defining Custom Attributes in XML
    3. Example: Reading Custom Attributes in Kotlin
    4. 2. Implementing Custom Drawing
    5. Example: Basic Custom View with Drawing
    6. 3. Creating Shape Drawables
    7. Example: Rectangle Shape Drawable
    8. Example: Oval Shape Drawable
    9. Example: Ring Shape Drawable
    10. 4. Using State List Drawables
    11. Example: State List Drawable XML
    12. Example: Applying State List Drawable to Button
    13. 5. Implementing Layer Drawables
    14. Example: Layer Drawable XML
    15. Example: Using Layer Drawable in Code
    16. 6. Using Nine-Patch Images
    17. Example: Nine-Patch Image Setup
    18. Key Points
    19. 7. Creating Ripple Effects
    20. Example: Ripple Effect on Button
    21. Example: Ripple with Custom Color
    22. 8. Implementing Clipping
    23. Example: Using clipChildren
    24. Example: Using clipToPadding
    25. 9. Using Elevation and Shadows
    26. Example: Setting Elevation on a Button
    27. Example: Using Shadow with CardView
    28. Elevation and Shadows Summary
    29. 10. Working with WindowInsets
    30. Example: Requesting Insets in a View
    31. Example: Using WindowInsetsCompat
    32. 11. Implementing Edge-to-Edge Design
    33. Example: Enabling Edge-to-Edge in Android
    34. Key Points for Edge-to-Edge Design

  22. Working with Animation

    1. 1. Using View Animations
    2. Example: Applying a Fade Animation
    3. Example: Creating a Scale Animation
    4. 2. Creating Animation Resources
    5. Example: Define a fade-in animation
    6. Example: Define a scale animation
    7. Example: Define a translate animation
    8. 3. Starting Animations
    9. Example: Basic Animation
    10. Example: Using Interpolator
    11. 4. Using Property Animations
    12. Example: Basic Property Animation
    13. Example: ObjectAnimator for View Properties
    14. 5. Animating Multiple Properties
    15. Example: Animating Multiple Properties
    16. 6. Implementing Transitions
    17. Example: Basic Transition
    18. Example: Crossfade Transition
    19. Transition Types
    20. 7. Using Motion Layout
    21. Example: Basic Motion Layout Setup
    22. Example: Motion Scene Definition
    23. 8. Creating Circular Reveal
    24. Example: Circular Reveal Animation
    25. 9. Interpolating Animations
    26. Example: Using Interpolator
    27. 10. Handling Animation Lifecycle
    28. Example: Using Animation Listeners
    29. 11. Using Animated Vector Drawables
    30. Example: Defining an Animated Vector Drawable
    31. Example: Using Animated Vector Drawable in Layout

  23. Handling User Input

    1. 1. Working with EditText
    2. Example: Setting up EditText in XML
    3. Example: Reading input from EditText in Kotlin
    4. Example: Setting text programmatically
    5. 2. Implementing TextWatcher
    6. Example: TextWatcher Implementation
    7. 3. Using Input Validation
    8. Example: Basic Input Validation
    9. Input Validation Best Practices
    10. 4. Handling Soft Keyboard
    11. Example: Setting Keyboard Options
    12. 5. Working with CheckBox and RadioButton
    13. Example: CheckBox Usage
    14. Example: RadioButton Usage
    15. CheckBox vs RadioButton
    16. 6. Using Spinner
    17. Example: Basic Spinner Setup
    18. Example: Spinner with ArrayAdapter
    19. 7. Implementing Date and Time Pickers
    20. Example: Using DatePickerDialog
    21. Example: Using TimePickerDialog
    22. Date and Time Picker Features
    23. 8. Working with SeekBar and Slider
    24. Example: Basic SeekBar Usage
    25. Example: Custom Slider with Thumb Drawable
    26. 9. Handling Touch Events
    27. Example: Basic Touch Event Handling
    28. Example: Detecting Swipe Gesture
    29. Touch Event Lifecycle
    30. 10. Implementing Gesture Detection
    31. Example: Detecting Swipe Gesture
    32. 11. Using ScaleGestureDetector
    33. Example: Basic ScaleGestureDetector Usage

  24. Managing Permissions

    1. 1. Declaring Permissions in Manifest
    2. Example: Declaring Permissions in AndroidManifest.xml
    3. 2. Requesting Runtime Permissions
    4. Example: Requesting Camera Permission
    5. 3. Checking Permission Status
    6. Example: Check Camera Permission
    7. 4. Handling Permission Results
    8. Example: Requesting Camera Permission
    9. Permission Handling Workflow
    10. 5. Using Permission Request Contracts
    11. Example: Requesting Camera Permission
    12. 6. Understanding Permission Groups
    13. 7. Handling Rationale UI
    14. Example: Requesting Permission with Rationale UI
    15. Workflow: Handling Permission Requests with Rationale
    16. Comparison: Permission Request Methods
    17. 8. Working with Special Permissions
    18. Example: Requesting Special Permissions
    19. 9. Managing Location Permissions
    20. Example: Requesting Location Permissions
    21. Example: Handling Permission Results
    22. 10. Handling Permission Denials
    23. Example: Requesting Permissions with Rationale
    24. 11. Using Photo Picker
    25. Example: Launching Photo Picker
    26. Example: Handling Selected Image

  25. Managing Resources

    1. 1. Accessing String Resources
    2. Example: Using String Resources
    3. Example: Formatting Strings with Placeholders
    4. 2. Using String Formatting
    5. Example: String formatting with variables
    6. Example: Formatting floating-point numbers
    7. 3. Working with Plurals
    8. Example: Defining Plurals in XML
    9. Example: Using Plurals in Kotlin
    10. 4. Accessing Drawable Resources
    11. Example: Loading a Drawable Resource
    12. 5. Using Color Resources
    13. Example: Defining a Color Resource
    14. Example: Using a Color Resource in Layout
    15. Example: Using a Color Resource in Code
    16. 6. Working with Dimension Resources
    17. Example: Defining Dimension Resources
    18. Example: Using Dimension Resources in Layout
    19. Example: Using Dimension Resources in Code
    20. 7. Creating Alternative Resources
    21. Example: Creating Alternative Layouts
    22. Example: Creating Alternative Strings
    23. 8. Using Configuration Qualifiers
    24. Example: Using Configuration Qualifiers for Layouts
    25. 9. Accessing Raw Resources
    26. Example: Reading a Raw Resource
    27. 10. Working with Assets
    28. Example: Loading a Raw Asset
    29. Example: Loading a Drawable Resource

  26. Working with SharedPreferences

    1. 1. Getting SharedPreferences Instance
    2. Example: Getting SharedPreferences Instance
    3. 2. Storing Primitives
    4. Example: Storing and Retrieving Boolean
    5. Example: Storing and Retrieving Integer
    6. 3. Retrieving Values
    7. Example: Retrieving Values
    8. 4. Using Preferences Editor
    9. Example: Saving and Editing Preferences
    10. 5. Removing Data
    11. 6. Implementing OnSharedPreferenceChangeListener
    12. Example: Registering a Listener
    13. Example: Unregistering a Listener
    14. 7. Using Encrypted SharedPreferences
    15. Example: Creating EncryptedSharedPreferences
    16. Example: Storing and Retrieving Data
    17. 8. Applying Best Practices
    18. Best Practices for SharedPreferences
    19. Example: Saving and Retrieving Data
    20. 9. Storing Collections
    21. Example: Storing and Retrieving a List of Integers
    22. 10. Migrating to DataStore
    23. SharedPreferences vs DataStore
    24. Example: Migrating from SharedPreferences to DataStore

  27. Working with DataStore

    1. 1. Setting Up DataStore Dependencies
    2. Example: Adding Dependencies to build.gradle.kts
    3. 2. Creating Preferences DataStore
    4. Example: Creating Preferences DataStore
    5. Key Points
    6. 3. Reading Preferences
    7. Example: Reading a String Preference
    8. Example: Reading an Integer Preference
    9. Example: Reading a Boolean Preference
    10. 4. Writing Preferences
    11. Example: Writing a Preference Value
    12. Example: Writing Multiple Preferences
    13. 5. Defining Preference Keys
    14. Example: Defining and Using Preference Keys
    15. 6. Using Proto DataStore
    16. Example: Define a Proto Message
    17. Example: Create DataStore Instance
    18. Example: Read Data
    19. Example: Write Data
    20. 7. Handling Exceptions
    21. Example: Catching DataStore Exceptions
    22. 8. Implementing Migration from SharedPreferences
    23. Example: Migrating SharedPreferences to DataStore
    24. Migration Best Practices
    25. 9. Using DataStore with Hilt
    26. Example: Injecting DataStore in a ViewModel
    27. Key Points
    28. 10. Implementing Type-Safe Preferences
    29. Example: Saving Preferences
    30. Example: Reading Preferences

  28. Working with SQLite Database

    1. 1. Creating Database Helper
    2. Example: Database Helper Class
    3. 2. Defining Database Schema
    4. Example: Creating a Table in SQLite
    5. Example: Adding a Foreign Key Constraint
    6. 3. Performing CRUD Operations
    7. Example: Inserting Data into SQLite Table
    8. Example: Querying Data from SQLite Table
    9. Example: Updating Data in SQLite Table
    10. Example: Deleting Data from SQLite Table
    11. 4. Using ContentValues
    12. Example: Inserting Data Using ContentValues
    13. Example: Updating Data Using ContentValues
    14. 5. Querying Database
    15. Example: Basic SELECT query
    16. Example: Using rawQuery with WHERE clause
    17. Example: COUNT query
    18. 6. Working with Cursor
    19. Example: Querying Data and Iterating with Cursor
    20. Example: Getting Column Index
    21. Example: Using getColumnIndexOrThrow()
    22. 7. Using Transactions
    23. Example: Basic Transaction
    24. Example: Nested Transaction
    25. 8. Implementing Database Migrations
    26. Example: Auto Migration
    27. Example: Custom Migration
    28. Migration Best Practices
    29. 9. Creating Indexes
    30. Example: Creating a Single-Column Index
    31. Example: Creating a Composite Index
    32. 10. Closing Database Connections
    33. Example: Closing Database Connection

  29. Using Room Database

    1. 1. Setting Up Room Dependencies
    2. Example: Adding Room Dependencies to build.gradle (Module: app)
    3. 2. Creating Entity Classes
    4. Example: Basic Entity Class
    5. Example: Entity with Composite Primary Key
    6. 3. Defining Data Access Objects
    7. Example: Basic DAO Definition
    8. Example: Using LiveData with DAO
    9. 4. Building Room Database
    10. Example: Basic Room Database Setup
    11. Example: Using Room Database in Application
    12. Key Points
    13. 5. Using Type Converters
    14. Example: Converting Date to Long
    15. Example: Converting List to String
    16. 6. Implementing Relationships
    17. Example: One-to-Many Relationship
    18. Example: Many-to-Many Relationship
    19. 7. Observing Data Changes
    20. Example: Using LiveData to observe data changes
    21. Example: Using Flow to observe data changes
    22. Key Points for Observing Data Changes
    23. 8. Performing Migrations
    24. Example: Custom Migration
    25. Migration Best Practices
    26. 9. Using Database Transactions
    27. Example: Using Room Transaction
    28. Key Points
    29. 10. Testing Room Databases
    30. Example: Unit Test with In-Memory Database
    31. 11. Implementing Full-Text Search
    32. Example: Setting up FTS with Room
    33. Key Points
    34. 12. Using Room with Paging
    35. Example: Setting up PagedList with Room
    36. Example: Using PagingSource with Room
    37. Example: Configuring PagedListAdapter

  30. Implementing Data Serialization

    1. 1. Using Parcelable Interface
    2. Example: Implementing Parcelable
    3. 2. Implementing Parcelable with @Parcelize
    4. Example: Basic Parcelable Implementation
    5. Supported Types
    6. 3. Using Serializable Interface
    7. Example: Implementing Serializable in a Data Class
    8. 4. Working with JSON
    9. Example: Serializing and Deserializing JSON
    10. 5. Parsing JSON to Objects
    11. Example: Parsing JSON to User Object
    12. 6. Serializing Objects to JSON
    13. Example: Serializing a Kotlin object to JSON
    14. Example: Using custom JSON configuration
    15. 7. Using Gson Library
    16. Key Features of Gson
    17. 8. Using Moshi Library
    18. Example: Basic JSON Serialization with Moshi
    19. Example: Custom Adapter for Date
    20. 9. Using Kotlinx Serialization
    21. Example: Basic Serialization
    22. Example: Deserialization
    23. 10. Handling Null Values in JSON
    24. Example: Serializing Null Values
    25. Example: Custom Null Handling

  31. Working with Networking

    1. 1. Adding Internet Permission
    2. Example: Declaring Permissions in AndroidManifest.xml
    3. 2. Making HTTP Requests
    4. Example: Basic GET Request with OkHttp
    5. 3. Performing GET Requests
    6. Example: Basic GET Request with OkHttp
    7. 4. Performing POST Requests
    8. Example: Sending a POST Request with OkHttp
    9. Example: Sending a POST Request with Retrofit
    10. 5. Handling Network Responses
    11. Example: Handling Response Codes
    12. Example: Parsing JSON Response
    13. 6. Parsing JSON Responses
    14. Example: Parsing JSON with Gson
    15. Example: Using Moshi for JSON Parsing
    16. JSON Parsing Libraries Comparison
    17. 7. Checking Network Connectivity
    18. Example: Check Network Status
    19. Network Connectivity Overview
    20. 8. Monitoring Network Changes
    21. Example: Registering for Network Status Updates
    22. Example: Using NetworkCallback (API 23+)
    23. Network Change Monitoring Summary
    24. 9. Handling Network Exceptions
    25. Example: Handling Network Exceptions in Retrofit
    26. 10. Using Network Security Configuration
    27. Example: Basic Network Security Config
    28. Example: Allowing Cleartext Traffic
    29. Example: Using Custom Certificate
    30. 11. Implementing Certificate Pinning
    31. Example: Using OkHttp with Certificate Pinning

  32. Using Retrofit for Networking

    1. 1. Setting Up Retrofit Dependencies
    2. Example: Gradle Dependencies
    3. 2. Creating API Interface
    4. Example: Basic API Interface Definition
    5. 3. Building Retrofit Instance
    6. Example: Basic Retrofit Setup
    7. 4. Defining Request Parameters
    8. Example: Using Path and Query Parameters
    9. 5. Using Call Objects
    10. Example: Enqueuing a Call
    11. Example: Synchronous Execution
    12. 6. Implementing Callbacks
    13. Example: Basic Callback Implementation
    14. 7. Using Coroutines with Retrofit
    15. 8. Configuring OkHttp Client
    16. Example: Basic OkHttp Configuration
    17. Example: Adding Interceptors
    18. 9. Adding Headers
    19. Example: Using @HeaderMap
    20. 10. Handling Different Response Types
    21. Example: Using Response<T>
    22. Example: Using Call<T>
    23. 11. Implementing Error Handling
    24. Example: Handling HttpException
    25. Example: Handling IOException
    26. Error Handling Best Practices

  33. Implementing Architecture Patterns

    1. 1. Understanding MVVM Pattern
    2. Example: Basic MVVM Implementation in Kotlin
    3. Comparison: MVVM vs MVC
    4. 2. Creating ViewModel Classes
    5. Example: Basic ViewModel Implementation
    6. Example: Using ViewModel with Repository
    7. 3. Using LiveData for Observables
    8. Example: Basic LiveData Usage
    9. Key Points About LiveData
    10. 4. Observing LiveData
    11. Example: Observing LiveData in a Fragment
    12. Example: Using observeForever
    13. 5. Transforming LiveData
    14. Example: Using map to transform data
    15. Example: Using switchMap for asynchronous operations
    16. 6. Implementing Repository Pattern
    17. Example: Repository with Local and Remote Data Sources
    18. Key Benefits of Repository Pattern
    19. 7. Using StateFlow and SharedFlow
    20. Example: Using StateFlow to manage UI state
    21. Example: Using SharedFlow to emit events
    22. 8. Managing UI State
    23. Example: Using ViewModel with StateFlow
    24. Example: Using Jetpack Compose State
    25. 9. Implementing Single Activity Architecture
    26. Example: Basic Single Activity with Multiple Fragments
    27. Workflow: Navigation Between Fragments
    28. Comparison: SAA vs Multi-Activity
    29. 10. Separating Concerns
    30. Example: ViewModel with Separated Concerns
    31. Benefits of Separation
    32. 11. Implementing Clean Architecture
    33. Example: Project Structure
    34. Example: Use Case Implementation
    35. Example: Repository Implementation

  34. Working with ViewModel

    1. 1. Creating ViewModel Classes
    2. Example: Basic ViewModel Class
    3. 2. Sharing ViewModel Between Fragments
    4. Example: Sharing ViewModel Between Fragments
    5. 3. Using SavedStateHandle
    6. Example: Using SavedStateHandle in ViewModel
    7. Key Features of SavedStateHandle
    8. 4. Injecting Dependencies into ViewModel
    9. Example: Injecting Repository into ViewModel
    10. Example: Using ViewModelProvider with Factory
    11. 5. Managing ViewModel Scope
    12. Example: Using viewModelScope
    13. Example: Using lifecycleScope
    14. 6. Handling Configuration Changes
    15. Example: Observing Configuration Changes in ViewModel
    16. 7. Clearing ViewModel
    17. Example: Clearing ViewModel Data
    18. 8. Using ViewModel with Compose
    19. Example: Basic ViewModel usage in Compose
    20. 9. Testing ViewModel
    21. Example: Unit Test with JUnit and Mockito
    22. 10. Implementing ViewModel Factory
    23. Example: Custom ViewModel Factory

  35. Using Dependency Injection with Hilt

    1. 1. Setting Up Hilt Dependencies
    2. Example: Gradle Setup
    3. 2. Annotating Application Class
    4. Example: Annotating Application Class
    5. 3. Injecting into Activities and Fragments
    6. Example: Injecting a Repository into an Activity
    7. Example: Injecting a ViewModel into a Fragment
    8. 4. Creating Modules
    9. Example: Basic Hilt Module
    10. Example: Providing Different Scopes
    11. Module Creation Guidelines
    12. 5. Providing Dependencies
    13. Example: Providing a Singleton Dependency
    14. Example: Using Qualifiers for Multiple Implementations
    15. 6. Using Constructor Injection
    16. Example: Constructor Injection in a Repository
    17. Example: Constructor Injection in a ViewModel
    18. 7. Defining Scopes
    19. Example: Using @Singleton Scope
    20. Example: Using @ActivityScoped
    21. 8. Injecting ViewModel
    22. Example: Injecting ViewModel with Hilt
    23. 9. Using Qualifiers
    24. Example: Using @Named Qualifier
    25. Example: Using Custom @Qualifier
    26. 10. Testing with Hilt
    27. Example: Providing Mock Dependencies in Tests
    28. Testing with Hilt Summary
    29. 11. Implementing Entry Points
    30. Example: Defining an Entry Point
    31. Example: Using Entry Points in an Activity

  36. Working with Paging Library

    1. 1. Setting Up Paging Dependencies
    2. Example: Gradle Dependencies
    3. 2. Creating PagingSource
    4. Example: Basic PagingSource Implementation
    5. 3. Building Pager
    6. Example: Basic Pager Setup
    7. Example: Custom PagingConfig
    8. Key Points
    9. 4. Observing PagingData
    10. Example: Observing PagingData in ViewModel
    11. Example: Using PagingData in Composable
    12. 5. Using PagingDataAdapter
    13. Example: Initializing PagingDataAdapter
    14. Example: Using PagingDataAdapter with RecyclerView
    15. Key Features of PagingDataAdapter
    16. 6. Handling Loading States
    17. Example: Basic Loading State with Paging 3
    18. Example: Handling Append State
    19. Key Points for Loading State Management
    20. 7. Implementing Retry Logic
    21. Example: Retry Logic with PagingSource
    22. Retry Behavior
    23. 8. Using RemoteMediator
    24. Example: Implementing RemoteMediator
    25. 9. Displaying Load State
    26. Example: Basic Load State Handling
    27. Example: Handling LoadState in UI
    28. 10. Using Paging with Compose
    29. Example: Basic Paging with Jetpack Compose
    30. Example: Custom Paging Source
    31. Key Concepts

  37. Working with Background Services

    1. 1. Creating Foreground Services
    2. Example: Creating a Foreground Service
    3. 2. Implementing Service Lifecycle
    4. Example: Basic Service Lifecycle Implementation
    5. 3. Starting and Stopping Services
    6. Example: Starting a Service
    7. Example: Stopping a Service
    8. 4. Implementing Bound Services
    9. Example: Basic Bound Service Implementation
    10. Example: Binding to the Service
    11. 5. Using IntentService Replacement
    12. Example: Using WorkManager for Background Tasks
    13. 6. Understanding Service Types
    14. 7. Managing Service Notifications
    15. Example: Creating a Notification Channel
    16. Example: Displaying a Foreground Service Notification
    17. 8. Handling Service Restart
    18. Example: Service Restart Behavior
    19. 9. Using Coroutines in Services
    20. Example: Using Coroutines in a Service
    21. 10. Implementing Media Services
    22. Example: Basic MediaSession Setup
    23. Example: Handling Media Playback

  38. Working with WorkManager

    1. 1. Setting Up WorkManager Dependencies
    2. Example: Gradle Dependencies
    3. 2. Creating Worker Classes
    4. Example: Basic Worker Class
    5. Example: Worker with Input Parameters
    6. 3. Creating CoroutineWorker
    7. Example: Creating a CoroutineWorker
    8. Key Points
    9. 4. Building WorkRequest
    10. Example: Creating a OneTimeWorkRequest
    11. Example: Creating a PeriodicWorkRequest
    12. 5. Setting Work Constraints
    13. Example: Setting Network Constraint
    14. Example: Combining Multiple Constraints
    15. 6. Chaining Work Requests
    16. Example: Chaining Work Requests
    17. 7. Observing Work Status
    18. Example: Observing Work Status
    19. 8. Passing Data to Workers
    20. Example: Passing Data to Worker
    21. Example: Enqueuing Worker with Data
    22. 9. Handling Work Failures
    23. Example: Retry Logic with Backoff
    24. Failure Handling Best Practices
    25. 10. Implementing Expedited Work
    26. Example: Scheduling Expedited Work
    27. 11. Canceling Work
    28. Example: Canceling Work by ID
    29. Example: Canceling Work by Tag
    30. 12. Using Unique Work
    31. Example: Unique Work Request

  39. Implementing Notifications

    1. 1. Creating Notification Channels
    2. Example: Creating a Notification Channel
    3. 2. Building Notifications
    4. Example: Basic Notification
    5. Example: Notification with Action
    6. 3. Setting Notification Content
    7. Example: Basic Notification Content
    8. Example: Expanded Notification
    9. 4. Displaying Notifications
    10. Example: Basic Notification
    11. Example: Notification with Actions
    12. 5. Adding Actions to Notifications
    13. 6. Using Notification Styles
    14. 7. Setting Notification Priority and Category
    15. Example: Setting Priority and Category
    16. 8. Handling Notification Taps
    17. Example: Handling Tap with Activity Launch
    18. 9. Updating and Canceling Notifications
    19. Example: Updating a Notification
    20. Example: Canceling a Notification
    21. Example: Canceling All Notifications
    22. 10. Creating Grouped Notifications
    23. Example: Creating a Grouped Notification
    24. Example: Adding Individual Notifications to a Group
    25. 11. Implementing Progress Notifications
    26. Example: Basic Progress Notification
    27. Example: Indeterminate Progress Notification
    28. Example: Updating Progress Notification
    29. 12. Using Full-Screen Intents
    30. Example: Creating a Full-Screen Notification

  40. Working with BroadcastReceivers

    1. 1. Creating BroadcastReceiver Class
    2. Example: Basic BroadcastReceiver
    3. 2. Registering Receivers in Manifest
    4. Example: Declaring a BroadcastReceiver in AndroidManifest.xml
    5. 3. Registering Receivers Dynamically
    6. Example: Registering a Dynamic Receiver
    7. 4. Unregistering Receivers
    8. Example: Unregistering a BroadcastReceiver
    9. 5. Sending Broadcasts
    10. Example: Sending a Basic Broadcast
    11. Example: Sending Ordered Broadcast
    12. 6. Handling System Broadcasts
    13. Example: Receiving Battery Status Changes
    14. Example: Registering for Boot Completion
    15. 7. Setting Broadcast Permissions
    16. Example: Declaring Permissions in Manifest
    17. 8. Creating Custom Broadcasts
    18. Example: Sending a Custom Broadcast
    19. 9. Using Implicit vs Explicit Broadcasts
    20. Example: Sending an Implicit Broadcast
    21. Example: Sending an Explicit Broadcast
    22. 10. Handling Broadcast Exceptions
    23. Example: Exception Handling in BroadcastReceiver

  41. Working with Content Providers

    1. 1. Creating ContentProvider Class
    2. Example: Basic ContentProvider Implementation
    3. 2. Defining Content URIs
    4. Example: Defining Content URI
    5. 3. Implementing CRUD Methods
    6. Example: Implementing CRUD in a Content Provider
    7. 4. Using ContentResolver
    8. Example: Querying Data
    9. Example: Inserting Data
    10. Example: Updating Data
    11. Example: Deleting Data
    12. 5. Querying Content Providers
    13. Example: Querying a Content Provider
    14. 6. Inserting Data
    15. Example: Inserting Data into a Content Provider
    16. 7. Updating and Deleting Data
    17. Example: Updating Data
    18. Example: Deleting Data
    19. 8. Registering Providers in Manifest
    20. Example: AndroidManifest.xml Registration
    21. 9. Using CursorLoader Alternative
    22. Example: Using ContentResolver.query()
    23. 10. Observing Content Changes
    24. Example: Observing Content Changes
    25. Key Points

  42. Handling Images

    1. 1. Loading Images from Resources
    2. Example: Loading an Image from Drawable Resource
    3. 2. Setting Images from Drawables
    4. Example: Setting Image from Drawable
    5. Example: Setting Background from Drawable
    6. 3. Loading Images from URIs
    7. Example: Loading Image with Glide
    8. Example: Loading Image with Coil
    9. 4. Decoding Bitmaps
    10. Example: Decoding a Bitmap from File
    11. Example: Decoding a Bitmap from Resource
    12. Example: Decoding a Bitmap from InputStream
    13. Example: Decoding a Bitmap from Byte Array
    14. 5. Scaling Bitmaps
    15. Example: Scaling Bitmaps
    16. 6. Creating Bitmaps
    17. Example: Creating a Bitmap from Resource
    18. Example: Creating a Bitmap with Custom Dimensions
    19. 7. Drawing on Canvas
    20. Example: Basic Canvas Drawing
    21. Example: Drawing with Gradient
    22. Example: Drawing with Bitmap
    23. 8. Using Vector Drawables
    24. Example: Defining a Vector Drawable
    25. Example: Using Vector Drawable in Layout
    26. 9. Implementing Image Transformations
    27. 10. Handling Image Memory
    28. Example: Loading Scaled Bitmap
    29. Example: Using LruCache for Bitmaps
    30. 11. Using Coil for Image Loading
    31. Example: Basic Image Loading with Coil
    32. Example: Image Loading with Placeholder and Error Handling

  43. Working with Media Playback

    1. 1. Playing Audio with MediaPlayer
    2. Example: Basic Audio Playback
    3. 2. Controlling Playback
    4. Example: Controlling Playback State
    5. 3. Managing MediaPlayer Lifecycle
    6. Example: MediaPlayer Lifecycle Management
    7. 4. Playing Video with VideoView
    8. Example: Setting up VideoView in Kotlin
    9. 5. Using MediaController
    10. Example: Initializing MediaController
    11. Example: Controlling Playback
    12. 6. Handling Playback Errors
    13. Example: Error Handling in MediaPlayer
    14. 7. Managing Audio Focus
    15. Example: Requesting Audio Focus
    16. Example: Releasing Audio Focus
    17. 8. Playing Audio in Background
    18. Example: Setting up background audio playback
    19. 9. Using ExoPlayer
    20. Example: Basic ExoPlayer Setup
    21. Example: Setting Up Player with Custom DataSource
    22. Key Features of ExoPlayer
    23. 10. Implementing Playback Controls
    24. 11. Using Media3 Library
    25. Example: Basic Media3 Player Setup
    26. Key Features of Media3

  44. Working with Camera

    1. 1. Requesting Camera Permission
    2. Example: Check and Request Camera Permission
    3. Example: Handle Permission Result
    4. 2. Using Camera Intent
    5. Example: Launch Camera Intent
    6. 3. Capturing Photos
    7. Example: Capturing a Photo
    8. 4. Saving Captured Images
    9. Example: Saving Image to Gallery
    10. 5. Using CameraX
    11. Example: Basic CameraX Setup
    12. Key Features of CameraX
    13. 6. Configuring CameraX Use Cases
    14. Example: Setting up Preview Use Case
    15. Example: Setting up ImageCapture Use Case
    16. Example: Setting up VideoCapture Use Case
    17. 7. Capturing Images with CameraX
    18. Example: Setting up CameraX for image capture
    19. Example: Capturing an image
    20. 8. Recording Video with CameraX
    21. Example: Start Video Recording
    22. 9. Setting Camera Parameters
    23. Example: Setting Camera Parameters
    24. 10. Handling Camera Lifecycle
    25. Example: Camera Lifecycle Management
    26. 11. Implementing Image Analysis
    27. Example: Basic Image Analysis Setup
    28. 12. Switching Between Cameras
    29. Example: Switching Camera

  45. Implementing Location Services

    1. 1. Requesting Location Permissions
    2. Example: Requesting Location Permissions in Android Manifest
    3. 2. Using FusedLocationProviderClient
    4. Example: Requesting Location Updates
    5. 3. Creating Location Requests
    6. Example: Creating a Location Request
    7. 4. Receiving Location Updates
    8. Example: Requesting Location Updates
    9. Example: Setting Priority and Intervals
    10. Key Points
    11. 5. Removing Location Updates
    12. Example: Removing Location Updates with Listener
    13. Example: Removing Location Updates with PendingIntent
    14. 6. Using Geocoding
    15. Example: Reverse Geocoding
    16. Example: Forward Geocoding
    17. 7. Calculating Distance Between Locations
    18. Example: Calculating Distance
    19. 8. Checking Location Settings
    20. Example: Check Location Settings
    21. 9. Implementing Geofencing
    22. Example: Creating a Geofence
    23. Example: Adding Geofences
    24. Example: Handling Geofence Transitions
    25. 10. Handling Background Location
    26. Example: Request Background Location Permission
    27. Example: Background Location Update

  46. Working with Sensors

    1. 1. Accessing Sensor Service
    2. Example: Registering a Sensor Listener
    3. 2. Listing Available Sensors
    4. Example: Listing Available Sensors
    5. 3. Registering Sensor Listeners
    6. Example: Registering a Sensor Listener
    7. Key Points
    8. 4. Unregistering Listeners
    9. Example: Unregistering a Sensor Listener
    10. 5. Handling Sensor Events
    11. Example: Registering Sensor Listener
    12. Sensor Event Handling Workflow
    13. 6. Using Accelerometer
    14. Example: Reading Accelerometer Data
    15. 7. Working with Gyroscope
    16. Example: Reading Gyroscope Data
    17. Example: Registering Sensor Listener
    18. 8. Using Proximity Sensor
    19. Example: Registering Proximity Sensor
    20. 9. Working with Light Sensor
    21. Example: Reading Light Sensor Data
    22. 10. Monitoring Device Orientation
    23. Example: Detecting Orientation Changes

  47. Working with Bluetooth

    1. 1. Requesting Bluetooth Permissions
    2. Example: Requesting Permissions at Runtime
    3. 2. Checking Bluetooth Availability
    4. Example: Check Bluetooth Availability
    5. 3. Enabling Bluetooth
    6. Example: Requesting Permissions
    7. Example: Enabling Bluetooth Programmatically
    8. 4. Discovering Devices
    9. Example: Start Bluetooth Discovery
    10. Example: Handle Discovery Results
    11. 5. Pairing with Devices
    12. Example: Requesting Pairing
    13. Example: Handling Pairing Request
    14. Pairing Process Summary
    15. 6. Connecting via BluetoothSocket
    16. Example: Connecting to a Bluetooth device using BluetoothSocket
    17. 7. Using Bluetooth Low Energy
    18. Example: Start BLE Scan
    19. Example: Handle Scan Results
    20. Example: Connect to BLE Device
    21. Example: Read Characteristic Value
    22. BLE Connection Lifecycle
    23. 8. Scanning for BLE Devices
    24. Example: Start BLE Scan
    25. 9. Reading and Writing BLE Characteristics
    26. Example: Reading a BLE Characteristic
    27. Example: Writing to a BLE Characteristic
    28. 10. Managing Bluetooth Connections
    29. Example: Discovering and Connecting to a Bluetooth Device
    30. Example: Handling Connection State Changes

  48. Working with App Widgets

    1. 1. Creating Widget Provider Class
    2. Example: Basic Widget Provider Implementation
    3. 2. Defining Widget Layout
    4. Example: Basic Widget Layout
    5. 3. Configuring Widget Metadata
    6. Example: Widget Metadata in XML
    7. 4. Updating Widget Content
    8. Example: Updating Widget Text
    9. Example: Updating Widget Image
    10. 5. Handling Widget Clicks
    11. Example: Broadcast Receiver for Widget Clicks
    12. 6. Implementing Widget Configuration
    13. Example: Basic AppWidgetProvider
    14. Example: Configuration Activity
    15. 7. Using Collection Widgets
    16. Example: Creating a Collection Widget
    17. Example: Service for Collection Items
    18. Key Points
    19. 8. Creating RemoteViewsService
    20. Example: Basic RemoteViewsService Implementation
    21. Example: Implementing RemoteViewsFactory
    22. 9. Managing Widget Lifecycle
    23. Example: Handling Widget Updates
    24. Widget Lifecycle Summary
    25. 10. Updating Widgets from App
    26. Example: Updating Widget Text
    27. Example: Using Broadcast to Update Widget
    28. 11. Using Glance for Compose Widgets
    29. Example: Basic Glance Widget
    30. Key Features of Glance

  49. Implementing Splash Screen

    1. 1. Setting Up Splash Screen API
    2. Example: Splash Screen Setup in AndroidManifest.xml
    3. Example: Kotlin Activity Implementation
    4. 2. Configuring Splash Theme
    5. Example: Define splash theme in
    6. Example: Apply theme in
    7. 3. Installing Splash Screen
    8. Example: Adding Splash Screen Dependency
    9. 4. Customizing Animation
    10. Example: Customizing Animation Duration
    11. Example: Setting Background Color
    12. 5. Handling Branding
    13. Example: Define Splash Screen in Theme
    14. 6. Managing Exit Animation
    15. Example: Define Exit Animation
    16. Example: Apply Exit Animation in Theme
    17. 7. Supporting Older Versions
    18. Example: Implementing Splash Screen for API 21+
    19. 8. Implementing Loading Logic
    20. Example: Basic Loading Logic with Coroutines
    21. Loading Logic Best Practices
    22. 9. Using Animated Icons
    23. Example: Animated Icon in Splash Screen
    24. 10. Testing Splash Screen
    25. Example: Unit Test for Splash Screen Logic
    26. Testing Best Practices

  50. Implementing Localization

    1. 1. Creating String Resources
    2. Example: Define a localized string resource
    3. Example: Using string resources in Kotlin
    4. 2. Adding Language Qualifiers
    5. Example: Language Resource Directory Structure
    6. 3. Using Plurals for Quantities
    7. Example: Defining Plurals in XML
    8. Example: Using Plurals in Kotlin
    9. 4. Formatting Dates and Times
    10. Example: Formatting with Locale
    11. 5. Formatting Numbers and Currency
    12. Example: Formatting Numbers in Different Locales
    13. Example: Formatting Currency in Different Locales
    14. 6. Using RTL Support
    15. Example: Setting RTL Support in Manifest
    16. Example: Using Layout Direction in XML
    17. Example: Setting Text Direction Programmatically
    18. 7. Translating String Resources
    19. Example: Translating a String Resource
    20. Example: Translated String Resource (Spanish)
    21. Localization Workflow
    22. 8. Testing Different Locales
    23. Example: Setting Locale in Android Emulator
    24. Workflow: Testing Locale Changes
    25. 9. Handling Per-App Language Preferences
    26. Example: Setting App Locale Programmatically
    27. Key Points
    28. 10. Using Grammatical Inflection API
    29. Example: Using pluralize in Android

  51. Implementing Accessibility

    1. 1. Adding Content Descriptions
    2. Example: Content Description for Image
    3. Example: Content Description for Button
    4. 2. Using Accessibility Services
    5. Example: Registering an Accessibility Service
    6. Example: Declaring Accessibility Service in Manifest
    7. Example: Accessibility Service Configuration XML
    8. 3. Setting Accessibility Labels
    9. Example: Setting Accessibility Label on a Button
    10. Example: Using Content Description for ImageView
    11. 4. Implementing Focus Order
    12. Example: Setting Focus Order in XML
    13. Best Practices for Focus Order
    14. 5. Using Heading Attributes
    15. Example: Applying Heading Attributes
    16. 6. Announcing Live Regions
    17. Example: Setting Live Region
    18. Example: Using Polite Announcements
    19. 7. Setting Minimum Touch Target Size
    20. Example: Setting Touch Target Size
    21. 8. Providing Text Alternatives
    22. Example: Using contentDescription in XML
    23. Example: Setting contentDescription programmatically
    24. 9. Testing with Accessibility Scanner
    25. Example: Running Accessibility Scanner
    26. Key Points
    27. 10. Supporting Screen Readers
    28. Example: Setting Content Description
    29. Example: Using Accessibility Heading
    30. 11. Implementing Compose Accessibility
    31. Example: Basic Compose Accessibility
    32. Example: Accessibility in Button
    33. Accessibility Best Practices in Jetpack Compose

  52. Handling Application Security

    1. 1. Encrypting Data with KeyStore
    2. Example: Generate a Key in Keystore
    3. Example: Encrypt Data with Keystore Key
    4. Example: Decrypt Data with Keystore Key
    5. 2. Using BiometricPrompt
    6. Example: Initializing BiometricPrompt
    7. 3. Implementing Certificate Pinning
    8. Example: Using OkHttp with Certificate Pinning
    9. 4. Validating Input Data
    10. Example: Basic Input Validation
    11. Example: Sanitizing User Input
    12. 5. Securing SharedPreferences
    13. Example: Secure SharedPreferences Usage
    14. 6. Using HTTPS Only
    15. Example: Enforcing HTTPS Only
    16. Example: Applying Network Security Config
    17. HTTPS Enforcement Summary
    18. 7. Implementing App Signing
    19. Example: Generate Keystore Using Keytool
    20. Example: Configure Gradle for Release Build
    21. 8. Protecting Against SQL Injection
    22. Example: Room Query with Parameters
    23. 9. Using R8 for Obfuscation
    24. Example: Basic R8 Configuration
    25. 10. Securing API Keys
    26. Example: Using BuildConfig for API Key

  53. Implementing Biometric Authentication

    1. 1. Checking Biometric Availability
    2. Example: Checking Biometric Availability
    3. 2. Creating BiometricPrompt Instance
    4. Example: Creating BiometricPrompt Instance
    5. 3. Configuring Prompt Info
    6. Example: Setting up Biometric Prompt Info
    7. 4. Authenticating Users
    8. Example: Basic Biometric Authentication Setup
    9. 5. Handling Authentication Results
    10. Example: Handling Authentication Success
    11. 6. Using CryptoObject
    12. Example: Creating CryptoObject
    13. 7. Handling Biometric Errors
    14. Example: Error Handling in Biometric Prompt
    15. 8. Supporting Device Credentials
    16. Example: Using Device Credentials
    17. Key Points
    18. 9. Implementing Biometric Enrollment
    19. Example: Starting Biometric Enrollment
    20. 10. Testing Biometric Authentication
    21. Example: Testing Biometric Authentication Flow
    22. Testing Best Practices

  54. Optimizing Performance

    1. 1. Using ViewBinding vs findViewById
    2. Example: ViewBinding Usage
    3. Example: findViewById Usage
    4. 2. Implementing View Recycling
    5. Example: Basic RecyclerView Setup
    6. 3. Reducing Layout Hierarchy
    7. Example: Using ConstraintLayout to reduce nesting
    8. 4. Using ViewStub for Lazy Loading
    9. Example: Inflate ViewStub Programmatically
    10. 5. Optimizing Bitmap Loading
    11. Example: Loading a Scaled Bitmap
    12. Example: Using inBitmap for Memory Reuse
    13. 6. Implementing Memory Caching
    14. Example: Using LruCache
    15. 7. Reducing Overdraw
    16. Example: Identifying Overdraw
    17. Techniques to Reduce Overdraw
    18. 8. Using Strict Mode
    19. Example: Enabling StrictMode
    20. 9. Profiling with Android Profiler
    21. Example: Launching Android Profiler
    22. Workflow: Using Android Profiler
    23. Key Features of Android Profiler
    24. 10. Implementing LazyColumn Optimization
    25. Example: Basic LazyColumn with Item Content
    26. Example: LazyColumn with Key
    27. Performance Tips
    28. 11. Avoiding Memory Leaks
    29. Example: Using WeakReference to avoid context leak
    30. Example: Unregistering broadcast receiver
    31. 12. Using Baseline Profiles
    32. Example: Baseline Profile Configuration
    33. Example: Enabling Baseline Profiles in Gradle

  55. Handling Application Lifecycle

    1. 1. Understanding Process Lifecycle
    2. Example: Lifecycle Callbacks in Kotlin
    3. 2. Handling App Startup
    4. Example: Custom Application Class
    5. Key Points
    6. 3. Managing Low Memory
    7. Example: Implementing onTrimMemory()
    8. Memory Trim Levels
    9. 4. Handling App Visibility
    10. Example: Managing Visibility in Activity
    11. 5. Implementing Lifecycle-Aware Components
    12. Example: Creating a LifecycleObserver
    13. Example: Registering a LifecycleObserver
    14. Key Concepts
    15. 6. Managing Configuration Changes
    16. Example: Handling Configuration Changes
    17. Example: Manifest Declaration
    18. 7. Handling App Updates
    19. Example: Check for App Updates
    20. Update Handling Best Practices
    21. 8. Managing Multi-Window Mode
    22. Example: Check Multi-Window Mode
    23. Example: Handle Window Mode Changes
    24. Key Points
    25. 9. Handling Picture-in-Picture
    26. Example: Enter Picture-in-Picture Mode
    27. 10. Implementing App Shortcuts
    28. Example: Defining App Shortcuts
    29. Key Points

  56. Working with App Links

    1. 1. Understanding Deep Links vs App Links
    2. Example: Deep Link Intent
    3. Example: App Link Intent
    4. 2. Configuring Intent Filters
    5. Example: Intent Filter Configuration
    6. 3. Creating Asset Links File
    7. Example: assetlinks.json
    8. 4. Hosting Digital Asset Links
    9. Example: assetlinks.json content
    10. 5. Verifying App Links
    11. Example: Intent Filter with Auto-Verification
    12. 6. Handling Incoming Links
    13. Example: Handling App Link in Activity
    14. 7. Using Navigation Deep Links
    15. Example: Define Deep Link in Navigation Graph
    16. Example: Handle Deep Link in Activity
    17. 8. Implementing Deferred Deep Links
    18. Example: Setting up deferred deep links in AndroidManifest.xml
    19. Example: Handling deferred deep links in Kotlin
    20. 9. Testing App Links
    21. Example: Testing App Links with Android Studio
    22. Testing Workflow
    23. 10. Debugging App Link Verification
    24. Example: Using adb to verify App Links
    25. Debugging Steps

  57. Implementing In-App Purchases

    1. 1. Setting Up Google Play Billing
    2. Example: Basic Setup in AndroidManifest.xml
    3. Example: Adding Play Billing Library
    4. Setup Steps
    5. 2. Connecting to BillingClient
    6. Example: Initialize BillingClient
    7. 3. Querying Product Details
    8. Example: Querying Product Details
    9. 4. Launching Purchase Flow
    10. Example: Launching Purchase Flow
    11. 5. Processing Purchases
    12. Example: Handling Purchase
    13. Example: Verifying Purchase Token
    14. 6. Acknowledging Purchases
    15. Example: Acknowledging a Purchase
    16. 7. Consuming Consumables
    17. Example: Consuming a Consumable
    18. Consuming Consumables - Key Points
    19. 8. Handling Subscriptions
    20. Example: Querying Subscription Details
    21. Example: Purchasing a Subscription
    22. 9. Verifying Purchases
    23. Example: Verifying Purchase Data
    24. 10. Restoring Purchases
    25. Example: Restoring Purchases
    26. Key Points for Purchase Restoration

  58. Working with Testing

    1. 1. Writing Unit Tests
    2. Example: Basic Unit Test
    3. Example: Mocking with Mockito
    4. 2. Using Assertions
    5. Example: Using assertThrows
    6. 3. Mocking Dependencies
    7. Example: Using MockK to mock a repository
    8. Example: Mocking suspending functions
    9. 4. Testing ViewModels
    10. Example: Basic ViewModel Test
    11. Testing ViewModels - Key Points
    12. 5. Writing Instrumentation Tests
    13. Example: Espresso Test
    14. Key Points
    15. 6. Using Espresso for UI Testing
    16. Example: Basic Espresso Test
    17. Example: Testing EditText Input
    18. Key Features of Espresso
    19. 7. Testing RecyclerView Items
    20. Example: Basic RecyclerView Item Test
    21. Example: Testing Item Content
    22. 8. Implementing Idling Resources
    23. Example: Custom Idling Resource for Network Calls
    24. Example: Using Idling Resource in Espresso Test
    25. 9. Testing Intents
    26. Example: Testing Intent with Mockito
    27. 10. Testing Compose UI
    28. Example: Basic Compose UI Test
    29. Testing Compose UI - Key Points
    30. 11. Running Tests
    31. Example: Running Unit Tests
    32. Workflow: Running Tests in Android Studio

  59. Debugging Applications

    1. 1. Using Logcat
    2. Example: Basic Logcat Command
    3. Example: Filter Logs by Tag
    4. Example: Set Log Level
    5. Common Log Levels
    6. 2. Setting Breakpoints
    7. Example: Setting a Conditional Breakpoint
    8. 3. Inspecting Variables
    9. Example: Watching a Variable in Kotlin
    10. 4. Using Android Debug Bridge
    11. Example: View Logs
    12. Memory Profiler Capabilities
    13. Steps to Analyze Memory
    14. 6. Monitoring Network Traffic
    15. Example: Using OkHttp Interceptor for Logging
    16. Example: Configuring HttpLoggingInterceptor
    17. Network Monitoring Tools
    18. 7. Using Layout Inspector
    19. Example: Inspecting Layout Hierarchy
    20. Key Features
    21. 8. Detecting ANR Issues
    22. Example: Identifying ANR in Main Thread
    23. ANR Detection Methods
    24. 9. Analyzing Crash Reports
    25. Example: Parsing Crash Report
    26. 10. Using StrictMode for Detection
    27. Example: Enabling StrictMode

  60. Managing Build and Deployment

    1. 1. Creating Signed APK
    2. Example: Signing an APK with Gradle
    3. Steps to Create a Signed APK
    4. 2. Building Release Builds
    5. Example: Configure Release Build
    6. Example: Signing Config
    7. 3. Using App Bundles
    8. Example: Configuring App Bundle in Gradle
    9. Benefits of App Bundles
    10. 4. Configuring Versioning
    11. Example: Setting version in build.gradle.kts
    12. 5. Setting Up Continuous Integration
    13. Example: GitHub Actions Workflow
    14. CI Tools Comparison
    15. 6. Using Gradle Tasks
    16. Example: Custom Gradle Task
    17. Example: Task with Dependencies
    18. 7. Optimizing APK Size
    19. Example: Enable ProGuard/R8
    20. Example: Exclude Dependencies from Shrinking
    21. Example: Compress PNG Images
    22. APK Size Optimization Tips
    23. 8. Configuring Multi-APK Support
    24. Example: Basic Multi-APK Configuration
    25. Key Considerations
    26. 9. Testing Release Builds
    27. Example: Configure Release Build Signing
    28. Workflow: Testing Release Builds
    29. Comparison: Debug vs Release Builds
    30. 10. Publishing to Play Store
    31. 11. Using Play Feature Delivery
    32. Example: Configuring a Dynamic Feature Module
    33. Example: Using Feature Module in Base App