Android UI Development with Jetpack Compose Bring Declarative and Native UI to Life Quickly and Easily on Android Using Jetpack Compose and Kotlin
Compose has caused a paradigm shift in Android development, introducing a variety of new concepts that are essential to an Android developer’s learning journey. It solves a lot of pain points associated with Android development and is touted to become the default way to building Android apps over th...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham :
Packt Publishing
[2023]
|
| Edición: | Second edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009786738606719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Dedications
- Contributors
- Table of Contents
- Part 1: Fundamentals of Jetpack Compose
- Chapter 1: Building Your First Compose App
- Technical requirements
- Saying hello to composable functions
- Showing a welcome text
- Using rows, text fields, and buttons
- Showing a greeting message
- Using the preview
- Preview parameters
- Configuring previews
- Grouping previews
- Running a Compose app
- Deploying a composable function
- Using composable functions in activities
- Looking under the hood
- Pressing the play button
- Summary
- Further reading
- Questions
- Chapter 2: Understanding the Declarative Paradigm
- Technical requirements
- Looking at the Android view system
- Inflating layout files
- Modifying the UI
- Moving from components to composable functions
- Component hierarchies
- Limitations of component hierarchies
- Composing UIs with functions
- Examining architectural aspects
- Reacting to clicks
- Sizing and positioning UI elements
- Summary
- Exercise
- Chapter 3: Exploring the Key Principles of Compose
- Technical requirements
- Looking closer at composable functions
- Building blocks of composable functions
- Emitting UI elements
- Returning values
- Composing and recomposing the UI
- Sharing state among composable functions
- Controlling size
- Displaying a composable hierarchy inside an Activity
- Modifying the behavior of composable functions
- Understanding how modifiers work
- Implementing custom modifiers
- Summary
- Questions
- Part 2: Building User Interfaces
- Chapter 4: Laying Out UI Elements in Compose
- Technical requirements
- Using predefined layouts
- Combining basic building blocks
- Creating layouts based on constraints
- Understanding the single measure pass
- Defining measure policies.
- Creating custom layouts
- Implementing a custom measure policy
- Summary
- Questions
- Chapter 5: Managing State of Your Composable Functions
- Technical requirements
- Understanding stateful and stateless composable functions
- Using state in a composable function
- Writing stateless composable functions
- Hoisting state and passing events
- Creating radio button groups
- Surviving configuration changes
- Using ViewModel
- Summary
- Questions
- Chapter 6: Building a Real-World App
- Technical requirements
- Styling a Compose app
- Defining colors, shapes, and text styles
- Using resource-based themes
- Integrating toolbars and menus
- Using Scaffold() to structure your screen
- Creating a top app bar
- Adding navigation
- Defining screens
- Using NavHostController and NavHost()
- Summary
- Questions
- Chapter 7: Exploring App Architecture
- Technical requirements
- Persisting and retrieving state
- Injecting objects into a ViewModel
- Using the factory
- Keeping your composables responsive
- Communicating with ViewModel instances
- Handling long-running tasks
- Understanding side effects
- Invoking suspending functions
- Cleaning up with DisposableEffect()
- Summary
- Questions
- Exercise
- Part 3: Advanced Topics
- Chapter 8: Working with Animations
- Technical requirements
- Using animation to visualize state changes
- Animating single value changes
- Animating multiple value changes
- Showing and hiding UI elements with animations
- Understanding AnimatedVisibility()
- Animating size changes
- Spicing up transitions through visual effects
- Crossfading composable functions
- Understanding animation specifications
- Summary
- Exercise
- Chapter 9: Exploring Interoperability APIs
- Technical requirements
- Showing Views in a Compose app
- Adding custom components to a Compose app.
- Inflating View hierarchies with AndroidViewBinding()
- Sharing data between Views and composable functions
- Revisiting ViewModels
- Combining View Binding and ViewModels
- Embedding composables in View hierarchies
- Summary
- Questions
- Chapter 10: Testing and Debugging Compose Apps
- Technical requirements
- Setting up and writing tests
- Implementing unit tests
- Testing composable functions
- Understanding semantics
- Working with semantics nodes
- Adding custom semantics properties
- Debugging Compose apps
- Using custom modifiers for logging and debugging
- Summary
- Further reading
- Questions
- Chapter 11: Developing for Different Form Factors
- Technical requirements
- Understanding different form factors
- Preparing for adaptive layouts
- Enhancing the UI
- Introducing Window Size Classes
- Using Jetpack WindowManager
- Reading hinge and fold features
- Organizing the screen content
- Summary
- Exercise
- Chapter 12: Bringing Your Compose UI to Different Platforms
- Technical requirements
- Introducing Compose Multiplatform
- Setting up a Compose Multiplatform project
- Running the sample app
- Building a cross-platform app
- Accessing composables from platform-specific code
- Developing across platforms
- Using Mobile Kotlin resources
- Summary
- Exercise
- Index
- Other Books You May Enjoy.
