Head First Android Development, 3rd Edition

Table of Contents (the real thing)

• How to use this book: Intro

  Your brain on Android. Here you are trying to learn something, while here your brain is, doing you a favor by making sure the learning doesn’t stick. Your brain’s thinking, “Better leave room for more important things, like which wild animals to avoid and whether naked snowboarding is a bad idea.” So how do you trick your brain into thinking that your life depends on knowing how to develop Android apps?

  1. “Who is this book for?”

  2. “We know what you’re thinking”

  3. “We know what your brain is thinking”

  4. “Metacognition: thinking about thinking”

  5. “Here’s what WE did”

  6. “Read me”

  7. “The truly awesome technical review team”

  8. “Acknowledgments”

• Chapter 1

  Android is the world’s most popular mobile operating system. And there are billions of Android users worldwide, all waiting to download your next great idea. In this chapter, you’ll find out how to start turning your ideas into reality by building a basic Android app, and updating it. You’ll learn how to run it on physical and virtual devices. Along the way, you’ll meet two of the core components of all Android apps: activities and layouts.

  1. “Welcome to Androidville”

  2. “Activities and layouts form the backbone of your app”

  3. “Here’s what we’re going to do”

  4. “Android Studio: your development environment”

  5. “Install Android Studio”

  6. “Let’s build a basic app”

  7. “How to build the app”

  8. “Android Versions Up Close ”

  9. “You’ve created your first Android project”

  10. “Dissecting your new project”

  11. “Introducing the key files in your project”

  12. “Edit code with the Android Studio editors”

  13. “The story so far”

  14. “How to run the app on a physical device”

  15. “How to run the app on a virtual device”

  16. “Create an Android Virtual Device (AVD)”

  17. “Compile, package, deploy, run”

  18. “What just happened?”

  19. “Let’s refine the app”

  20. “What’s in the layout?”

  21. “activity_main.xml has two elements”

  22. “Update the text displayed in the layout”

  23. “What the code does”

  24. “Your Android Toolbox”

• Chapter 2

  Most apps need to respond to the user in some way. And in this chapter, you’ll see how you can make your apps more interactive. You’ll discover how to add an OnClickListener to your activity code so that your app can listen to what the user’s doing, and make an appropriate response. You’ll find out more about how to design layouts, and you’ll learn how each UI component you add to your layout is derived from a common View ancestor. Along the way, you’ll discover why String resources are so important for flexible, well-designed apps.

  1. “Let’s build a Beer Adviser app”

  2. “Create the project”

  3. “A closer look at the design editor”

  4. “Add a button using the design editor”

  5. “A closer look at the layout code”

  6. “Let’s update the layout XML”

  7. “The XML changes are reflected in the design editor”

  8. “There are warnings in the layout…”

  9. “Put text in a String resource file”

  10. “Extract the String resource”

  11. “Add and use a new String resource”

  12. “String Resources Up Close ”

  13. “Add values to the spinner”

  14. “Add the string-array to strings.xml”

  15. “We need to make the app interactive”

  16. “What the MainActivity code looks like”

  17. “A button can listen for on-click events…”

  18. “Get a reference to the button…”

  19. “Pass a lambda to the setOnClickListener method”

  20. “How to edit a text view’s text”

  21. “The updated code for MainActivity.kt”

  22. “What happens when you run the code”

  23. “Add the getBeers() method”

  24. “Your Android Toolbox”

• Chapter 3

  We’ve only scratched the surface of using layouts. So far, you’ve seen how to arrange views in a simple linear layout, but there’s so much more that layouts can do. In this chapter we’ll go a little deeper and show you how layouts really work. You’ll learn how to fine-tune your linear layouts. You’ll discover how to use frame layouts and scroll views. And by the end of the chapter, you’ll learn that even though they might look a little different, all layouts—and the views you add to them—have more in common than you might think.

  1. “It all starts with a layout”

  2. “Android has different types of layout”

  3. “How to define a linear layout”

  4. “Orientation can be vertical or horizontal”

  5. “Anatomy of AndroidManifest.xml ”

  6. “Use padding to add space to the layout’s edges”

  7. “The layout code so far”

  8. “An edit text lets you enter text”

  9. “Add views to the layout XML”

  10. “Make a view streeeeetch by adding weight”

  11. “How to add weight to one view”

  12. “How to add weight to multiple views”

  13. “Values you can use with the android:gravity attribute”

  14. “The story so far”

  15. “More values you can use with the android:layout-gravity attribute”

  16. “Use margins to add space between views”

  17. “Your activity code tells Android which layout it uses”

  18. “Layout inflation: an example”

  19. “A frame layout stacks its views”

  20. “Add an image to your project”

  21. “Drawable Resources Up Close ”

  22. “A frame layout stacks views in the order they appear in the layout XML”

  23. “All layouts are a type of ViewGroup…”

  24. “A scroll view inserts a vertical scrollbar”

  25. “Your Android Toolbox”

• Chapter 4

  You don’t build a house without a blueprint. And some layouts use blueprints to make sure they look exactly the way you want. In this chapter, we’ll introduce you to Android’s constraint layout: a flexible way of designing more complex UIs. You’ll discover how constraints and bias let you position and size your views, irrespective of screen size and orientation. You’ll find out how to keep views in their place with guidelines and barriers. Finally, you’ll learn how to pack or spread views with chains and flows.

  1. “Nested layouts revisited”

  2. “Introducing the constraint layout”

  3. “Constraint layouts are part of Android Jetpack”

  4. “Use Gradle to include Jetpack libraries”

  5. “Let’s add a constraint layout to activity_main.xml”

  6. “Add a button to the blueprint”

  7. “Position views using constraints”

  8. “Add a vertical constraint too”

  9. “Use opposing constraints to center views”

  10. “Remove constraints with the constraint widget”

  11. “Changes to the blueprint appear in the XML”

  12. “Views can have bias”

  13. “You can change a view’s size”

  14. “Most layouts need multiple views”

  15. “You can connect views to other views”

  16. “Align views using guidelines”

  17. “Guidelines have a fixed position”

  18. “Create a movable barrier”

  19. “Add a horizontal barrier”

  20. “Constrain a button under the barrier”

  21. “Use a chain to control a linear group of views”

  22. “Create the horizontal chain”

  23. “There are different styles of chain”

  24. “A flow is like a multi-line chain”

  25. “How to add a flow”

  26. “You can control the flow’s appearance”

  27. “Your Android Toolbox”

• Chapter 5

  Activities form the foundation of every Android app. So far you’ve seen how to create an activity, and use it to interact with the user. But if you don’t know about the activity lifecycle, some of its behavior might take you by surprise. In this chapter, you’ll learn what happens when an activity is created and destroyed, and how this can lead to unexpected consequences. You’ll find out how to control its behavior when it’s made visible, or hidden. You’ll even discover ways of saving and restoring your activity’s state, just when you need it.

  1. “How do activities really work?”

  2. “Create a new project”

  3. “The full code for activity_main.xml”

  4. “The activity code controls the stopwatch”

  5. “The full code for MainActivity.kt”

  6. “What happens when you run the app”

  7. “Rotating the screen changes the device configuration”

  8. “An activity’s states”

  9. “The activity lifecycle: from create to destroy”

  10. “Your activity inherits the lifecycle methods”

  11. “Save the current state in a Bundle”

  12. “Save the state using onSaveInstanceState()”

  13. “The updated MainActivity.kt code”

  14. “What happens when you run the app”

  15. “There’s more to an activity’s life than create and destroy”

  16. “The visible lifecycle”

  17. “We need to implement two more lifecycle methods”

  18. “Restart the stopwatch when the app becomes visible”

  19. “What happens when you run the app”

  20. “What if an activity is only partially visible?”

  21. “The foreground lifecycle”

  22. “Pause the stopwatch if the activity’s paused”

  23. “The complete MainActivity.kt code”

  24. “What happens when you run the app”

  25. “Your handy guide to the activity lifecycle methods”

  26. “Your Android Toolbox”

• Chapter 6

  Most apps require more than one screen. So far, we’ve just looked at how to create single-screen apps, which is fine for simple applications. But what if you have more complex requirements? In this chapter, you’ll learn how to use fragments and the Navigation component to build multi-screen apps. You’ll learn how fragments are like subactivities with their own methods. You’ll find out how to design effective navigation graphs. Finally, you’ll meet the navigation host and navigation controller, and learn how they help you navigate from place to place.

  1. “Most apps need more than one screen”

  2. “Each screen is a fragment”

  3. “Navigate between screens using the Navigation component”

  4. “Create a new project”

  5. “Add WelcomeFragment to the project”

  6. “What fragment code looks like”

  7. “The fragment’s onCreateView() method”

  8. “Fragment layout code looks like activity layout code”

  9. “You display a fragment in a FragmentContainerView”

  10. “Update the activity_main.xml code”

  11. “What the code does”

  12. “Create MessageFragment”

  13. “Use the Navigation component to navigate between fragments”

  14. “Use Gradle to add the Navigation component to your project”

  15. “Create a navigation graph”

  16. “Add fragments to the navigation graph”

  17. “Connect fragments using an action”

  18. “Navigation graphs are XML resources”

  19. “Add a navigation host to the layout using a FragmentContainerView”

  20. “Add a NavHostFragment to activity_main.xml”

  21. “Add an OnClickListener to the button”

  22. “Get a navigation controller”

  23. “The full code for WelcomeFragment.kt”

  24. “What happens when the app runs”

  25. “Your Android Toolbox”

• Chapter 7

  Sometimes fragments need extra information to work properly. If a fragment shows details of a contact, for example, it needs to know which contact to display. But what if this information comes from another fragment? In this chapter, you’ll build on your navigation know-how by learning how to pass data between fragments. You’ll find out how to add arguments to navigation destinations so they can receive the information they need. You’ll meet the Safe Args plug-in, and learn how to use it to write type-safe code. Finally, you’ll discover how to manipulate the back stack, and take control of back button behavior.

  1. “The Secret Message app navigates between fragments”

  2. “MessageFragment needs to pass the message to a new fragment”

  3. “Create EncryptFragment…”

  4. “Add EncryptFragment to the navigation graph”

  5. “MessageFragment needs to navigate to EncryptFragment”

  6. “Add Safe Args to the build.gradle files”

  7. “EncryptFragment needs to accept a String argument”

  8. “MessageFragment needs to pass a message to EncryptFragment”

  9. “Safe Args generates Directions classes”

  10. “Update the MessageFragment.kt code”

  11. “EncryptFragment needs to get the argument’s value”

  12. “The full code for EncryptFragment.kt”

  13. “What happens when the app runs”

  14. “What if the user wants to go back?”

  15. “Welcome to the back stack”

  16. “Use the navigation graph to pop fragments off the back stack”

  17. “Your Android Toolbox”

• Chapter 8

  Most apps need to be able to navigate between destinations. And with the Android the Navigation component, building this UI became much simpler. Here, you’ll learn how to use some of Android’s navigation UI components so that your users can navigate your app more easily. You’ll see how to use themes, and replace your app’s default app bar with a toolbar. You’ll learn how to add menu items you can use for navigation. You’ll discover how to implement bottom bar navigation. Finally, you’ll create a swish navigation drawer: a panel that slides out from the side of your activity.

  1. “Different apps, different structures”

  2. “Android includes navigation UI components”

  3. “How the CatChat app will work”

  4. “Apply a theme in AndroidManifest.xml”

  5. “Define styles in style resource files”

  6. “Replace the default app bar with a toolbar”

  7. “Create InboxFragment”

  8. “Specify items in the toolbar with a menu resource file”

  9. “onCreateOptionsMenu() adds menu items to the toolbar”

  10. “Respond to menu item clicks with onOptionsItemSelected()”

  11. “Configure the toolbar using an AppBarConfiguration”

  12. “What happens when the app runs”

  13. “Most types of UI navigation work with the Navigation component”

  14. “Create SentItemsFragment”

  15. “The bottom navigation bar needs a new menu resource file”

  16. “Link the bottom navigation bar to the navigation controller”

  17. “A navigation drawer lets you display many navigation items”

  18. “Add the support section…”

  19. “Highlight the selected item with groups”

  20. “Create the navigation drawer’s header”

  21. “How to create a navigation drawer”

  22. “Configure the toolbar’s drawer icon…”

  23. “Your Android Toolbox”

• Chapter 9

  Most apps need a slick UI that responds to the user. You’ve so far learned how to use views such as text views, buttons, and spinners, and applied Material themes to make sweeping changes to your app’s look and feel. But there’s so much more you can do. Here, you’ll learn how to make your UI more responsive with the coordinator layout. You’ll create toolbars that can collapse or scroll on a whim. You’ll discover exciting new views such as checkboxes, radio buttons, chips, and floating action buttons. Finally, you’ll find out how to display friendly pop-up messages using toasts and snackbars.

  1. “Material is used throughout Androidville”

  2. “The Bits and Pizzas app”

  3. “Create OrderFragment”

  4. “Replace the default app bar with a toolbar”

  5. “Fragments don’t have a setSupportActionBar() method”

  6. “The coordinator layout coordinates animations between views”

  7. “The app bar layout enables toolbar animation”

  8. “Tell the toolbar how to respond to scroll events”

  9. “How to create a plain collapsing toolbar”

  10. “How to add an image to a collapsing toolbar”

  11. “We need to build OrderFragment’s main content”

  12. “Choose a pizza type using a radio button”

  13. “A chip is a type of flexible compound button”

  14. “Add multiple chips to a chip group”

  15. “A FAB is a floating action button”

  16. “You can anchor a FAB to a collapsing toolbar”

  17. “We need to build OrderFragment’s layout”

  18. “Add an OnClickListener to the FAB”

  19. “A toast is a simple pop-up message”

  20. “Display the pizza order in a snackbar”

  21. “The snackbar code for the pizza order”

  22. “The full code for OrderFragment.kt”

  23. “Your Android Toolbox”

• Chapter 10

  It’s time to wave farewell to findViewById(). As you’ve probably noticed by now, the more views you have and the more interactive your apps become, the more calls you need to make to findViewById(). And if you’re getting tired of typing the code for this method every time you want to work with a view, you’re not alone. In this chapter, you’ll discover how to make findViewById() a thing of the past by implementing view binding. You’ll find out how to apply this technique to both activity and fragment code, and you’ll learn why this approach is a safer, more efficient way of accessing your layout’s views.

  1. “Behind the scenes of findViewById()”

  2. “There’s a downside to findViewById()”

  3. “View binding to the rescue”

  4. “Here’s how we’ll use view binding”

  5. “The Stopwatch app revisited”

  6. “Enable view binding in the app build.gradle file”

  7. “How to add view binding to an activity”

  8. “Use the binding property to interact with views”

  9. “The full code for MainActivity.kt”

  10. “What the code does”

  11. “Fragments can use view binding too (but the code’s a little different)”

  12. “Enable view binding for Bits and Pizzas”

  13. “Fragment view binding code is a little different”

  14. “Fragments can access views from onCreateView() to onDestroyView()”

  15. “Fragment Lifecycle Methods Up Close ”

  16. “What fragment view binding code looks like”

  17. “_binding refers to the binding object…”

  18. “The full code for OrderFragment.kt”

  19. “Your Android Toolbox”

• Chapter 11

  As apps grow more complex, fragments have more to juggle. And if you’re not careful, this can lead to bloated code that tries to do everything. Business logic, navigation, controlling the UI, dealing with configuration changes…you name it, it’s in there. In this chapter, you’ll learn how to deal with this kind of situation using view models. You’ll discover how they simplify your activity and fragment code. You’ll find out how they survive configuration changes, keeping your app’s state safe and sound. Finally, we’ll show you how to build a view model factory, and when this might be needed.

  1. “Configuration changes revisited”

  2. “Introducing the view model”

  3. “What the guessing game will do”

  4. “How the app will be structured”

  5. “Update the project build.gradle file…”

  6. “The Guessing Game app has two fragments”

  7. “How navigation should work”

  8. “Update the navigation graph”

  9. “What happens when the app runs”

  10. “The game loses state when the screen rotates”

  11. “A view model holds business logic”

  12. “Add a view model dependency to the app build.gradle file…”

  13. “Create a GameViewModel object”

  14. “What happens when the app runs”

  15. “ View Models Up Close”

  16. “ResultViewModel needs to hold the result”

  17. “A view model factory creates view models”

  18. “Create the ResultViewModelFactory class”

  19. “Use the factory to create the view model”

  20. “What happens when the app runs”

  21. “Your Android Toolbox”

• Chapter 12

  Your code often needs to react to property value changes. If a view model property changes value, for example, the fragment might need to respond by updating its views or navigating elsewhere. But how does a fragment get to hear when a property’s been updated? Here, we’ll introduce you to live data: a way of telling interested parties when something’s changed. You’ll learn all about MutableLiveData, and how to make your fragment observe properties of this type. You’ll discover how the LiveData type helps maintain your app’s integrity.

  1. “The Guessing Game app revisited”

  2. “The fragments decide when to update views”

  3. “Here’s what we’re going to do”

  4. “GameViewModel and GameFragment need to use live data”

  5. “Live data objects use a value property”

  6. “The fragment observes the view model properties and reacts to changes.”

  7. “The full code for GameFragment.kt”

  8. “What happens when the app runs”

  9. “Fragments can update GameViewModel’s properties”

  10. “What happens when the app runs”

  11. “GameFragment still includes game logic”

  12. “The full code for GameViewModel.kt”

  13. “Make GameFragment observe the new property”

  14. “What happens when the app runs”

  15. “Your Android Toolbox”

• Chapter 13

  Layouts can do more than control your app’s appearance. All of the layouts you’ve written so far have been told how they should behave by activity or fragment code. But just imagine if the layouts could think for themselves, and make their own decisions. In this chapter, we’ll introduce you to data binding: a way of boosting your layout’s IQ. You’ll find out how to make views get values directly from the view model. You’ll use listener binding to make buttons call their methods. You’ll even discover how one simple line of code lets views respond to live data updates.

  1. “Back to the Guessing Game app”

  2. “The fragments update the views in their layouts”

  3. “Enable data binding in the app build.gradle file”

  4. “ResultFragment updates the text in its layout”

  5. “1. Add <layout> and <data> elements”

  6. “2. Set the layout’s data binding variable”

  7. “3. Use the layout’s data binding variable to access the view model”

  8. “What happens when the app runs”

  9. “ <layout> Up Close”

  10. “GameFragment can use data binding too”

  11. “Add <layout> and <data> elements to fragment_game.xml”

  12. “Use the data binding variable to set the layout’s text”

  13. “String resources revisited”

  14. “The layout can pass parameters to String resources”

  15. “We need to set the gameViewModel variable”

  16. “What happens when the app runs”

  17. “You can use data binding to call methods”

  18. “Add finishGame() to GameViewModel.kt”

  19. “Use data binding to make a button call a method when clicked”

  20. “What happens when the app runs”

  21. “Fireside Chats”

  22. “We can switch off view binding”

  23. “Your Android Toolbox”

• Chapter 14

  Most apps need data that persists. But if you don’t take steps to store this data somewhere, it will be lost forever as soon as the app is closed down. You usually keep data safe in Androidville by storing it in a database, so in this chapter, we’ll introduce you to the Room persistence library. You’ll learn how to build databases, create tables, and define data access methods using annotated classes and interfaces. You’ll find out how to use coroutines to run database code in the background. And along the way, you’ll discover how to transform your live data as soon as it changes with a little help from Transformations.map().

  1. “Most apps need to store data”

  2. “Room is a database library that sits on top of SQLite”

  3. “Create TasksFragment”

  4. “How Room databases are created”

  5. “We’ll store tasks data in a table”

  6. “Specify a table name with @Entity”

  7. “Use an interface to specify data operations”

  8. “Use @Insert to insert a record”

  9. “Use @Delete to delete a record”

  10. “Create a TaskDatabase abstract class”

  11. “Add properties for any DAO interfaces”

  12. “MVVM revisited”

  13. “Database operations can run in slooooow-moooo”

  14. “1. Mark TaskDao’s methods with suspend”

  15. “2. Launch the insert() method in the background”

  16. “TasksViewModel needs a view model factory”

  17. “We’ll use data binding to insert a record”

  18. “What happens when the code runs”

  19. “TasksFragment needs to display records”

  20. “Use getAll() to get all tasks from the database”

  21. “A LiveData<List<Task>> is a more complex type”

  22. “Let’s update the TasksViewModel code”

  23. “We’ll bind the tasksString property to the layout’s text view”

  24. “What happens when the code runs”

  25. “Your Android Toolbox”

• Chapter 15

  Lists of data are a key part of most apps. And in this chapter, we’ll show you how to create one using a recycler view: a super-flexible way of building a scrollable list. You’ll learn how to create flexible layouts for your list, including text views, checkboxes, and more. You’ll find out how to create adapters that squish your data into the recycler view in whatever way you choose. You’ll discover how to use card views to give your data a 3D material look. Finally, we’ll show you how layout managers can completely change the look of your list with just one or two lines of code.

  1. “What the Tasks app currently looks like”

  2. “We can turn the list into a recycler view”

  3. “Tell the recycler view how to display each item…”

  4. “The adapter adds data to the recycler view”

  5. “Define the adapter’s view holder”

  6. “Override the onCreateViewHolder() method”

  7. “Add data to the layout’s view”

  8. “We need to display the recycler view”

  9. “We’ve added a recycler view to TasksFragment’s layout”

  10. “TasksFragment needs to update TaskItemAdapter’s data property”

  11. “What happens when the code runs”

  12. “Recycler views are very flexible”

  13. “How to create a card view”

  14. “The full code for task_item.xml”

  15. “The adapter’s view holder needs to work with the new layout code”

  16. “The full code for TaskItemAdapter.kt”

  17. “The layout manager gallery”

  18. “Update fragment_tasks.xml to arrange items in a grid”

  19. “What happens when the code runs”

  20. “Your Android Toolbox”

• Chapter 16

  Your app needs to run as smoothly and efficiently as possible. But if you’re not careful, large or complex data sets can cause your recycler view to glitch. In this chapter, we’ll introduce you to DiffUtil: a utility class that adds extra smarts to your recycler view. You’ll find out how to use it to make efficient updates to your recycler view. You’ll discover how ListAdapters make using DiffUtil a breeze. And along the way, you’ll learn how to get rid of findViewById() for good by implementing data binding in your recycler view code.

  1. “The Tasks app revisited”

  2. “How the recycler view gets its data”

  3. “The data property’s setter calls notifyDataSetChanged()”

  4. “Tell the recycler view what needs to change”

  5. “Here’s what we’re going to do”

  6. “We need to implement DiffUtil.ItemCallback”

  7. “A ListAdapter accepts a DiffUtil.ItemCallback argument”

  8. “The updated code for TaskItemAdapter.kt”

  9. “Populate the ListAdapter’s list…”

  10. “The updated code for TasksFragment.kt”

  11. “What happens when the code runs”

  12. “Recycler views can use data binding”

  13. “Add a data binding variable to task_item.xml”

  14. “The layout gets inflated in the adapter’s view holder code”

  15. “Use the binding class to inflate the layout”

  16. “The full code for TaskItemAdapter.kt”

  17. “The full code for task_item.xml”

  18. “What happens when the code runs”

  19. “Your Android Toolbox”

• Chapter 17

  Some apps rely on the user selecting an item from a list. And in this chapter, you’ll learn how to make recycler views a core part of your app design by making their items clickable. You’ll discover how to implement recycler view navigation by making the app navigate to a new screen each time the user clicks on a record. You’ll find out how to show the user extra information about their chosen record, and update it in the database.

  1. “Recycler views can be used for navigation”

  2. “Make each item clickable”

  3. “Where should we create the toast?”

  4. “We’ll pass a lambda to TaskItemAdapter”

  5. “What happens when the code runs”

  6. “We want to use the recycler view to navigate to a new fragment”

  7. “Create EditTaskFragment…”

  8. “Update the navigation graph”

  9. “Make TasksFragment navigate to EditTaskFragment”

  10. “Make EditTaskFragment display the task ID”

  11. “What happens when the code runs”

  12. “We want to use EditTaskFragment to update task records”

  13. “Use TaskDao to interact with database records”

  14. “Create EditTaskViewModel”

  15. “EditTaskViewModel will tell EditTaskFragment when to navigate”

  16. “EditTaskViewModel needs a view model factory”

  17. “fragment_edit_task.xml needs to display the task”

  18. “What happens when the code runs”

  19. “Your Android Toolbox”

• Chapter 18

  All the UIs you’ve built so far have used views and layout files. But with Jetpack Compose, that’s not the only option. In this chapter, we’re going to take a road trip to Composeville, and find out how to build UIs using Compose components called composables instead of views. You’ll learn how to use built-in composables such as Text, Image, TextField, and Button. You’ll discover how to arrange them in Rows and Columns, and style them using themes. You’ll write and preview your own composable functions. You’ll even find out how to manage a composable’s state using MutableState objects.

  1. “UI components don’t have to be Views”

  2. “Create a new Compose project”

  3. “Compose projects have no layout files”

  4. “What Compose activity code looks like”

  5. “Use a Text composable to display text”

  6. “Use composables in composable functions”

  7. “Preview composables with the Design or Split option”

  8. “Let’s make the app convert temperatures”

  9. “Add a MainActivityContent composable function”

  10. “Add an Image to MainActivity.kt”

  11. “Let’s display the temperature text”

  12. “Use a Button composable to add a button”

  13. “We need to pass a lambda to ConvertButton”

  14. “ Composition Up Close”

  15. “We need to change the value of TemperatureText’s argument”

  16. “What happens when the app runs”

  17. “Add a TextField to a composable function”

  18. “What happens when the app runs”

  19. “Add padding to the Column composable”

  20. “You can center composables in Columns or Rows”

  21. “Applying themes: revisited”

  22. “Android Studio includes extra theme code”

  23. “The full code for MainActivity.kt”

  24. “Your Android Toolbox”

• Chapter 19

  You get the best results when things work together. So far, you’ve learned how to build a UI using views or composables. But what if you want to use both? In this chapter, you’ll find out how to get the best of both worlds by adding composables to a View-based UI. You’ll discover techniques for making composables work with view models. You’ll even find out how to make them respond to LiveData updates. By the end of the chapter, you’ll have all the tools you need to use composables with views, or even migrate to a pure Compose UI.

  1. “You can add composables to View-based UIs”

  2. “The Guessing Game app structure”

  3. “We’ll replace ResultFragment’s views with composables”

  4. “A ComposeView lets you add composables to a layout”

  5. “Add composables using Kotlin code”

  6. “Add a composable function for the fragment’s content”

  7. “Reproduce the Start New Game button”

  8. “Reproduce ResultFragment’s TextView”

  9. “onCreateView() returns the UI’s root view”

  10. “The full code for ResultFragment.kt”

  11. “What happens when the app runs”

  12. “Next we’ll make GameFragment use composables too”

  13. “We’ll add a ComposeView to fragment_game.xml”

  14. “Add a composable function for GameFragment’s content”

  15. “Reproduce the Finish Game button”

  16. “Reproduce the EditText with a TextField”

  17. “Reproduce the Guess button”

  18. “We’ll display the incorrect guesses in a Text composable”

  19. “Create an IncorrectGuessesText composable function”

  20. “Your Android Toolbox”

• Appendix A

  Even after all that, there’s still a little more. There are just a few more things we think you need to know. We wouldn’t feel right about ignoring them, and we really wanted to give you a book you’d be able to lift without extensive training at the local gym. Before you put down the book, read through these tidbits.

  1. “1. Sharing data with other apps”

  2. “2. WorkManager”

  3. “3. Dialogs and notifications”

  4. “4. Automated testing”

  5. “5. Supporting different screen sizes”

  6. “6. More Compose features”

  7. “7. Retrofit”

  8. “8. Android Game Development Kit”

  9. “9. CameraX”

  10. “10. Publishing your app”