Real-World Android by Tutorials (Second Edition): Professional App Development With Kotlin

✍ Scribed by raywenderlich Tutorial Team, Ricardo Costeira, Antonio Roa-Valverde, Subhrajyoti Sen, Kolin Stürt

• Publisher: Razeware LLC
• Year: 2022
• Tongue: English
• Leaves: 519
• Category: Library

✦ Synopsis

Learn How to Implement a Real World Android App

When developing a professional Android app, there are hundreds of options for libraries and possible architectures. Finding documentation is easy, but you might end up with an app structure that isn’t ideal for your project.

Real-World Android by Tutorials helps you implement a real-world app from scratch, addressing critical problems like finding the right architecture, making the UI responsive and appealing and implementing efficient animations.

Who this book is for

This book is for intermediate Android developers who already know the basics of the Android platform and the Kotlin language, and who are looking to build modern and professional apps using the most important libraries. If you want to create a reactive and good-looking UI and are determined not to ignore important aspects like security, this book will help.

Topics covered in Real-World Android by Tutorials

By reading this book, you’ll learn about the following topics:

• Choosing the right architecture: Pick the right app architecture to achieve a good separation between domain and data layers, making your app easy to build and maintain.
• Building features: Learn how to structure your code to make it more testable.
• Modularization: Split your code into different modules, improving the build time and reusability of your code.
• Animations: Use the new Motion Editor to implement animations that make your app’s UI more appealing.
• Custom Views: Go beyond the basics by creating a View that’s specific to your app’s needs.
• Security: Protect your app’s data and code.
• Tooling: Mastering the right tool is a fundamental skill when creating a professional app. Learn how to use the tools to analyze your code and fix some tricky bugs.

After reading this book, you’ll be prepared to implement your own, professional Android app.

✦ Table of Contents

Book License
What You Need
Book Source Code & Forums
About the Authors
About the Editors
Acknowledgments
Content Development
Chapter 1: Introduction
What Is This Book About?
Who Is This Book for?
The Sample Project
Signing Up for an API Key
Where to Go From Here?
Chapter 2: Starting From the Beginning
Package by Feature Approach
Full Stack Features Through Layers
Bridging Requirements and Implementation
Devising a Plan of Attack
Key Points
Chapter 3: Domain Layer
What Is a Domain Layer?
Creating Your Domain Model
Inverting Dependencies With Repositories
Testing Your Domain Logic
Key Points
Chapter 4: Data Layer — Network
What Is a Data Layer?
Network Data Models
Connecting to the API With Retrofit
Interceptors
Testing the Network Code
Key Points
Chapter 5: Data Layer — Caching
Cache Data Models
Caching Data With Room
Managing Cache Dependencies With Hilt
Putting It All Together
Testing Your Repository
Key Points
Chapter 6: Building Features — Animals Near You
What Is a Presentation Layer?
Making Your Life Easier With Architecture
Building Animals Near You
Creating the UI Components
Creating the View State
Creating the Data Flow
Your First Use Case
Connecting the Layers
Hilt on Android Components
Displaying Cute Animals
Allowing an Infinite Scroll
Key Points
Chapter 7: Building Features — Search
Building a Search Feature
Getting Started
Searching Locally
Triggering the Search
Adding Search to the Repository
Adding Search to the ViewModel
Searching Remotely
Canceling Old Search Requests
Finishing Touches
Testing
ViewModel Tests
UI Tests
Key Points
Chapter 8: Multi-Module Apps
What is Modularization?
Types of Modules
Why Modularization Is Good
Using Gradle With Modules
Looking Back Over Your Decisions so Far
Creating the Onboarding Feature Module
Navigating Between Feature Modules
Using Deep Links
Additional Improvements
Key Points
Chapter 9: Dynamic Features Theory
Android App Bundle
Dynamic Delivery
What Are Dynamic Features?
Key Points
Chapter 10: Building a Dynamic Feature
PetSave’s New Features
Deciding How to Create Your Dynamic Feature
Preparing the App MNodule
Preparing the Feature Module
Handling Navigation
Handling Dependency Injection
Testing Module Install
Key Points
Where to Go From Here?
Chapter 11: Animations
Lottie
Animated Vector Drawables
Physics-based Animations
Key Points
Chapter 12: MotionLayout & Motion Editor
Getting to Know MotionLayout
Getting Started
Adding Your First Constraint
Motion Editor
Adding a Trigger
Overriding Visibility
Animating More Features
Adding Non-linear Motion
ImageFilterView
Key Points
Chapter 13: Custom Views
Creating Custom Views
Implementing a Progress Button
Initializing the Paint Objects
Designing the Animation Logic
Painting Your Shape
Previewing Your Shape
Adding Animation
Drawing the Check Icon
Putting Everything Together
Manually Stopping the Animation
Enhancing Performance
Key Points
Chapter 14: Style & Theme
Defining Styles and Themes
Structure of a Style
Structure of a Theme
Style Hierarchy
Theme Overlay
TextAppearance
Setting Up Dark Themes
Styling Custom Views
Key Points
Chapter 15: User Privacy
Securing the Foundations
Using Permissions
Opting Out
Clearing Caches
Disabling Logging
Disabling Screenshots
Wiping Memory Securely
Key Points
Where to Go From Here?
Chapter 16: Securing Data at Rest
Implementing the Login
Securing Data with Biometrics
Customizing Encryption
Key Points
Chapter 17: Securing Data in Transit
Understanding HTTPS
Updating Security Providers
Understanding Certificate and Public Key Pinning
Using Certificate Transparency
Preventing Information Leaks with OCSP Stapling
Understanding Authentication
End-to-end Encryption
Key Points
Where to Go From Here?
Chapter 18: App Hardening
Introducing Overflows
Paying Attention to Warnings
Sanitizing Data
Validating Input
Nullability and Safety Checks
Concurrency
Checking App Integrity
Key Points
Chapter 19: Firebase Integration
Setting up Firebase
Crashlytics
Remote Config
Firebase Test Lab
Key Points
Chapter 20: Release Optimizations
Using APK Analyzer
Enabling an Optimizer
ProGuard Versus R8
Fixing Compilation Errors
Enabling More Optimizations
A Few Things To Keep in Mind…
Key Points
Chapter 21: Advanced Debugging
Memory Leaks
Android Studio Profiler
Layout Inspector
Key Points
Chapter 22: App Analysis
Debugging Versus Investigating
Extracting Data
Recovering Deleted Data
Black Box Testing And Reverse-engineering
Using Reverse-engineering Tools
Debugging With ProGuard Output Files
Some Final Notes
Key Points
Conclusion