Android Jetpack Compose - Build Android Native UIs Fast

Android Jetpack Compose - Build Android Native UIs Fast

by Paulo Dichone
Released July 2022
Publisher(s): Packt Publishing
ISBN: 9781803237718

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

Android Jetpack Compose is a new way of building modern Android apps in Android app development. The software development industry is moving away from the imperative approach of building apps—where developers were required to write a lot of boilerplate code, navigate through inconsistent APIs, and hard to maintain code to build simple mobile apps. With Jetpack Compose, building Native UI for the Android platform is more effortless, concise, consistent, and has less code.

In this course, you will start with learning about Jetpack Compose and its advantages over the imperative way of building Android apps. You will look at Kotlin programming basics, intermediate and advanced concepts. You will look at core Jetpack Compose concepts: composable functions, compose layout widgets, and modifiers, and understand how Jetpack Compose handles state—recomposition and state hoisting. You will understand how MutableState and Flow work with composable functions; master how to build various Jetpack Compose apps that range from simple to complex (tip calculator, movie app, note app, trivia app, weather forecast app, and so much more); and build a lot of apps while learning Jetpack Compose.

By the end of the course, you will have learned everything you need to know about Kotlin and Jetpack Compose to build complex Native UIs and Android apps with Jetpack Compose.

What You Will Learn

  • Learn clean architecture and MVVM patterns with Android Jetpack Compose
  • Master Jetpack Compose and build modern Android apps
  • Build different Android apps with Jetpack Compose and Kotlin
  • Master modern Android development best practices with Jetpack tools and Compose
  • Leverage Hilt and Dagger and add dependency injection to Jetpack Compose
  • Integrate the Android ROOM database into a Compose application

Audience

This course is ideal for beginner Android developers who are curious about building modern Android apps using Jetpack Compose and Kotlin.

Android developers who want to learn Kotlin and build Android apps with Jetpack Compose, and anyone who wants to learn Java and Android development will also benefit from this course.

Basic programming experience, in general, is helpful but not required. The course covers everything you will need to build Android apps with Kotlin and Jetpack Compose.

Kotlin fundamentals are included in the course so no need for prior knowledge of the same.

About The Author

Paulo Dichone: Paulo Dichone is a highly skilled developer and teacher with a strong background in Computer Science. With his expertise in Android App Development for mobile and web platforms, Paulo founded Magadistudio, a successful mobile app development company.

Passionate about teaching, Paulo is dedicated to helping learners master Android app development. His goal is to empower students with the knowledge and skills needed to create impressive Android applications and experience the freedom of being an Android developer.

With his deep understanding of the subject matter and a commitment to student success, Paulo Dichone is a trusted instructor who can guide learners on their journey to becoming proficient Android developers.

Table of contents

  1. Chapter 1 : Introduction to the Course
    1. Introduction
    2. Course Learning Path
  2. Chapter 2 : Windows Machine Setup for Development
    1. Installing Android Studio and Setup
    2. Creating a Kotlin Module and Running It
    3. Kotlin Playground - Online Code Editor
  3. Chapter 3 : Mac Machine Setup for Development
    1. Install and Set Up Android Studio
    2. Create a Kotlin Module in an Android Project
    3. Kotlin Playground - Online Code Editor
  4. Chapter 4 : Build Your First Jetpack Compose App
    1. App Demo
    2. Setting Up BizCard App - Android Compose Surface Layout and Preview
    3. Creating a Card and Changing Its Properties with Modifier
    4. Adding the Profile Image
    5. Adding a Column and a Divider
    6. (Challenge) - Change Divider's Parameters
    7. (Challenge Solution) - Divider's Parameters
    8. Adding the Card Info Section
    9. Adding the Portfolio Button
    10. Create the Content Composable Function
    11. Adding a LazyColumn Layout and the Toggle Functionality
    12. Final Touches to the BizCard App
    13. What's Next
  5. Chapter 5 : Kotlin Programming Language Fundamentals - Variable Types
    1. Section Introduction
    2. Kotlin var and val Keywords
    3. Initializing Variables
    4. Introduction to Variable Types - Int and String
    5. Basic Types in Kotlin
    6. The Long Type
    7. Floating Point Types
    8. Kotlin Operators
    9. Section Summary
  6. Chapter 6 : Kotlin Fundamentals - Loops and Branching
    1. Section Introduction - Loops and Branching
    2. The If Statement and When Expression
    3. When Expression - Range
    4. The For Loop
  7. Chapter 7 : Kotlin Fundamentals - Functions
    1. Section Introduction - Functions
    2. Create a Simple Kotlin Function
    3. Functions with Int Parameters
    4. Adding More Parameters to a Function
    5. Default Arguments and Named Arguments
    6. Functions and Return Types
    7. Returning a Boolean
    8. Lambda Expressions - an Introduction
    9. (Challenge Solution) - CatAge - To Lambda Expression
    10. Using the "it" Lambda Keyword
    11. Lambda Expressions that Return Unit - Void
    12. Trailing Lambda
  8. Chapter 8 : Kotlin Fundamentals - Collections
    1. Introduction to Collections
    2. Invoking Methods on Lists
    3. Kotlin Sets and Maps Collections
    4. Initializing Lists
    5. Empty Collections
    6. Collection Filters
    7. Section Summary - Collections
  9. Chapter 9 : Kotlin - Intermediate Object-Oriented Programming Concepts
    1. Introduction to OOP - Create First Class
    2. Kotlin Classes and the Primary Constructors
    3. The init Block
    4. Adding a class Function with Parameters
    5. Inheritance and Override
    6. Inheritance Design Steps
    7. Introduction to Interface Classes
    8. Creating an Interface and Using It
    9. Extension Functions in Kotlin
    10. Remove First and Last Character Extension Function - Challenge Solution
    11. Data Class
    12. Section Summary - Kotlin OOP
  10. Chapter 10 : Kotlin - Advanced Concepts
    1. Introduction to Generics
    2. Using Generics
    3. Introduction to Enums and State
    4. Improving Enums - Sealed Classes
    5. Sealed Classes Creation
  11. Chapter 11 : Introduction to Jetpack Compose and Fundamentals
    1. Introduction - What's Jetpack and Understanding the Imperative Approach
    2. Understanding a Compose Project - Basics - Preview and Compose Annotation
    3. Creating a Simple Composable Function
    4. Modifier and Composable Functions - What Are They?
    5. Creating a Simple Compose App - Create a Circle
    6. Adding the Circle to the Main Surface
    7. Finishing Up the User Interface
    8. Introduction to MutableState - Incrementing a Counter
    9. (Imperative Versus Declarative Approach) - Thinking in Compose
    10. Hoisting the State of Our Money Counter App
    11. Section Summary - Jetpack Compose and Paradigm Shift
  12. Chapter 12 : Android Real Device Setup
    1. How to Set Up an Android Device for Development
  13. Chapter 13 : Build a Tip Calculator App
    1. JetTip App Demo
    2. The Structure of JetTip and Setting Up the Container Function
    3. The TopHeader Function - Finish Up
    4. Adding the Rounded Border for the Main Content
    5. Input Fields - Creating a Customizable InputField Composable Function
    6. Showing the Input Field
    7. Refactoring the InputField Compose Function
    8. Creating Round Icon Buttons
    9. Fixing the Input Field Width
    10. Adding the TipRow and Slider
    11. Finishing Up the Slider Composable
    12. Incrementing and Decrementing Functions
    13. Showing the Tip Percentage on Slide Value Change
    14. Calculating the Tip Amount
    15. Total Per Person Calculations
    16. State Hoisting - Code Refactor and Section Summary
  14. Chapter 14 : Build a Movie App - Introduction to Scaffold and LazyColumn
    1. Section Introduction
    2. Understanding the Scaffold Composable
    3. Using LazyColumn and Showing Movies
    4. Make Each Row Clickable
    5. Introduction to Navigation Component
    6. Setting Up the Navigation Structure
    7. Setting Up the Navigation Structure - Home Screen and Details Screen
    8. Navigation and Passing Arguments
    9. Navigating Back on Back button Clicked
    10. Adding the TopAppBar and Back Navigation
    11. Navigation Component Summary
  15. Chapter 15 : Movie App - Improvements
    1. Adding Movie Data Class and Dummy Data
    2. Using Coil to Add Images
    3. Adding Expand Capability on the Card to Show More Information
    4. Adding More Movie Information to the Row
    5. Finishing Up the Details Screen
    6. Section Summary
  16. Chapter 16 : Introduction to ViewModel - Build a Note App
    1. Note App Demo
    2. Note App - Project Setup and Creating a TextField
    3. Adding TextField and a Button
    4. Adding a DataSource Class - Dummy Data
    5. Creating a Note Row and Showing Dummy Notes
    6. Adding and Removing Notes - Showing Them on Screen
    7. Managing State and Data in Compose - Introduction to ViewModel
    8. Creating a ViewModel and Implementing It
  17. Chapter 17 : Note App Improvements - ROOM and Dependency Injection - Hilt
    1. What We Will Do
    2. Understanding Android ROOM and Dependency Injection (DI): Hilt and Dagger
    3. Understanding DI (Dependency Injection) and Its Advantages
    4. Manual DI Versus Hilt
    5. Set Up Hilt Dependencies in Gradle
    6. Setting Up App Hilt AppModule and the NoteApplication Component
    7. The Android ROOM Database Architecture
    8. Adding ROOM and Coroutine Dependencies to Project
    9. Creating a Note Entity
    10. Creating a RoomDatabase Class and DAO
    11. Understanding Coroutines and Suspend Functions
    12. Adding Flow State to getNotes Functions
    13. Adding Providers in AppModule Class
    14. Creating the Repository Class
    15. Updating the NoteViewModel Class
    16. Testing the NoteApp with the ROOM Database
    17. Adding TypeConverters and Getting the App to Work
    18. Section Summary
  18. Chapter 18 : JetTrivia App - Parsing JSON: Retrofit and Clean Architecture
    1. JetTrivia App Demo
    2. Setting Up the Project - Adding All Dependencies
    3. The Trivia JSON Payload
    4. Set Up the App Structure - Adding Retrofit Dependencies
    5. Adding Hilt Classes and Retrofit
    6. Creating a Wrapper Class for Emitting Metadata
    7. Finishing Up the Repository Class
    8. Creating the ViewModel Class
    9. Testing Our ViewModel and Logging Trivia Questions
    10. Refactoring Code and Showing the Progress Bar
    11. Creating the UI - Question Tracker Composable
    12. Creating the UI - Dotted Line Composable
    13. Creating the UI - Radio Button Row
    14. Creating UI - Radio Button Row and Checking Answers
    15. Finishing Up the Logic - App Working
    16. Create a Score Meter
    17. Finalizing the Score Meter
    18. Getting Total Question Count
    19. Section Summary
  19. Chapter 19 : Build a Weather Forecast App
    1. Weather Forecast App Demo
    2. Setting Up Project and Adding All Gradle Dependencies
    3. OpenWeather - Getting the API Key
    4. Setting Up Packages and DI Structures
    5. Setting Up App Navigation - Splash Screen - Part 1
    6. Showing the Splash Screen - Navigation Setup Continuation
    7. Putting Together the Splash Screen UI
    8. Splash Screen Animation and Navigating to Main Screen
    9. What We Have Done So Far
    10. Setting Up Model Classes
    11. Setting Up the Weather API Interface for Retrofit - HTTP Library
    12. Creating the Main ViewModel and the Repository Classes
    13. Setting Up the ViewModel and Retrieving JSON Payload
    14. Setting Up the AppBar - Part 1
    15. Finalizing the WeatherAppBar
    16. Creating the Main Screen Widgets - Top Circle
    17. Creating the Main Screen - Finalizing the Top Circle and Data
    18. Adding Humidity, Wind, and Pressure Row
    19. Creating the Sunset and Sunrise Row
    20. Weather Detail Row
    21. Finalizing the Weather Detail Row and the Main Screen
    22. Refactoring the Code
    23. Break - What We have Done So far
    24. Setting Up the Search Field in Search Screen
    25. Passing the City Name Back to Main Screen and Showing the Forecast Data
    26. Setting Up the Dialog and the Dropdown Menu
    27. Navigating to About, Favorites, and Settings and Creating the About Screen
    28. Introduction to ROOM and Favorite Screen Structure
    29. Creating a Favorite Entity and DAO Class
    30. Setting Up Room Database and Repository
    31. Creating the FavoriteViewModel Class
    32. Adding the Favorite Icon and Saving Favorite Cities to Database
    33. Showing All Favorite Cities
    34. Showing a Toast Message When a City Is Saved
    35. Break - What We have Done So Far - Next Up: The Settings Screen
    36. Creating the Settings View Model
    37. Putting Together the Settings Screen
    38. Saving Measurement Units to the Database
    39. Adding a Default Unit
    40. Showing Metric and Imperial Units in Main Screen - Final Touches
    41. Weather Forecast App Summary

Product information

  • Title: Android Jetpack Compose - Build Android Native UIs Fast
  • Author(s): Paulo Dichone
  • Release date: July 2022
  • Publisher(s): Packt Publishing
  • ISBN: 9781803237718