Everand Logo

Welcome to Everand!

  • Discover millions of ebooks, audiobooks, and so much more with a free trial

    From $11.99/month after trial. Cancel anytime.

    Jetpack Compose 1.5 Essentials: Developing Android Apps with Jetpack Compose 1.5, Android Studio, and Kotlin
    Jetpack Compose 1.5 Essentials: Developing Android Apps with Jetpack Compose 1.5, Android Studio, and Kotlin
    Jetpack Compose 1.5 Essentials: Developing Android Apps with Jetpack Compose 1.5, Android Studio, and Kotlin
    Ebook1,413 pages19 hours

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

    By Neil Smyth

    ()

    Read preview

    About this ebook

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


    The book begins with the basics by explaining how to set up an Android Studio d

    LanguageEnglish
    PublisherPayload Media, Inc.
    Release dateJan 8, 2024
    ISBN9798869111784
    Jetpack Compose 1.5 Essentials: Developing Android Apps with Jetpack Compose 1.5, Android Studio, and Kotlin

    Read more from Neil Smyth

    Related to Jetpack Compose 1.5 Essentials

    Related ebooks

    Programming For You

    View More
    View More

    Related podcast episodes

    Related articles

    • UNLIMITED

      Websocket

      Mar 7, 2023

      Mihalis Tsoukalos is a systems engineer and a technical writer. He is the author of Go Systems Programming and Mastering Go. You can reach him at @mactsouk. This tutorial covers the WebSocket protocol and how to work with it using the Go programming

      8 min read

    • UNLIMITED

      Metrics & Visuals In Go

      Nov 17, 2020

      Mihalis Tsoukalos is a DataOps engineer and a technical writer. He’s the author of Go Systems Programming and Mastering Go, 2nd edition. The subject of this tutorial is two-fold. First, it’s about creating a Go application that exports metrics to P

      7 min read

    • UNLIMITED

      Join the Pod, Man!

      May 30, 2023

      Join the Pod, Man!
      8 min read

    • UNLIMITED

      What Is The Future Of Game Streaming Now That Stadia Is Dead?

      Oct 31, 2022

      Once hyped as being ‘the future of gaming’, the Google Stadia game streaming service was officially, just three years after launch and before even making it to Australian shores. When game streaming first launched we did have some apprehension about

      2 min read

    • UNLIMITED

      How To Develop A RESTful Client In Go

      Nov 16, 2021

      Mihalis Tsoukalos is a systems engineer and technical writer. He’s the author of Go Systems Programming and Mastering Go. You can reach him at @mactsouk. The subject of this month’s tutorial is RESTful services. In particular, you’re going to learn h

      9 min read

    • UNLIMITED

      Usability

      Oct 19, 2021

      Usability
      3 min read

    • UNLIMITED

      Access Your Mac Anywhere

      Nov 8, 2022

      Access Your Mac Anywhere
      2 min read

    • UNLIMITED

      The Empire Strikes Back

      Jul 21, 2020

      The Empire Strikes Back
      9 min read

    • UNLIMITED

      QEMU, KVM And The Other Ones

      Feb 9, 2021

      QEMU, KVM And The Other Ones
      4 min read

    • UNLIMITED

      Basic Concepts

      Jul 2, 2019

      A messaging system such as Kafka enables you to send messages between processes, applications and servers. Applications connect to Kafka to send or get data. Strictly speaking, a Kafka ‘topic’ is a unit of storage in Kafka: data in Kafka is stored in

      1 min read

    • UNLIMITED

      Roundup

      Dec 13, 2022

      Roundup
      13 min read

    • UNLIMITED

      An Introduction To Rabbitmq

      Jun 29, 2021

      RabbitMQ is a Message Broker, which means that it can safely hold messages generated by applications and make them available to other applications. The main advantages are reliability, support for clustering and high-availability queues, tracing capa

      1 min read

    • UNLIMITED

      Use EBPF To Keep Tabs On Your CPU

      Oct 18, 2022

      Did you miss part one? Get hold of it on page 60 Mihalis Tsoukalos is a systems engineer and a technical writer. You can reach him at @mactsouk. We’re continuing our dive into the notoriously complex Extended Berkeley Packet Filter (eBPF) feature of

      9 min read

    • UNLIMITED

      In Brief

      Jun 1, 2021

      Mu is a code editor for many forms of Python. We can write standard Python 3 code, create web apps and write code for microcontrollers such as the new Raspberry Pi Pico. Mu is designed for new users and does away with complicated IDEs in favour of a

      1 min read

    • UNLIMITED

      The Retrobates

      Jul 7, 2022

      Once upon a time it would have been The Dragon’s Trap, but Monster Boy And The Cursed Kingdom is a killer update that I absolutely love Expertise: Juggling a gorgeous wife, two beautiful girls and an award-winning magazine, all under one roof! Curren

      1 min read

    • UNLIMITED

      Charts And Diagrams

      Nov 15, 2022

      Charts And Diagrams
      1 min read

    • UNLIMITED

      EBPF To Enhance Kubernetes Monitoring

      Apr 1, 2022

      The introduction of Docker and Kubernetes has brought a dramatic revolution in the IT industry. Unlike the traditional methods of developing and deploying software, Kubernetes or K8s uses scaling and automated deployment. Thanks to the Linux function

      4 min read

    • UNLIMITED

      Creating Flutter apps

      Aug 22, 2023

      Credit: https://flutterawesome.com/calculator-create-with-flutter/ David Bolton has been programming Flutter apps for a couple of years but this is the first time he’s done Flutter development on Linux. The Flutter plugin includes tools for insertin

      9 min read

    • UNLIMITED

      Build The Kernel

      Mar 8, 2022

      Build The Kernel
      1 min read

    • UNLIMITED

      Open Source Processors

      Jun 2, 2020

      Open Source Processors
      8 min read

    • UNLIMITED

      Build A Mac Server

      Sep 19, 2023

      Build A Mac Server
      10 min read

    • UNLIMITED

      Jump to LineageOS

      Feb 7, 2023

      Jump to LineageOS
      5 min read

    • UNLIMITED

      Common Errors

      Aug 27, 2019

      If you receive a ‘Script not found’ error, this probably means that you don’t have the mod scripts installed in your Minecraft directory. Check that you’ve replaced .minecraft with the one from McPiFoMo; this should include mcpipy, which will be full

      1 min read

    • UNLIMITED

      Enhance GIMP With Must-have Plugins

      Apr 4, 2023

      Credit: http://gimp.org Karsten Günther loves to extend his GIMP installations with useful plugins. And playing with the new tools… Many of the most important plugins presented here are quite old, but they are still maintained and sometimes even deve

      9 min read

    Related categories

    Reviews for Jetpack Compose 1.5 Essentials

    0 ratings

    0 ratings0 reviews

    What did you think?

    Tap to rate

    Review must be at least 10 words

      Book preview

      Jetpack Compose 1.5 Essentials - Neil Smyth

      jetpack_compose_1.5_front_cover_large.png

      Jetpack Compose 1.5

      Essentials

      Jetpack Compose 1.5 Essentials

      © 2024 Neil Smyth / Payload Media, Inc. All Rights Reserved.

      This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.

      The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.

      This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.

      Rev: 1.0

      Find more books at https://www.payloadbooks.com.

      Copyright

      "

      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

      1.6 Find more books

      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 Removing 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. An Android Biometric Authentication Tutorial

      56.1 An overview of biometric authentication

      56.2 Creating the biometric authentication project

      56.3 Adding the biometric dependency

      56.4 Configuring device fingerprint authentication

      56.5 Adding the biometric permissions to the manifest file

      56.6 Checking the security settings

      56.7 Designing the user interface

      56.8 Configuring the authentication callbacks

      56.9 Starting the biometric prompt

      56.10 Testing the project

      56.11 Summary

      57. Working with the Google Maps Android API in Android Studio

      57.1 The elements of the Google Maps Android API

      57.2 Creating the Google Maps project

      57.3 Creating a Google Cloud billing account

      57.4 Creating a new Google Cloud project

      57.5 Enabling the Google Maps SDK

      57.6 Generating a Google Maps API key

      57.7 Adding the API key to the Android Studio project

      57.8 Adding the compose map dependency

      57.9 Creating a map

      57.10 Testing the application

      57.11 Understanding geocoding and reverse geocoding

      57.12 Specifying a map location

      57.13 Changing the map type

      57.14 Displaying map controls to the user

      57.15 Handling map gesture interaction

      57.15.1 Map zooming gestures

      57.15.2 Map scrolling/panning gestures

      57.15.3 Map tilt gestures

      57.15.4 Map rotation gestures

      57.16 Creating map markers

      57.17 Controlling the map camera

      57.18 Summary

      58. Creating, Testing, and Uploading an Android App Bundle

      58.1 The Release Preparation Process

      58.2 Android App Bundles

      58.3 Register for a Google Play Developer Console Account

      58.4 Configuring the App in the Console

      58.5 Enabling Google Play App Signing

      58.6 Creating a Keystore File

      58.7 Creating the Android App Bundle

      58.8 Generating Test APK Files

      58.9 Uploading the App Bundle to the Google Play Developer Console

      58.10 Exploring the App Bundle

      58.11 Managing Testers

      58.12 Rolling the App Out for Testing

      58.13 Uploading New App Bundle Revisions

      58.14 Analyzing the App Bundle File

      58.15 Summary

      59. An Overview of Android In-App Billing

      59.1 Preparing a project for In-App purchasing

      59.2 Creating In-App products and subscriptions

      59.3 Billing client initialization

      59.4 Connecting to the Google Play Billing library

      59.5 Querying available products

      59.6 Starting the purchase process

      59.7 Completing the purchase

      59.8 Querying previous purchases

      59.9 Summary

      60. An Android In-App Purchasing Tutorial

      60.1 About the In-App purchasing example project

      60.2 Creating the InAppPurchase project

      60.3 Adding libraries to the project

      60.4 Adding the App to the Google Play Store

      60.5 Creating an In-App product

      60.6 Enabling license testers

      60.7 Creating a purchase helper class

      60.8 Adding the StateFlow streams

      60.9 Initializing the billing client

      60.10 Querying the product

      60.11 Handling purchase updates

      60.12 Launching the purchase flow

      60.13 Consuming the product

      60.14 Restoring a previous purchase

      60.15 Completing the MainActivity

      60.16 Testing the app

      60.17 Troubleshooting

      60.18 Summary

      61. Working with Compose Theming

      61.1 Material Design 2 vs. Material Design 3

      61.2 Material Design 3 theming

      61.3 Building a custom theme

      61.4 Summary

      62. A Material Design 3 Theming Tutorial

      62.1 Creating the ThemeDemo project

      62.2 Designing the user interface

      62.3 Building a new theme

      62.4 Adding the theme to the project

      62.5 Enabling dynamic colors

      62.6 Summary

      63. An Overview of Gradle in Android Studio

      63.1 An overview of Gradle

      63.2 Gradle and Android Studio

      63.2.1 Sensible defaults

      63.2.2 Dependencies

      63.2.3 Build variants

      63.2.4 Manifest entries

      63.2.5 APK signing

      63.2.6 ProGuard support

      63.3 The Property and Settings Gradle build file

      63.4 The top-level Gradle build file

      63.5 Module level Gradle build files

      63.6 Configuring signing settings in the build File

      63.7 Running Gradle tasks from the command line

      63.8 Summary

      Index

      1. Start Here

      This book teaches you how to build Android applications using Jetpack Compose 1.5, Android Studio Hedgehog (2023.1.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 and key user interface design concepts such as modifiers, navigation bars, and user interface navigation. Additional chapters explore building your own reusable custom layout components, securing your apps with Biometric authentication, and integrating Google Maps.

      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. You will also learn to generate extra revenue from your app using in-app billing.

      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.

      1.1 For Kotlin programmers

      This book addresses the needs of existing Kotlin programmers and those new to Kotlin and Jetpack Compose app development. If you are familiar with the Kotlin programming language, you can probably skip the Kotlin-specific chapters.

      1.2 For new Kotlin programmers

      If you are new to Kotlin programming, the entire book is appropriate for you. Just start at the beginning and keep going.

      1.3 Downloading the code samples

      The source code and Android Studio project files for the examples contained in this book are available for download at:

      https://www.payloadbooks.com/product/compose15/

      The steps to load a project from the code samples into Android Studio are as follows:

      1. Click on the Open button option from the Welcome to Android Studio dialog.

      2. In the project selection dialog, navigate to and select the folder containing the project to be imported and click on OK.

      1.4 Feedback

      We want you to be satisfied with your purchase of this book. Therefore, if you find any errors in the book or have any comments, questions, or concerns, please contact us at [email protected].

      1.5 Errata

      While we make every effort to ensure the accuracy of the content of this book, inevitably, a book covering a subject area of this size and complexity may include some errors and oversights. Any known issues with the book will be outlined, together with solutions, at the following URL:

      https://www.payloadbooks.com/compose15_errata

      If you find an error not listed in the errata, email our technical support team at [email protected].

      1.6 Find more books

      Visit our website to view our complete book catalog at https://www.payloadbooks.com.

      2. Setting up an Android Studio Development Environment

      Before any work can begin on developing an Android application, the first step is to configure a computer system to act as the development platform. This involves several steps consisting of installing the Android Studio Integrated Development Environment (IDE), including the Android Software Development Kit (SDK) and the OpenJDK Java development environment.

      This chapter will cover the steps necessary to install the requisite components for Android application development on Windows, macOS, and Linux-based systems.

      2.1 System requirements

      Android application development may be performed on any of the following system types:

      •Windows 8/10/11 64-bit

      •macOS 10.14 or later running on Intel or Apple silicon

      •Chrome OS device with Intel i5 or higher

      •Linux systems with version 2.31 or later of the GNU C Library (glibc)

      •Minimum of 8GB of RAM

      •Approximately 8GB of available disk space

      •1280 x 800 minimum screen resolution

      2.2 Downloading the Android Studio package

      Most of the work involved in developing applications for Android will be performed using the Android Studio environment. The content and examples in this book were created based on Android Studio Hedgehog 2023.1.1 using the Android API 34 SDK (UpsideDownCake), which, at the time of writing, are the latest stable releases.

      Android Studio is, however, subject to frequent updates, so a newer version may have been released since this book was published.

      The latest release of Android Studio may be downloaded from the primary download page, which can be found at the following URL:

      https://developer.android.com/studio/index.html

      If this page provides instructions for downloading a newer version of Android Studio, there may be differences between this book and the software. A web search for Android Studio Hedgehog should provide the option to download the older version if these differences become a problem. Alternatively, visit the following web page to find Android Studio Hedgehog 2023.1.1 in the archives:

      https://developer.android.com/studio/archive

      2.3 Installing Android Studio

      Once downloaded, the exact steps to install Android Studio differ depending on the operating system on which the installation is performed.

      2.3.1 Installation on Windows

      Locate the downloaded Android Studio installation executable file (named android-studio--windows.exe) in a Windows Explorer window and double-click on it to start the installation process, clicking the Yes button in the User Account Control dialog if it appears.

      Once the Android Studio setup wizard appears, work through the various screens to configure the installation to meet your requirements in terms of the file system location into which Android Studio should be installed and whether or not it should be made available to other system users. When prompted to select the components to install, ensure that the Android Studio and Android Virtual Device options are all selected.

      Although there are no strict rules on where Android Studio should be installed on the system, the remainder of this book will assume that the installation was performed into C:\Program Files\Android\Android Studio and that the Android SDK packages have been installed into the user’s AppData\Local\Android\sdk sub-folder. Once the options have been configured, click the Install button to begin the installation process.

      On versions of Windows with a Start menu, the newly installed Android Studio can be launched from the entry added to that menu during the installation. The executable may be pinned to the taskbar for easy access by navigating to the Android Studio\bin directory, right-clicking on the studio64 executable, and selecting the Pin to Taskbar menu option (on Windows 11, this option can be found by selecting Show more options from the menu).

      2.3.2 Installation on macOS

      Android Studio for macOS is downloaded as a disk image (.dmg) file. Once the android-studio--mac.dmg file has been downloaded, locate it in a Finder window and double-click on it to open it, as shown in Figure 2-1:

      Figure 2-1

      To install the package, drag the Android Studio icon and drop it onto the Applications folder. The Android Studio package will then be installed into the Applications folder of the system, a process that will typically take a few seconds to complete.

      To launch Android Studio, locate the executable in the Applications folder using a Finder window and double-click on it.

      For future, easier access to the tool, drag the Android Studio icon from the Finder window and drop it onto the dock.

      2.3.3 Installation on Linux

      Having downloaded the Linux Android Studio package, open a terminal window, change directory to the location where Android Studio is to be installed, and execute the following command:

      tar xvfz //android-studio--linux.tar.gz

      Note that the Android Studio bundle will be installed into a subdirectory named android-studio. Therefore, assuming that the above command was executed in /home/demo, the software packages will be unpacked into /home/demo/android-studio.

      To launch Android Studio, open a terminal window, change directory to the android-studio/bin sub-directory, and execute the following command:

      ./studio.sh

      2.4 The Android Studio setup wizard

      If you have previously installed an earlier version of Android Studio, the first time this new version is launched, a dialog may appear providing the option to import settings from a previous Android Studio version. If you have settings from a previous version and would like to import them into the latest installation, select the appropriate option and location. Alternatively, indicate that you do not need to import any previous settings and click the OK button to proceed.

      If you are installing Android Studio for the first time, the initial dialog that appears once the setup process starts may resemble that shown in Figure 2-2 below:

      Figure 2-2

      If this dialog appears, click the Next button to display the Install Type screen (Figure 2-3). On this screen, select the Standard installation option before clicking Next.

      Figure 2-3

      On the Select UI Theme screen, select either the Darcula or Light theme based on your preferences. After making a choice, click Next, and review the options in the Verify Settings screen before proceeding to the License Agreement screen. Select each license category and enable the Accept checkbox. Finally, click the Finish button to initiate the installation.

      After these initial setup steps have been taken, click the Finish button to display the Welcome to Android Studio screen using your chosen UI theme:

      Figure 2-4

      2.5 Installing additional Android SDK packages

      The steps performed so far have installed the Android Studio IDE and the current set of default Android SDK packages. Before proceeding, it is worth taking some time to verify which packages are installed and to install any missing or updated packages.

      This task can be performed by clicking on the More Actions link within the welcome dialog and selecting the SDK Manager option from the drop-down menu. Once invoked, the Android SDK screen of the Settings dialog will appear as shown in Figure 2-5:

      Figure 2-5

      Google pairs each release of Android Studio with a maximum supported Application Programming Interface (API) level of the Android SDK. In the case of Android Studio Hedgehog, this is Android UpsideDownCake (API Level 34). This information can be confirmed using the following link:

      https://developer.android.com/studio/releases#api-level-support

      Immediately after installing Android Studio for the first time, it is likely that only the latest supported version of the Android SDK has been installed. To install older versions of the Android SDK, select the checkboxes corresponding to the versions and click the Apply button. The rest of this book assumes that the Android UpsideDownCake (API Level 34) SDK is installed.

      Most of the examples in this book will support older versions of Android as far back as Android 8.0 (Oreo). This ensures that the apps run on a wide range of Android devices. Within the list of SDK versions, enable the checkbox next to Android 8.0 (Oreo) and click the Apply button. Click the OK button to install the SDK in the resulting confirmation dialog. Subsequent dialogs will seek the acceptance of licenses and terms before performing the installation. Click Finish once the installation is complete.

      It is also possible that updates will be listed as being available for the latest SDK. To access detailed information about the packages that are ready to be updated, enable the Show Package Details option located in the lower right-hand corner of the screen. This will display information similar to that shown in Figure 2-6:

      Figure 2-6

      The above figure highlights the availability of an update. To install the updates, enable the checkbox to the left of the item name and click the Apply button.

      In addition to the Android SDK packages, several tools are also installed for building Android applications. To view the currently installed packages and check for updates, remain within the SDK settings screen and select the SDK Tools tab as shown in Figure 2-7:

      Figure 2-7

      Within the Android SDK Tools screen, make sure that the following packages are listed as Installed in the Status column:

      •Android SDK Build-tools

      •Android Emulator

      •Android SDK Platform-tools

      •Google Play Services

      •Intel x86 Emulator Accelerator (HAXM installer)*

      •Google USB Driver (Windows only)

      •Layout Inspector image server for API 31-34

      *Note that the Intel x86 Emulator Accelerator (HAXM installer) cannot be installed on Apple silicon-based Macs.

      If any of the above packages are listed as Not Installed or requiring an update, select the checkboxes next to those packages and click the Apply button to initiate the installation process. If the HAXM emulator settings dialog appears, select the recommended memory allocation:

      Figure 2-8

      Once the installation is complete, review the package list and ensure that the selected packages are listed as Installed in the Status column. If any are listed as Not installed, make sure they are selected and click the Apply button again.

      2.6 Installing the Android SDK Command-line Tools

      Android Studio includes tools that allow some tasks to be performed from your operating system command line. To install these tools on your system, open the SDK Manager, select the SDK Tools tab, and locate the Android SDK Command-line Tools (latest) package as shown in Figure 2-9:

      Figure 2-9

      If the command-line tools package is not already installed, enable it and click Apply, followed by OK to complete the installation. When the installation completes, click Finish and close the SDK Manager dialog.

      For the operating system on which you are developing to be able to find these tools, it will be necessary to add them to the system’s PATH environment variable.

      Regardless of your operating system, you will need to configure the PATH environment variable to include the following paths (where represents the file system location into which you installed the Android SDK):

      /sdk/cmdline-tools/latest/bin

      /sdk/platform-tools

      You can identify the location of the SDK on your system by launching the SDK Manager and referring to the Android SDK Location: field located at the top of the settings panel, as highlighted in Figure 2-10:

      Figure 2-10

      Once the location of the SDK has been identified, the steps to add this to the PATH variable are operating system dependent:

      2.6.1 Windows 8.1

      1. On the start screen, move the mouse to the bottom right-hand corner of the screen and select Search from the resulting menu. In the search box, enter Control Panel. When the Control Panel icon appears in the results area, click on it to launch the tool on the desktop.

      2. Within the Control Panel, use the Category menu to change the display to Large Icons. From the list of icons, select the one labeled System.

      3. In the Environment Variables dialog, locate the Path variable in the System variables list, select it, and click the Edit… button. Using the New button in the edit dialog, add two new entries to the path. For example, assuming the Android SDK was installed into C:\Users\demo\AppData\Local\Android\Sdk, the following entries would need to be added:

      C:\Users\demo\AppData\Local\Android\Sdk\cmdline-tools\latest\bin

      C:\Users\demo\AppData\Local\Android\Sdk\platform-tools

      4. Click OK in each dialog box and close the system properties control panel.

      Open a command prompt window by pressing Windows + R on the keyboard and entering cmd into the Run dialog. Within the Command Prompt window, enter:

      echo %Path%

      The returned path variable value should include the paths to the Android SDK platform tools folders. Verify that the platform-tools value is correct by attempting to run the adb tool as follows:

      adb

      The tool should output a list of command-line options when executed.

      Similarly, check the tools path setting by attempting to run the AVD Manager command-line tool (don’t worry if the avdmanager tool reports a problem with Java - this will be addressed later):

      avdmanager

      If a message similar to the following message appears for one or both of the commands, it is most likely that an incorrect path was appended to the Path environment variable:

      'adb' is not recognized as an internal or external command,

      operable program or batch file.

      2.6.2 Windows 10

      Right-click on the Start menu, select Settings from the resulting menu and enter Edit the system environment variables into the Find a setting text field. In the System Properties dialog, click the Environment Variables... button. Follow the steps outlined for Windows 8.1 starting from step 3.

      2.6.3 Windows 11

      Right-click on the Start icon located in the taskbar and select Settings from the resulting menu. When the Settings dialog appears, scroll down the list of categories and select the About option. In the About screen, select Advanced system settings from the Related links section. When the System Properties window appears, click the Environment Variables... button. Follow the steps outlined for Windows 8.1 starting from step 3.

      2.6.4 Linux

      This configuration can be achieved on Linux by adding a command to the .bashrc file in your home directory (specifics may differ depending on the particular Linux distribution in use). Assuming that the Android SDK bundle package was installed into /home/demo/Android/sdk, the export line in the .bashrc file would read as follows:

      export PATH=/home/demo/Android/sdk/platform-tools:/home/demo/Android/sdk/cmdline-tools/latest/bin:/home/demo/android-studio/bin:$PATH

      Note also that the above command adds the android-studio/bin directory to the PATH variable. This will enable the studio.sh script to be executed regardless of the current directory within a terminal window.

      2.6.5 macOS

      Several techniques may be employed to modify the $PATH environment variable on macOS. Arguably the cleanest method is to add a new file in the /etc/paths.d directory containing the paths to be added to $PATH. Assuming an Android SDK installation location of /Users/demo/Library/Android/sdk, the path may be configured by creating a new file named android-sdk in the /etc/paths.d directory containing the following lines:

      /Users/demo/Library/Android/sdk/cmdline-tools/latest/bin

      /Users/demo/Library/Android/sdk/platform-tools

      Note that since this is a system directory, it will be necessary to use the sudo command when creating the file. For example:

      sudo vi /etc/paths.d/android-sdk

      2.7 Android Studio memory management

      Android Studio is a large and complex software application with many background processes. Although Android Studio has been criticized in the past for providing less than optimal performance, Google has made significant performance improvements in recent releases and continues to do so with each new version. These improvements include allowing the user to configure the amount of memory used by both the Android Studio IDE and the background processes used to build and run apps. This allows the software to take advantage of systems with larger amounts of RAM.

      If you are running Android Studio on a system with sufficient unused RAM to increase these values (this feature is only available on 64-bit systems with 5GB or more of RAM) and find that Android Studio performance appears to be degraded, it may be worth experimenting with these memory settings. Android Studio may also notify you that performance can be increased via a dialog similar to the one shown below:

      Figure 2-11

      To view and modify the current memory configuration, select the File -> Settings... main menu option (Android Studio -> Settings... on macOS) and, in the resulting dialog, select Appearance & Behavior followed by the Memory Settings option listed under System Settings in the left-hand navigation panel, as illustrated in Figure 2-12 below:

      Figure 2-12

      When changing the memory allocation, be sure not to allocate more memory than necessary or than your system can spare without slowing down other processes.

      The IDE heap size setting adjusts the memory allocated to Android Studio and applies regardless of the currently loaded project. On the other hand, when a project is built and run from within Android Studio, several background processes (referred to as daemons) perform the task of compiling and running the app. When compiling and running large and complex projects, build time could be improved by adjusting the

      daemon heap settings. Unlike the IDE heap settings, these daemon settings apply only to the current project and can only be accessed when a project is open in Android Studio. To display the SDK Manager from within an open project, select the Tools -> SDK Manager... menu option from the main menu.

      2.8 Updating Android Studio and the SDK

      From time to time, new versions of Android Studio and the Android SDK are released. New versions of the SDK are installed using the Android SDK Manager. Android Studio will typically notify you when an update is ready to be installed.

      To manually check for Android Studio updates, use the Help -> Check for Updates... menu option from the Android Studio main window (Android Studio -> Check for Updates... on macOS).

      2.9 Summary

      Before beginning the development of Android-based applications, the first step is to set up a suitable development environment. This consists of the Android SDKs and Android Studio IDE (which also includes the OpenJDK development environment). This chapter covers the steps necessary to install these packages on Windows, macOS, and Linux.

      3. A Compose Project Overview

      Now that we have installed Android Studio, the next step is to create an Android app using Jetpack Compose. Although this project will use several Compose features, it is an intentionally simple example intended to provide an early demonstration of Compose in action and an initial success on which to build as you work through the remainder of the book. The project will also verify that your Android Studio environment is correctly installed and configured.

      This chapter will create a new project using the Android Studio Compose project template and explore both the basic structure of a Compose-based Android Studio project and some of the key areas of Android Studio. The next chapter will use this project to create a simple Android app.

      Both chapters will briefly explain key features of Compose as they are introduced within the project. If anything is unclear when you have completed the project, rest assured that all the areas covered in the tutorial will be explored in greater detail in later chapters of the book.

      3.1 About the project

      The completed project will consist of two text components and a slider. When the slider is moved, the current value will be displayed on one of the text components, while the font size of the second text instance will adjust to match the current slider position. Once completed, the user interface for the app will appear as shown in Figure 3-1:

      Figure 3-1

      3.2 Creating the project

      The

      Enjoying the preview?
      Page 1 of 1