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