Book Image

Kickstart Modern Android Development with Jetpack and Kotlin

By : Catalin Ghita
5 (1)
Book Image

Kickstart Modern Android Development with Jetpack and Kotlin

5 (1)
By: Catalin Ghita

Overview of this book

With Jetpack libraries, you can build and design high-quality, robust Android apps that have an improved architecture and work consistently across different versions and devices. This book will help you understand how Jetpack allows developers to follow best practices and architectural patterns when building Android apps while also eliminating boilerplate code. Developers working with Android and Kotlin will be able to put their knowledge to work with this condensed practical guide to building apps with the most popular Jetpack libraries, including Jetpack Compose, ViewModel, Hilt, Room, Paging, Lifecycle, and Navigation. You'll get to grips with relevant libraries and architectural patterns, including popular libraries in the Android ecosystem such as Retrofit, Coroutines, and Flow while building modern applications with real-world data. By the end of this Android app development book, you'll have learned how to leverage Jetpack libraries and your knowledge of architectural concepts for building, designing, and testing robust Android applications for various use cases.

Related Content you might be interested in

Current Title:

Small book image
Kickstart Modern Android Development with Jetpack and Kotlin
Catalin Ghita
May, 2022 | 472 pages
Small book image
Modern Android 13 Development Cookbook
Madona S. Wambua
Jul, 2023 | 322 pages
Small book image
Clean Android Architecture
Mr. Alexandru Dumbravan
Jun, 2022 | 368 pages
Small book image
Android UI Development with Jetpack Compose
Thomas Künneth
Feb, 2022 | 248 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Get in touch
Share Your Thoughts
1
Part 1: Exploring the Core Jetpack Suite and Other Libraries
Part 1: Exploring the Core Jetpack Suite and Other Libraries
Free Chapter
2
Chapter 1: Creating a Modern UI with Jetpack Compose
Chapter 1: Creating a Modern UI with Jetpack Compose
Technical requirements
Understanding the core concepts of Compose
Exploring the building blocks of Compose UIs
Building a Compose-based screen
Exploring lists with Compose
Summary
Further reading
3
Chapter 2: Handling UI State with Jetpack ViewModel
Chapter 2: Handling UI State with Jetpack ViewModel
Technical requirements
Understanding the Jetpack ViewModel
Defining and handling state with Compose
Hoisting state in Compose
Recovering from system-initiated process death
Summary
Further reading
4
Chapter 3: Displaying Data from REST APIs with Retrofit
Chapter 3: Displaying Data from REST APIs with Retrofit
Technical requirements
Understanding how apps communicate with remote servers
Creating and populating your database with Firebase
Exploring Retrofit as an HTTP networking client for Android
Improving the way our app handles network requests
Summary
Further reading
5
Chapter 4: Handling Async Operations with Coroutines
Chapter 4: Handling Async Operations with Coroutines
Technical requirements
Introducing Kotlin coroutines
Exploring the basic elements of coroutines
Using coroutines for async work
Summary
Further reading
6
Chapter 5: Adding Navigation in Compose With Jetpack Navigation
Chapter 5: Adding Navigation in Compose With Jetpack Navigation
Technical requirements
Introducing the Jetpack Navigation component
Creating a new Compose-based screen
Implementing navigation with Jetpack Navigation
Adding support for deep links
Summary
7
Part 2: A Guide to Clean Application Architecture with Jetpack Libraries
Part 2: A Guide to Clean Application Architecture with Jetpack Libraries
8
Chapter 6: Adding Offline Capabilities with Jetpack Room
Chapter 6: Adding Offline Capabilities with Jetpack Room
Technical requirements
Introducing Jetpack Room
Enabling offline usage by implementing Room
Applying partial updates to the Room database
Making local data the single source of truth for app content
Summary
9
Chapter 7: Introducing Presentation Patterns in Android
Chapter 7: Introducing Presentation Patterns in Android
Technical requirements
Introducing MVC, MVP, and MVVM as presentation patterns
Refactoring our Restaurants app to fit a presentation pattern
Improving state encapsulation in ViewModel
Summary
10
Chapter 8: Getting Started with Clean Architecture in Android
Chapter 8: Getting Started with Clean Architecture in Android
Technical requirements
Defining the Domain layer with Use Cases
Separating the Domain model from Data models
Creating a package structure
Decoupling the Compose-based UI layer from ViewModel
Summary
Further reading
11
Chapter 9: Implementing Dependency Injection with Jetpack Hilt
Chapter 9: Implementing Dependency Injection with Jetpack Hilt
Technical requirements
What is DI?
Why is DI needed?
Implementing DI with Hilt
Summary
Further reading
12
Chapter 10: Test Your App with UI and Unit Tests
Chapter 10: Test Your App with UI and Unit Tests
Technical requirements
Exploring the fundamentals of testing
Learning the basics of testing your Compose UI
Covering the basics of unit-testing your core logic
Summary
Further reading
13
Part 3: Diving into Other Jetpack Libraries
Part 3: Diving into Other Jetpack Libraries
14
Chapter 11: Creating Infinite Lists with Jetpack Paging and Kotlin Flow
Chapter 11: Creating Infinite Lists with Jetpack Paging and Kotlin Flow
Technical requirements
Why do we need pagination?
Importing and exploring the Repositories App
Using Kotlin Flow to handle streams of data
Exploring pagination with Jetpack Paging
Summary
Further reading
15
Chapter 12: Exploring the Jetpack Lifecycle Components
Chapter 12: Exploring the Jetpack Lifecycle Components
Technical requirements
Introducing the Jetpack Lifecycle components
Adding a countdown component in the Repositories app
Creating your own lifecycle-aware component
Making our countdown component aware of the lifecycle of composables
Summary
Further reading
Why subscribe?
16
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Further reading

Clean Architecture is a very complex subject, and one chapter is simply not enough to cover it. However, one of the most important concepts that Clean Architecture brings is the Dependency Rule. The Dependency Rule states that within a project, dependencies can only point inward.

To understand what the Dependency Rule is about, let's visualize the layer dependencies of our Restaurants app through a simplified version of concentric circles. Each concentric circle represents different areas of software with their corresponding layer dependencies (and libraries).

Figure 8.7 – The Dependency Rule with layers and components

This representation dictates that implementation details should be placed in outer circles (just as Compose is an implementation detail of the UI layer or Retrofit is an implementation detail for the Data layer), while business policies (Use Cases from the Domain layer) are placed within the inner circle.

The...

Previous Section
End of Chapter 10
Next Chapter