Book Image

Android UI Development with Jetpack Compose

By : Thomas Künneth
Book Image

Android UI Development with Jetpack Compose

By: Thomas Künneth

Overview of this book

Jetpack Compose is Android’s new framework for building fast, beautiful, and reliable native user interfaces. It simplifies and significantly accelerates UI development on Android using the declarative approach. This book will help developers to get hands-on with Jetpack Compose and adopt a modern way of building Android applications. The book is not an introduction to Android development, but it will build on your knowledge of how Android apps are developed. Complete with hands-on examples, this easy-to-follow guide will get you up to speed with the fundamentals of Jetpack Compose such as state hoisting, unidirectional data flow, and composition over inheritance and help you build your own Android apps using Compose. You'll also cover concepts such as testing, animation, and interoperability with the existing Android UI toolkit. By the end of the book, you'll be able to write your own Android apps using Jetpack Compose.

Related Content you might be interested in

Current Title:

Small book image
Android UI Development with Jetpack Compose
Thomas Künneth
Feb, 2022 | 248 pages
Small book image
Kickstart Modern Android Development with Jetpack and Kotlin
Catalin Ghita
May, 2022 | 472 pages
Small book image
Modern Android 13 Development Cookbook
Madona S Wambua
Jul, 2023 | 322 pages
Small book image
How to Build Android Apps with Kotlin
Eran Boudjnah | Alex Forrester | Alexandru Dumbravan | Jomar Tigcal
May, 2023 | 704 pages
Table of Contents (16 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Part 1:Fundamentals of Jetpack Compose
Part 1:Fundamentals of Jetpack Compose
Free Chapter
2
Chapter 1: Building Your First Compose App
Chapter 1: Building Your First Compose App
Technical requirements
Saying hello to composable functions
Using the preview
Running a Compose app
Summary
Further reading
3
Chapter 2: Understanding the Declarative Paradigm
Chapter 2: Understanding the Declarative Paradigm
Technical requirements
Looking at the Android view system
Moving from components to composable functions
Examining architectural aspects
Summary
4
Chapter 3: Exploring the Key Principles of Compose
Chapter 3: Exploring the Key Principles of Compose
Technical requirements
Looking closer at composable functions
Composing and recomposing the UI
Modifying the behavior of composable functions
Summary
5
Part 2:Building User Interfaces
Part 2:Building User Interfaces
6
Chapter 4: Laying Out UI Elements
Chapter 4: Laying Out UI Elements
Technical requirements
Using predefined layouts
Understanding the single measure pass
Creating custom layouts
Summary
7
Chapter 5: Managing the State of Your Composable Functions
Chapter 5: Managing the State of Your Composable Functions
Technical requirements
Understanding stateful and stateless composable functions
Hoisting state and passing events
Surviving configuration changes
Summary
8
Chapter 6: Putting Pieces Together
Chapter 6: Putting Pieces Together
Technical requirements
Styling a Compose app
Integrating toolbars and menus
Adding navigation
Summary
9
Chapter 7: Tips, Tricks, and Best Practices
Chapter 7: Tips, Tricks, and Best Practices
Technical requirements
Persisting and retrieving state
Keeping your composables responsive
Understanding side effects
Summary
10
Part 3:Advanced Topics
Part 3:Advanced Topics
11
Chapter 8: Working with Animations
Chapter 8: Working with Animations
Technical requirements
Using animation to visualize state changes
Showing and hiding UI elements with animations
Spicing up transitions through visual effects
Summary
12
Chapter 9: Exploring Interoperability APIs
Chapter 9: Exploring Interoperability APIs
Technical requirements
Showing Views in a Compose app
Sharing data between Views and composable functions
Embedding composables in View hierarchies
Summary
13
Chapter 10: Testing and Debugging Compose Apps
Chapter 10: Testing and Debugging Compose Apps
Technical requirements
Setting up and writing tests
Understanding semantics
Debugging Compose apps
Summary
Further reading
14
Chapter 11: Conclusion and Next Steps
Chapter 11: Conclusion and Next Steps
Technical requirements
Exploring the future
Migrating to Material You
Moving beyond Android
Summary
Why subscribe?
15
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Chapter 4: Laying Out UI Elements

In the previous chapters, you learned how to build simple UIs. Although they consisted of just a few UI elements, they needed to arrange their buttons, text fields, and sliders in a particular order, direction, or hierarchy. Layouts position and size their content in a way specific to this layout, such as horizontally (Row()) or vertically (Column()). This chapter explores layouts in greater detail.

In this chapter, we will cover the following topics:

  • Using predefined layouts
  • Understanding the single measure pass
  • Creating custom layouts

We will start by exploring the predefined layouts of Row(), Column(), and Box(). You will learn how to combine them to create beautiful UIs. Next, I'll introduce you to ConstraintLayout. It places composables that are relative to others on the screen and uses attributes to flatten the UI element hierarchy. This is an alternative to nesting Row(), Column(), and Box().

The second main...

Previous Section
End of Section 1
Next Section