Jetpack Compose 1.2 Essentials

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 Making the Android SDK tools command-line accessible
		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 Previewing the example project
	3.6 Reviewing the main activity
	3.7 Preview updates
	3.8 Upgrading to Jetpack Compose 1.2
	3.9 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 Testing in interactive mode
	4.10 Completing the project
	4.11 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 Running on multiple devices
	5.5 Stopping a running application
	5.6 Supporting dark theme
	5.7 Running the emulator in a separate window
	5.8 Enabling the device frame
	5.9 Summary
6. Using and Configuring the Android Studio AVD Emulator
	6.1 The emulator environment
	6.2 The 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 Summary
7. A Tour of the Android Studio User Interface
	7.1 The Welcome Screen
	7.2 The Main Window
	7.3 The Tool Windows
	7.4 Android Studio Keyboard Shortcuts
	7.5 Switcher and Recent Files Navigation
	7.6 Changing the Android Studio Theme
	7.7 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 Summary
9. The Basics of the Android Studio Code Editor
	9.1 The Android Studio editor
	9.2 Code mode
	9.3 Splitting the editor window
	9.4 Code completion
	9.5 Statement completion
	9.6 Parameter information
	9.7 Parameter name hints
	9.8 Code generation
	9.9 Code folding
	9.10 Quick documentation lookup
	9.11 Code reformatting
	9.12 Finding sample code
	9.13 Live templates
	9.14 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 Writing 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. Composing Layouts with Row and Column
	25.1 Creating the RowColDemo project
	25.2 Row composable
	25.3 Column composable
	25.4 Combining Row and Column composables
	25.5 Layout alignment
	25.6 Layout arrangement positioning
	25.7 Layout arrangement spacing
	25.8 Row and Column scope modifiers
	25.9 Scope modifier weights
	25.10 Summary
26. Box Layouts in Compose
	26.1 An introduction to the Box composable
	26.2 Creating the BoxLayout project
	26.3 Adding the TextCell composable
	26.4 Adding a Box layout
	26.5 Box alignment
	26.6 BoxScope modifiers
	26.7 Using the clip() modifier
	26.8 Summary
27. Custom Layout Modifiers
	27.1 Compose layout basics
	27.2 Custom layouts
	27.3 Creating the LayoutModifier project
	27.4 Adding the ColorBox composable
	27.5 Creating a custom layout modifier
	27.6 Understanding default position
	27.7 Completing the layout modifier
	27.8 Using a custom modifier
	27.9 Working with alignment lines
	27.10 Working with baselines
	27.11 Summary
28. Building Custom Layouts
	28.1 An overview of custom layouts
	28.2 Custom layout syntax
	28.3 Using a custom layout
	28.4 Creating the CustomLayout project
	28.5 Creating the CascadeLayout composable
	28.6 Using the CascadeLayout composable
	28.7 Summary
29. A Guide to ConstraintLayout in Compose
	29.1 An introduction to ConstraintLayout
	29.2 How ConstraintLayout works
		29.2.1 Constraints
		29.2.2 Margins
		29.2.3 Opposing constraints
		29.2.4 Constraint bias
		29.2.5 Chains
		29.2.6 Chain styles
	29.3 Configuring dimensions
	29.4 Guideline helper
	29.5 Barrier helper
	29.6 Summary
30. Working with ConstraintLayout in Compose
	30.1 Calling ConstraintLayout
	30.2 Generating references
	30.3 Assigning a reference to a composable
	30.4 Adding constraints
	30.5 Creating the ConstraintLayout project
	30.6 Adding the ConstraintLayout library
	30.7 Adding a custom button composable
	30.8 Basic constraints
	30.9 Opposing constraints
	30.10 Constraint bias
	30.11 Constraint margins
	30.12 The importance of opposing constraints and bias
	30.13 Creating chains
	30.14 Working with guidelines
	30.15 Working with barriers
	30.16 Decoupling constraints with constraint sets
	30.17 Summary
31. Working with IntrinsicSize in Compose
	31.1 Intrinsic measurements
	31.2 Max. vs Min. Intrinsic Size measurements
	31.3 About the example project
	31.4 Creating the IntrinsicSizeDemo project
	31.5 Creating the custom text field
	31.6 Adding the Text and Box components
	31.7 Adding the top-level Column
	31.8 Testing the project
	31.9 Applying IntrinsicSize.Max measurements
	31.10 Applying IntrinsicSize.Min measurements
	31.11 Summary
32. Coroutines and LaunchedEffects in Jetpack Compose
	32.1 What are coroutines?
	32.2 Threads vs. coroutines
	32.3 Coroutine Scope
	32.4 Suspend functions
	32.5 Coroutine dispatchers
	32.6 Coroutine builders
	32.7 Jobs
	32.8 Coroutines – suspending and resuming
	32.9 Coroutine channel communication
	32.10 Understanding side effects
	32.11 Summary
33. An Overview of Lists and Grids in Compose
	33.1 Standard vs. lazy lists
	33.2 Working with Column and Row lists
	33.3 Creating lazy lists
	33.4 Enabling scrolling with ScrollState
	33.5 Programmatic scrolling
	33.6 Sticky headers
	33.7 Responding to scroll position
	33.8 Creating a lazy grid
	33.9 Summary
34. A Compose Row and Column List Tutorial
	34.1 Creating the ListDemo project
	34.2 Creating a Column-based list
	34.3 Enabling list scrolling
	34.4 Manual scrolling
	34.5 A Row list example
	34.6 Summary
35. A Compose Lazy List Tutorial
	35.1 Creating the LazyListDemo project
	35.2 Adding list data to the project
	35.3 Reading the XML data
	35.4 Handling image loading
	35.5 Designing the list item composable
	35.6 Building the lazy list
	35.7 Testing the project
	35.8 Making list items clickable
	35.9 Summary
36. Lazy List Sticky Headers and Scroll Detection
	36.1 Grouping the list item data
	36.2 Displaying the headers and items
	36.3 Adding sticky headers
	36.4 Reacting to scroll position
	36.5 Adding the scroll button
	36.6 Testing the finished app
	36.7 Summary
37. Compose Visibility Animation
	37.1 Creating the AnimateVisibility project
	37.2 Animating visibility
	37.3 Defining enter and exit animations
	37.4 Animation specs and animation easing
	37.5 Repeating an animation
	37.6 Different animations for different children
	37.7 Auto-starting an animation
	37.8 Implementing crossfading
	37.9 Summary
38. Compose State-Driven Animation
	38.1 Understanding state-driven animation
	38.2 Introducing animate as state functions
	38.3 Creating the AnimateState project
	38.4 Animating rotation with animateFloatAsState
	38.5 Animating color changes with animateColorAsState
	38.6 Animating motion with animateDpAsState
	38.7 Adding spring effects
	38.8 Working with keyframes
	38.9 Combining multiple animations
	38.10 Using the Animation Inspector
	38.11 Summary
39. Canvas Graphics Drawing in Compose
	39.1 Introducing the Canvas component
	39.2 Creating the CanvasDemo project
	39.3 Drawing a line and getting the canvas size
	39.4 Drawing dashed lines
	39.5 Drawing a rectangle
	39.6 Applying rotation
	39.7 Drawing circles and ovals
	39.8 Drawing gradients
	39.9 Drawing arcs
	39.10 Drawing paths
	39.11 Drawing points
	39.12 Drawing an image
	39.13 Summary
40. Working with ViewModels in Compose
	40.1 What is Android Jetpack?
	40.2 The “old” architecture
	40.3 Modern Android architecture
	40.4 The ViewModel component
	40.5 ViewModel implementation using state
	40.6 Connecting a ViewModel state to an activity
	40.7 ViewModel implementation using LiveData
	40.8 Observing ViewModel LiveData within an activity
	40.9 Summary
41. A Compose ViewModel Tutorial
	41.1 About the project
	41.2 Creating the ViewModelDemo project
	41.3 Adding the ViewModel
	41.4 Accessing  DemoViewModel from MainActivity
	41.5 Designing the temperature input composable
	41.6 Designing the temperature input composable
	41.7 Completing the user interface design
	41.8 Testing the app
	41.9 Summary
42. An Overview of Android SQLite Databases
	42.1 Understanding database tables
	42.2 Introducing database schema
	42.3 Columns and data types
	42.4 Database rows
	42.5 Introducing primary keys
	42.6 What is SQLite?
	42.7 Structured Query Language (SQL)
	42.8 Trying SQLite on an Android Virtual Device (AVD)
	42.9 The Android Room persistence library
	42.10 Summary
43. Room Databases and Compose
	43.1 Revisiting modern app architecture
	43.2 Key elements of Room database persistence
		43.2.1 Repository
		43.2.2 Room database
		43.2.3 Data Access Object (DAO)
		43.2.4 Entities
		43.2.5 SQLite database
	43.3 Understanding entities
	43.4 Data Access Objects
	43.5 The Room database
	43.6 The Repository
	43.7 In-Memory databases
	43.8 Database Inspector
	43.9 Summary
44. A Compose Room Database and Repository Tutorial
	44.1 About the RoomDemo project
	44.2 Creating the RoomDemo project
	44.3 Modifying the build configuration
	44.4 Building the entity
	44.5 Creating the Data Access Object
	44.6 Adding the Room database
	44.7 Adding the repository
	44.8 Adding the ViewModel
	44.9 Designing the user interface
	44.10 Writing a ViewModelProvider Factory class
	44.11 Completing the MainScreen function
	44.12 Testing the RoomDemo app
	44.13 Using the Database Inspector
	44.14 Summary
45. An Overview of Navigation in Compose
	45.1 Understanding navigation
	45.2 Declaring a navigation controller
	45.3 Declaring a navigation host
	45.4 Adding destinations to the navigation graph
	45.5 Navigating to destinations
	45.6 Passing arguments to a destination
	45.7 Working with bottom navigation bars
	45.8 Summary
46. A Compose Navigation Tutorial
	46.1 Creating the NavigationDemo project
	46.2 About the NavigationDemo project
	46.3 Declaring the navigation routes
	46.4 Adding the home screen
	46.5 Adding the welcome screen
	46.6 Adding the profile screen
	46.7 Creating the navigation controller and host
	46.8 Implementing the screen navigation
	46.9 Passing the user name argument
	46.10 Testing the project
	46.11 Summary
47. A Compose Bottom Navigation Bar Tutorial
	47.1 Creating the BottomBarDemo project
	47.2 Declaring the navigation routes
	47.3 Designing bar items
	47.4 Creating the bar item list
	47.5 Adding the destination screens
	47.6 Creating the navigation controller and host
	47.7 Designing the navigation bar
	47.8 Working with the Scaffold component
	47.9 Testing the project
	47.10 Summary
48. Detecting Gestures in Compose
	48.1 Compose gesture detection
	48.2 Creating the GestureDemo project
	48.3 Detecting click gestures
	48.4 Detecting taps using PointerInputScope
	48.5 Detecting drag gestures
	48.6 Detecting drag gestures using PointerInputScope
	48.7 Scrolling using the scrollable modifier
	48.8 Scrolling using the scroll modifiers
	48.9 Detecting pinch gestures
	48.10 Detecting rotation gestures
	48.11 Detecting translation gestures
	48.12 Summary
49. Detecting Swipe Gestures in Compose
	49.1 Swipe gestures and anchors
	49.2 Detecting swipe gestures
	49.3 Declaring the anchors map
	49.4 Declaring thresholds
	49.5 Moving a component in response to a swipe
	49.6 About the SwipeDemo project
	49.7 Creating the SwipeDemo project
	49.8 Setting up the swipeable state and anchors
	49.9 Designing the parent Box
	49.10 Testing the project
	49.11 Summary
50. An Introduction to Kotlin Flow
	50.1 Understanding Flows
	50.2 Creating the sample project
	50.3 Adding a view model to the project
	50.4 Declaring the flow
	50.5 Emitting flow data
	50.6 Collecting flow data as state
	50.7 Transforming data with intermediaries
	50.8 Collecting flow data
	50.9 Adding a flow buffer
	50.10 More terminal flow operators
	50.11 Flow flattening
	50.12 Combining multiple flows
	50.13 Hot and cold flows
	50.14 StateFlow
	50.15 SharedFlow
	50.16 Converting a flow from cold to hot
	50.17 Summary
51. A Jetpack Compose SharedFlow Tutorial
	51.1 About the project
	51.2 Creating the SharedFlowDemo project
	51.3 Adding a view model to the project
	51.4 Declaring the SharedFlow
	51.5 Collecting the flow values
	51.6 Testing the SharedFlowDemo app
	51.7 Handling flows in the background
	51.8 Summary
52. Creating, Testing, and Uploading an Android App Bundle
	52.1 The release preparation process
	52.2 Android app bundles
	52.3 Register for a Google Play Developer Console account
	52.4 Configuring the app in the console
	52.5 Enabling Google Play app signing
	52.6 Creating a keystore file
	52.7 Creating the Android app bundle
	52.8 Generating test APK files
	52.9 Uploading the app bundle to the Google Play Developer Console
	52.10 Exploring the app bundle
	52.11 Managing testers
	52.12 Rolling the app out for testing
	52.13 Uploading new app bundle revisions
	52.14 Analyzing the app bundle file
	52.15 Summary
53. An Overview of Android In-App Billing
	53.1 Preparing a project for In-App purchasing
	53.2 Creating In-App products and subscriptions
	53.3 Billing client initialization
	53.4 Connecting to the Google Play Billing library
	53.5 Querying available products
	53.6 Starting the purchase process
	53.7 Completing the purchase
	53.8 Querying previous purchases
	53.9 Summary
54. An Android In-App Purchasing Tutorial
	54.1 About the In-App purchasing example project
	54.2 Creating the InAppPurchase project
	54.3 Adding libraries to the project
	54.4 Adding the App to the Google Play Store
	54.5 Creating an In-App product
	54.6 Enabling license testers
	54.7 Creating a purchase helper class
	54.8 Adding the StateFlow streams
	54.9 Initializing the billing client
	54.10 Querying the product
	54.11 Handling purchase updates
	54.12 Launching the purchase flow
	54.13 Consuming the product
	54.14 Restoring a previous purchase
	54.15 Completing the MainActivity
	54.16 Testing the app
	54.17 Troubleshooting
	54.18 Summary
55. Working with Compose Theming
	55.1 Material Design 2 vs Material Design 3
	55.2 Material Design 2 theming
	55.3 Material Design 3 theming
	55.4 Building a custom theme
	55.5 Summary
56. A Material Design 3 Theming Tutorial
	56.1 Creating the ThemeDemo project
	56.2 Adding the Material Design 3 library
	56.3 Designing the user interface
	56.4 Building a new theme
	56.5 Adding the theme to the project
	56.6 Enabling dynamic colors
	56.7 Summary
57. An Overview of Gradle in Android Studio
	57.1 An overview of Gradle
	57.2 Gradle and Android Studio
		57.2.1 Sensible defaults
		57.2.2 Dependencies
		57.2.3 Build variants
		57.2.4 Manifest entries
		57.2.5 APK signing
		57.2.6 ProGuard support
	57.3 The Properties and Settings Gradle build files
	57.4 The top-level gradle build file
	57.5 Module level Gradle build files
	57.6 Configuring signing settings in the build file
	57.7 Running Gradle tasks from the command-line
	57.8 Summary
Index
Blank Page