Jetpack Compose 1.4 Essentials: Developing Android Apps with Jetpack Compose 1.4, Android Studio, and Kotlin

✍ Scribed by Neil Smyth

• Publisher: Payload Media
• Year: 2023
• Tongue: English
• Leaves: 938
• Category: Library

✦ Synopsis

This book teaches you how to build Android applications using Jetpack Compose 1.4, Android Studio Giraffe (2023.2.1), Material Design 3, and the Kotlin programming language.

The book begins with the basics by explaining how to set up an Android Studio development environment.

The book also includes in-depth chapters introducing the Kotlin programming language, including data types, operators, control flow, functions, lambdas, coroutines, and object-oriented programming.

An introduction to the key concepts of Jetpack Compose and Android project architecture is followed by a guided tour of Android Studio in Compose development mode. The book also covers the creation of custom Composables and explains how functions are combined to create user interface layouts, including row, column, box, flow, pager, and list components.

Other topics covered include data handling using state properties, key user interface design concepts such as modifiers, navigation bars, and user interface navigation. Additional chapters explore building your own reusable custom layout components.

The book covers graphics drawing, user interface animation, transitions, Kotlin Flows, and gesture handling.

Chapters also cover view models, SQLite databases, Room database access, the Database Inspector, live data, and custom theme creation. Using in-app billing, you will also learn to generate extra revenue from your app.

Finally, the book explains how to package up a completed app and upload it to the Google Play Store for publication.

Along the way, the topics covered in the book are put into practice through detailed tutorials, the source code for which is also available for download.

Assuming you already have some rudimentary programming experience, are ready to download Android Studio and the Android SDK, and have access to a Windows, Mac, or Linux system, you are ready to start.

✦ Table of Contents

1. Start Here
   1.1 For Kotlin programmers
   1.2 For new Kotlin programmers
   1.3 Downloading the code samples
   1.4 Feedback
   1.5 Errata
2. Setting up an Android Studio Development Environment
   2.1 System requirements
   2.2 Downloading the Android Studio package
   2.3 Installing Android Studio
   2.3.1 Installation on Windows
   2.3.2 Installation on macOS
   2.3.3 Installation on Linux
   2.4 The Android Studio setup wizard
   2.5 Installing additional Android SDK packages
   2.6 Installing the Android SDK Command-line Tools
   2.6.1 Windows 8.1
   2.6.2 Windows 10
   2.6.3 Windows 11
   2.6.4 Linux
   2.6.5 macOS
   2.7 Android Studio memory management
   2.8 Updating Android Studio and the SDK
   2.9 Summary
3. A Compose Project Overview
   3.1 About the project
   3.2 Creating the project
   3.3 Creating an activity
   3.4 Defining the project and SDK settings
   3.5 Enabling the New Android Studio UI
   3.6 Previewing the example project
   3.7 Reviewing the main activity
   3.8 Preview updates
   3.9 Bill of Materials and the Compose version
   3.10 Summary
4. An Example Compose Project
   4.1 Getting started
   4.2 Removing the template Code
   4.3 The Composable hierarchy
   4.4 Adding the DemoText composable
   4.5 Previewing the DemoText composable
   4.6 Adding the DemoSlider composable
   4.7 Adding the DemoScreen composable
   4.8 Previewing the DemoScreen composable
   4.9 Adjusting preview settings
   4.10 Testing in interactive mode
   4.11 Completing the project
   4.12 Summary
5. Creating an Android Virtual Device (AVD) in Android Studio
   5.1 About Android Virtual Devices
   5.2 Starting the Emulator
   5.3 Running the Application in the AVD
   5.4 Real-time updates with Live Edit
   5.5 Running on Multiple Devices
   5.6 Stopping a Running Application
   5.7 Supporting Dark Theme
   5.8 Running the Emulator in a Separate Window
   5.9 Enabling the Device Frame
   5.10 Summary
6. Using and Configuring the Android Studio AVD Emulator
   6.1 The Emulator Environment
   6.2 Emulator Toolbar Options
   6.3 Working in Zoom Mode
   6.4 Resizing the Emulator Window
   6.5 Extended Control Options
   6.5.1 Location
   6.5.2 Displays
   6.5.3 Cellular
   6.5.4 Battery
   6.5.5 Camera
   6.5.6 Phone
   6.5.7 Directional Pad
   6.5.8 Microphone
   6.5.9 Fingerprint
   6.5.10 Virtual Sensors
   6.5.11 Snapshots
   6.5.12 Record and Playback
   6.5.13 Google Play
   6.5.14 Settings
   6.5.15 Help
   6.6 Working with Snapshots
   6.7 Configuring Fingerprint Emulation
   6.8 The Emulator in Tool Window Mode
   6.9 Creating a Resizable Emulator
   6.10 Summary
7. A Tour of the Android Studio User Interface
   7.1 The Welcome Screen
   7.2 The Menu Bar
   7.3 The Main Window
   7.4 The Tool Windows
   7.5 The Tool Window Menus
   7.6 Android Studio Keyboard Shortcuts
   7.7 Switcher and Recent Files Navigation
   7.8 Changing the Android Studio Theme
   7.9 Summary
8. Testing Android Studio Apps on a Physical Android Device
   8.1 An Overview of the Android Debug Bridge (ADB)
   8.2 Enabling USB Debugging ADB on Android Devices
   8.2.1 macOS ADB Configuration
   8.2.2 Windows ADB Configuration
   8.2.3 Linux adb Configuration
   8.3 Resolving USB Connection Issues
   8.4 Enabling Wireless Debugging on Android Devices
   8.5 Testing the adb Connection
   8.6 Device Mirroring
   8.7 Summary
9. The Basics of the Android Studio Code Editor
   9.1 The Android Studio Editor
   9.2 Splitting the Editor Window
   9.3 Code Completion
   9.4 Statement Completion
   9.5 Parameter Information
   9.6 Parameter Name Hints
   9.7 Code Generation
   9.8 Code Folding
   9.9 Quick Documentation Lookup
   9.10 Code Reformatting
   9.11 Finding Sample Code
   9.12 Live Templates
   9.13 Summary
10. An Overview of the Android Architecture
    10.1 The Android software stack
    10.2 The Linux kernel
    10.3 Android runtime – ART
    10.4 Android libraries
    10.4.1 C/C++ libraries
    10.5 Application framework
    10.6 Applications
    10.7 Summary
11. An Introduction to Kotlin
    11.1 What is Kotlin?
    11.2 Kotlin and Java
    11.3 Converting from Java to Kotlin
    11.4 Kotlin and Android Studio
    11.5 Experimenting with Kotlin
    11.6 Semi-colons in Kotlin
    11.7 Summary
12. Kotlin Data Types, Variables and Nullability
    12.1 Kotlin data types
    12.1.1 Integer data types
    12.1.2 Floating point data types
    12.1.3 Boolean data type
    12.1.4 Character data type
    12.1.5 String data type
    12.1.6 Escape sequences
    12.2 Mutable variables
    12.3 Immutable variables
    12.4 Declaring mutable and immutable variables
    12.5 Data types are objects
    12.6 Type annotations and type inference
    12.7 Nullable type
    12.8 The safe call operator
    12.9 Not-null assertion
    12.10 Nullable types and the let function
    12.11 Late initialization (lateinit)
    12.12 The Elvis operator
    12.13 Type casting and type checking
    12.14 Summary
13. Kotlin Operators and Expressions
    13.1 Expression syntax in Kotlin
    13.2 The Basic assignment operator
    13.3 Kotlin arithmetic operators
    13.4 Augmented assignment operators
    13.5 Increment and decrement operators
    13.6 Equality operators
    13.7 Boolean logical operators
    13.8 Range operator
    13.9 Bitwise operators
    13.9.1 Bitwise inversion
    13.9.2 Bitwise AND
    13.9.3 Bitwise OR
    13.9.4 Bitwise XOR
    13.9.5 Bitwise left shift
    13.9.6 Bitwise right shift
    13.10 Summary
14. Kotlin Control Flow
    14.1 Looping control flow
    14.1.1 The Kotlin for-in Statement
    14.1.2 The while loop
    14.1.3 The do ... while loop
    14.1.4 Breaking from Loops
    14.1.5 The continue statement
    14.1.6 Break and continue labels
    14.2 Conditional control flow
    14.2.1 Using the if expressions
    14.2.2 Using if ... else … expressions
    14.2.3 Using if ... else if ... Expressions
    14.2.4 Using the when statement
    14.3 Summary
15. An Overview of Kotlin Functions and Lambdas
    15.1 What is a function?
    15.2 How to declare a Kotlin function
    15.3 Calling a Kotlin function
    15.4 Single expression functions
    15.5 Local functions
    15.6 Handling return values
    15.7 Declaring default function parameters
    15.8 Variable number of function parameters
    15.9 Lambda expressions
    15.10 Higher-order functions
    15.11 Summary
16. The Basics of Object-Oriented Programming in Kotlin
    16.1 What is an object?
    16.2 What is a class?
    16.3 Declaring a Kotlin class
    16.4 Adding properties to a class
    16.5 Defining methods
    16.6 Declaring and initializing a class instance
    16.7 Primary and secondary constructors
    16.8 Initializer blocks
    16.9 Calling methods and accessing properties
    16.10 Custom accessors
    16.11 Nested and inner classes
    16.12 Companion objects
    16.13 Summary
17. An Introduction to Kotlin Inheritance and Subclassing
    17.1 Inheritance, classes, and subclasses
    17.2 Subclassing syntax
    17.3 A Kotlin inheritance example
    17.4 Extending the functionality of a subclass
    17.5 Overriding inherited methods
    17.6 Adding a custom secondary constructor
    17.7 Using the SavingsAccount class
    17.8 Summary
18. An Overview of Compose
    18.1 Development before Compose
    18.2 Compose declarative syntax
    18.3 Compose is data-driven
    18.4 Summary
19. Composable Functions Overview
    19.1 What is a composable function?
    19.2 Stateful vs. stateless composables
    19.3 Composable function syntax
    19.4 Foundation and Material composables
    19.5 Summary
20. An Overview of Compose State and Recomposition
    20.1 The basics of state
    20.2 Introducing recomposition
    20.3 Creating the StateExample project
    20.4 Declaring state in a composable
    20.5 Unidirectional data flow
    20.6 State hoisting
    20.7 Saving state through configuration changes
    20.8 Summary
21. An Introduction to Composition Local
    21.1 Understanding CompositionLocal
    21.2 Using CompositionLocal
    21.3 Creating the CompLocalDemo project
    21.4 Designing the layout
    21.5 Adding the CompositionLocal state
    21.6 Accessing the CompositionLocal state
    21.7 Testing the design
    21.8 Summary
22. An Overview of Compose Slot APIs
    22.1 Understanding slot APIs
    22.2 Declaring a slot API
    22.3 Calling slot API composables
    22.4 Summary
23. A Compose Slot API Tutorial
    23.1 About the project
    23.2 Creating the SlotApiDemo project
    23.3 Preparing the MainActivity class file
    23.4 Creating the MainScreen composable
    23.5 Adding the ScreenContent composable
    23.6 Creating the Checkbox composable
    23.7 Implementing the ScreenContent slot API
    23.8 Adding an Image drawable resource
    23.9 Coding the TitleImage composable
    23.10 Completing the MainScreen composable
    23.11 Previewing the project
    23.12 Summary
24. Using Modifiers in Compose
    24.1 An overview of modifiers
    24.2 Creating the ModifierDemo project
    24.3 Creating a modifier
    24.4 Modifier ordering
    24.5 Adding modifier support to a composable
    24.6 Common built-in modifiers
    24.7 Combining modifiers
    24.8 Summary
25. Annotated Strings and Brush Styles
    25.1 What are annotated strings?
    25.2 Using annotated strings
    25.3 Brush Text Styling
    25.4 Creating the example project
    25.5 An example SpanStyle annotated string
    25.6 An example ParagraphStyle annotated string
    25.7 A Brush style example
    25.8 Summary
26. Composing Layouts with Row and Column
    26.1 Creating the RowColDemo project
    26.2 Row composable
    26.3 Column composable
    26.4 Combining Row and Column composables
    26.5 Layout alignment
    26.6 Layout arrangement positioning
    26.7 Layout arrangement spacing
    26.8 Row and Column scope modifiers
    26.9 Scope modifier weights
    26.10 Summary
27. Box Layouts in Compose
    27.1 An introduction to the Box composable
    27.2 Creating the BoxLayout project
    27.3 Adding the TextCell composable
    27.4 Adding a Box layout
    27.5 Box alignment
    27.6 BoxScope modifiers
    27.7 Using the clip() modifier
    27.8 Summary
28. An Introduction to FlowRow and FlowColumn
    28.1 FlowColumn and FlowRow
    28.2 Maximum number of items
    28.3 Working with main axis arrangement
    28.4 Understanding cross-axis arrangement
    28.5 Item alignment
    28.6 Controlling item size
    28.7 Summary
29. A FlowRow and FlowColumn Tutorial
    29.1 Creating the FlowLayoutDemo project
    29.2 Generating random height and color values
    29.3 Adding the Box Composable
    29.4 Modifying the Flow arrangement
    29.5 Modifying item alignment
    29.6 Switching to FlowColumn
    29.7 Using cross-axis arrangement
    29.8 Adding item weights
    29.9 Summary
30. Custom Layout Modifiers
    30.1 Compose layout basics
    30.2 Custom layouts
    30.3 Creating the LayoutModifier project
    30.4 Adding the ColorBox composable
    30.5 Creating a custom layout modifier
    30.6 Understanding default position
    30.7 Completing the layout modifier
    30.8 Using a custom modifier
    30.9 Working with alignment lines
    30.10 Working with baselines
    30.11 Summary
31. Building Custom Layouts
    31.1 An overview of custom layouts
    31.2 Custom layout syntax
    31.3 Using a custom layout
    31.4 Creating the CustomLayout project
    31.5 Creating the CascadeLayout composable
    31.6 Using the CascadeLayout composable
    31.7 Summary
32. A Guide to ConstraintLayout in Compose
    32.1 An introduction to ConstraintLayout
    32.2 How ConstraintLayout works
    32.2.1 Constraints
    32.2.2 Margins
    32.2.3 Opposing constraints
    32.2.4 Constraint bias
    32.2.5 Chains
    32.2.6 Chain styles
    32.3 Configuring dimensions
    32.4 Guideline helper
    32.5 Barrier helper
    32.6 Summary
33. Working with ConstraintLayout in Compose
    33.1 Calling ConstraintLayout
    33.2 Generating references
    33.3 Assigning a reference to a composable
    33.4 Adding constraints
    33.5 Creating the ConstraintLayout project
    33.6 Adding the ConstraintLayout library
    33.7 Adding a custom button composable
    33.8 Basic constraints
    33.9 Opposing constraints
    33.10 Constraint bias
    33.11 Constraint margins
    33.12 The importance of opposing constraints and bias
    33.13 Creating chains
    33.14 Working with guidelines
    33.15 Working with barriers
    33.16 Decoupling constraints with constraint sets
    33.17 Summary
34. Working with IntrinsicSize in Compose
    34.1 Intrinsic measurements
    34.2 Max. vs Min. Intrinsic Size measurements
    34.3 About the example project
    34.4 Creating the IntrinsicSizeDemo project
    34.5 Creating the custom text field
    34.6 Adding the Text and Box components
    34.7 Adding the top-level Column
    34.8 Testing the project
    34.9 Applying IntrinsicSize.Max measurements
    34.10 Applying IntrinsicSize.Min measurements
    34.11 Summary
35. Coroutines and LaunchedEffects in Jetpack Compose
    35.1 What are coroutines?
    35.2 Threads vs. coroutines
    35.3 Coroutine Scope
    35.4 Suspend functions
    35.5 Coroutine dispatchers
    35.6 Coroutine builders
    35.7 Jobs
    35.8 Coroutines – suspending and resuming
    35.9 Coroutine channel communication
    35.10 Understanding side effects
    35.11 Summary
36. An Overview of Lists and Grids in Compose
    36.1 Standard vs. lazy lists
    36.2 Working with Column and Row lists
    36.3 Creating lazy lists
    36.4 Enabling scrolling with ScrollState
    36.5 Programmatic scrolling
    36.6 Sticky headers
    36.7 Responding to scroll position
    36.8 Creating a lazy grid
    36.9 Summary
37. A Compose Row and Column List Tutorial
    37.1 Creating the ListDemo project
    37.2 Creating a Column-based list
    37.3 Enabling list scrolling
    37.4 Manual scrolling
    37.5 A Row list example
    37.6 Summary
38. A Compose Lazy List Tutorial
    38.1 Creating the LazyListDemo project
    38.2 Adding list data to the project
    38.3 Reading the XML data
    38.4 Handling image loading
    38.5 Designing the list item composable
    38.6 Building the lazy list
    38.7 Testing the project
    38.8 Making list items clickable
    38.9 Summary
39. Lazy List Sticky Headers and Scroll Detection
    39.1 Grouping the list item data
    39.2 Displaying the headers and items
    39.3 Adding sticky headers
    39.4 Reacting to scroll position
    39.5 Adding the scroll button
    39.6 Testing the finished app
    39.7 Summary
40. A Compose Lazy Staggered Grid Tutorial
    40.1 Lazy Staggered Grids
    40.2 Creating the StaggeredGridDemo project
    40.3 Adding the Box composable
    40.4 Generating random height and color values
    40.5 Creating the Staggered List
    40.6 Testing the project
    40.7 Switching to a horizontal staggered grid
    40.8 Summary
41. VerticalPager and HorizontalPager in Compose
    41.1 The Pager composables
    41.2 Working with pager state
    41.3 About the PagerDemo project
    41.4 Creating the PagerDemo project
    41.5 Modifying the build configuration
    41.6 Adding the book cover images
    41.7 Adding the HorizontalPager
    41.8 Creating the page content
    41.9 Testing the pager
    41.10 Adding the arrow buttons
    41.11 Summary
42. Compose Visibility Animation
    42.1 Creating the AnimateVisibility project
    42.2 Animating visibility
    42.3 Defining enter and exit animations
    42.4 Animation specs and animation easing
    42.5 Repeating an animation
    42.6 Different animations for different children
    42.7 Auto-starting an animation
    42.8 Implementing crossfading
    42.9 Summary
43. Compose State-Driven Animation
    43.1 Understanding state-driven animation
    43.2 Introducing animate as state functions
    43.3 Creating the AnimateState project
    43.4 Animating rotation with animateFloatAsState
    43.5 Animating color changes with animateColorAsState
    43.6 Animating motion with animateDpAsState
    43.7 Adding spring effects
    43.8 Working with keyframes
    43.9 Combining multiple animations
    43.10 Using the Animation Inspector
    43.11 Summary
44. Canvas Graphics Drawing in Compose
    44.1 Introducing the Canvas component
    44.2 Creating the CanvasDemo project
    44.3 Drawing a line and getting the canvas size
    44.4 Drawing dashed lines
    44.5 Drawing a rectangle
    44.6 Applying rotation
    44.7 Drawing circles and ovals
    44.8 Drawing gradients
    44.9 Drawing arcs
    44.10 Drawing paths
    44.11 Drawing points
    44.12 Drawing an image
    44.13 Drawing text
    44.14 Summary
45. Working with ViewModels in Compose
    45.1 What is Android Jetpack?
    45.2 The “old” architecture
    45.3 Modern Android architecture
    45.4 The ViewModel component
    45.5 ViewModel implementation using state
    45.6 Connecting a ViewModel state to an activity
    45.7 ViewModel implementation using LiveData
    45.8 Observing ViewModel LiveData within an activity
    45.9 Summary
46. A Compose ViewModel Tutorial
    46.1 About the project
    46.2 Creating the ViewModelDemo project
    46.3 Adding the ViewModel
    46.4 Accessing DemoViewModel from MainActivity
    46.5 Designing the temperature input composable
    46.6 Designing the temperature input composable
    46.7 Completing the user interface design
    46.8 Testing the app
    46.9 Summary
47. An Overview of Android SQLite Databases
    47.1 Understanding database tables
    47.2 Introducing database schema
    47.3 Columns and data types
    47.4 Database rows
    47.5 Introducing primary keys
    47.6 What is SQLite?
    47.7 Structured Query Language (SQL)
    47.8 Trying SQLite on an Android Virtual Device (AVD)
    47.9 The Android Room persistence library
    47.10 Summary
48. Room Databases and Compose
    48.1 Revisiting modern app architecture
    48.2 Key elements of Room database persistence
    48.2.1 Repository
    48.2.2 Room database
    48.2.3 Data Access Object (DAO)
    48.2.4 Entities
    48.2.5 SQLite database
    48.3 Understanding entities
    48.4 Data Access Objects
    48.5 The Room database
    48.6 The Repository
    48.7 In-Memory databases
    48.8 Database Inspector
    48.9 Summary
49. A Compose Room Database and Repository Tutorial
    49.1 About the RoomDemo project
    49.2 Creating the RoomDemo project
    49.3 Modifying the build configuration
    49.4 Building the entity
    49.5 Creating the Data Access Object
    49.6 Adding the Room database
    49.7 Adding the repository
    49.8 Adding the ViewModel
    49.9 Designing the user interface
    49.10 Writing a ViewModelProvider Factory class
    49.11 Completing the MainScreen function
    49.12 Testing the RoomDemo app
    49.13 Using the Database Inspector
    49.14 Summary
50. An Overview of Navigation in Compose
    50.1 Understanding navigation
    50.2 Declaring a navigation controller
    50.3 Declaring a navigation host
    50.4 Adding destinations to the navigation graph
    50.5 Navigating to destinations
    50.6 Passing arguments to a destination
    50.7 Working with bottom navigation bars
    50.8 Summary
51. A Compose Navigation Tutorial
    51.1 Creating the NavigationDemo project
    51.2 About the NavigationDemo project
    51.3 Declaring the navigation routes
    51.4 Adding the home screen
    51.5 Adding the welcome screen
    51.6 Adding the profile screen
    51.7 Creating the navigation controller and host
    51.8 Implementing the screen navigation
    51.9 Passing the user name argument
    51.10 Testing the project
    51.11 Summary
52. A Compose Navigation Bar Tutorial
    52.1 Creating the BottomBarDemo project
    52.2 Declaring the navigation routes
    52.3 Designing bar items
    52.4 Creating the bar item list
    52.5 Adding the destination screens
    52.6 Creating the navigation controller and host
    52.7 Designing the navigation bar
    52.8 Working with the Scaffold component
    52.9 Testing the project
    52.10 Summary
53. Detecting Gestures in Compose
    53.1 Compose gesture detection
    53.2 Creating the GestureDemo project
    53.3 Detecting click gestures
    53.4 Detecting taps using PointerInputScope
    53.5 Detecting drag gestures
    53.6 Detecting drag gestures using PointerInputScope
    53.7 Scrolling using the scrollable modifier
    53.8 Scrolling using the scroll modifiers
    53.9 Detecting pinch gestures
    53.10 Detecting rotation gestures
    53.11 Detecting translation gestures
    53.12 Summary
54. An Introduction to Kotlin Flow
    54.1 Understanding Flows
    54.2 Creating the sample project
    54.3 Adding a view model to the project
    54.4 Declaring the flow
    54.5 Emitting flow data
    54.6 Collecting flow data as state
    54.7 Transforming data with intermediaries
    54.8 Collecting flow data
    54.9 Adding a flow buffer
    54.10 More terminal flow operators
    54.11 Flow flattening
    54.12 Combining multiple flows
    54.13 Hot and cold flows
    54.14 StateFlow
    54.15 SharedFlow
    54.16 Converting a flow from cold to hot
    54.17 Summary
55. A Jetpack Compose SharedFlow Tutorial
    55.1 About the project
    55.2 Creating the SharedFlowDemo project
    55.3 Adding a view model to the project
    55.4 Declaring the SharedFlow
    55.5 Collecting the flow values
    55.6 Testing the SharedFlowDemo app
    55.7 Handling flows in the background
    55.8 Summary
56. Creating, Testing, and Uploading an Android App Bundle
    56.1 The Release Preparation Process
    56.2 Android App Bundles
    56.3 Register for a Google Play Developer Console Account
    56.4 Configuring the App in the Console
    56.5 Enabling Google Play App Signing
    56.6 Creating a Keystore File
    56.7 Creating the Android App Bundle
    56.8 Generating Test APK Files
    56.9 Uploading the App Bundle to the Google Play Developer Console
    56.10 Exploring the App Bundle
    56.11 Managing Testers
    56.12 Rolling the App Out for Testing
    56.13 Uploading New App Bundle Revisions
    56.14 Analyzing the App Bundle File
    56.15 Summary
57. An Overview of Android In-App Billing
    57.1 Preparing a project for In-App purchasing
    57.2 Creating In-App products and subscriptions
    57.3 Billing client initialization
    57.4 Connecting to the Google Play Billing library
    57.5 Querying available products
    57.6 Starting the purchase process
    57.7 Completing the purchase
    57.8 Querying previous purchases
    57.9 Summary
58. An Android In-App Purchasing Tutorial
    58.1 About the In-App purchasing example project
    58.2 Creating the InAppPurchase project
    58.3 Adding libraries to the project
    58.4 Adding the App to the Google Play Store
    58.5 Creating an In-App product
    58.6 Enabling license testers
    58.7 Creating a purchase helper class
    58.8 Adding the StateFlow streams
    58.9 Initializing the billing client
    58.10 Querying the product
    58.11 Handling purchase updates
    58.12 Launching the purchase flow
    58.13 Consuming the product
    58.14 Restoring a previous purchase
    58.15 Completing the MainActivity
    58.16 Testing the app
    58.17 Troubleshooting
    58.18 Summary
59. Working with Compose Theming
    59.1 Material Design 2 vs. Material Design 3
    59.2 Material Design 3 theming
    59.3 Building a custom theme
    59.4 Summary
60. A Material Design 3 Theming Tutorial
    60.1 Creating the ThemeDemo project
    60.2 Designing the user interface
    60.3 Building a new theme
    60.4 Adding the theme to the project
    60.5 Enabling dynamic colors
    60.6 Summary
61. An Overview of Gradle in Android Studio
    61.1 An Overview of Gradle
    61.2 Gradle and Android Studio
    61.2.1 Sensible Defaults
    61.2.2 Dependencies
    61.2.3 Build Variants
    61.2.4 Manifest Entries
    61.2.5 APK Signing
    61.2.6 ProGuard Support
    61.3 The Property and Settings Gradle Build File
    61.4 The Top-level Gradle Build File
    61.5 Module Level Gradle Build Files
    61.6 Configuring Signing Settings in the Build File
    61.7 Running Gradle Tasks from the Command Line
    61.8 Summary
    Index