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
Alexandru Dumbravan
Jun, 2022 | 368 pages
Small book image
Android UI Development with Jetpack Compose
Thomas Kuumlnneth
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

Introducing MVC, MVP, and MVVM as presentation patterns

In the beginning, most Android projects were designed as a bunch of Activity or Fragment classes that were setting content to their corresponding Extensible Markup Language (XML) layouts.

As projects grew and new features were requested, developers had to add more logic inside the Activity or Fragment class, development cycle after development cycle. This means that anything from a new feature, improvement, or bug fix for a particular screen would have to be done inside those Activity or Fragment classes.

After some time, these classes became larger and larger, and at some point, adding an improvement or fixing a bug could become a nightmare. The reason for this would be that the Activity or Fragment classes were burdened with all the responsibilities from within a particular project. These classes would be doing the following:

  • Defining the UI
  • Preparing the data to be displayed and defining different UI states...
Previous Section
End of Section 3
Next Section