Manifest Android Interview Course

Preface

Who This Course Is For

What This Course Covers

How to Use This Course

Course Structure

Practical Questions

Quizzes and Exercises

Earning Your Certificate

Staying Current

Phone/Video Screening (30-60 Minutes)

On-Site/Virtual Technical Rounds

System Design Rounds

Take-Home Assignments

Live Coding

Depth Over Breadth

Trade Off Analysis

Awareness of Internal Mechanisms

Practical Experience Signals

Communication Clarity

The “What, How, Why, Trade offs” Framework

Example: “Explain when Recomposition is triggered in Compose”

When to Mention Alternatives

Using Code Examples in Verbal Answers

Step 1: Identify Relevant Topics

Step 2: Study the Deep Dive Content

Step 3: Focus on Pro Tips for Mastery

Step 4: Practice with the Practical Questions

Step 5: Test Yourself with Quizzes and Exercises

Step 6: Review Recaps and Glossary Before the Interview

Topic Priority by Role Level

Setting Clear Scoring Criteria

Using Follow Up Questions Effectively

Creating a Comfortable Environment

Evaluating Understanding vs Memorization

Chapter Overview

What is Android?

Key Features of Android OS

Android Architecture

Summary

Practical Questions

What is Intent?

1. Explicit Intent

2. Implicit Intent

Summary

💡 Pro Tips for Mastery: What is Intent Filters?

The Purpose of Pending Intent

Key Features of PendingIntent

Use Cases

Security Considerations

Summary

Practical Questions

Serializable vs Parcelable

Serializable

Parcelable

Key Differences:

Summary

💡 Pro Tips for Mastery: Parcel and Parcelable

The Purpose of Bundle

Common Use Cases for a Bundle

How a Bundle Works

Example: Passing Data Between Activities

Example: Passing Data Between Fragments

Example: Saving and Restoring State

Summary

Passing Data Between Activities and Fragments

Passing Data Between Activities

Passing Data Between Fragments

Passing Data Between Fragments With Jetpack Navigation Library

1. Define arguments in the navigation graph

2. Pass data from the source fragment

3. Retrieve data in the destination fragment

Using a Shared ViewModel

Summary

💡 Pro Tips for Mastery: Fragment Result API

Setting a Result Listener in Fragment A

Sending Results from Fragment B

Behavior of Fragment Results

Summary

Practical Questions

What is Context?

Application Context

Activity Context

Service Context

Broadcast Context

Common Use Cases of Context

Summary

💡 Pro Tips for Mastery: What to be careful about when using Context?

Avoid Context Use on Background Threads

Summary

💡 Pro Tips for Mastery: What is ContextWrapper?

Purpose of ContextWrapper

Use Cases

Example of ContextWrapper

Key Benefits

Summary

💡 Pro Tips for Mastery: Differences between this and baseContext in Activity

this in an Activity

baseContext in an Activity

Key Differences Between this and baseContext

Example: Custom Context Wrapping

Summary

The Application Class

Purpose of the Application Class

Key Methods in the Application Class

How to Use the Application Class

Use Cases for the Application Class

Best Practices

Summary

Practical Questions

The AndroidManifest File

Key Functions of AndroidManifest.xml

Summary

Runtime Permissions

Declaring and Checking Permissions

Requesting Permissions

Providing a Permission Rationale

Handling Permission Denial

Handling Location Permissions

One-Time Permissions

Summary

Practical Questions

The Activity Lifecycle

Summary

💡 Pro Tips for Mastery: Lifecycle changes between multiple Activities

Complete Sequential Lifecycle Flow for Activity A and Activity B:

Summary

💡 Pro Tips for Mastery: The lifecycle instance in an Activity

How to Use the Lifecycle Instance

Benefits of Using the Lifecycle Instance

Summary

Handling Configuration Changes

💡 Additional Tips

Summary

What Happens to an Activity During Configuration Changes

Default Behavior During Configuration Changes

Key Configuration Changes Triggering Recreation

Avoiding Activity Recreation

Summary

Practical Questions

The Fragment Lifecycle

Summary

💡 Pro Tips for Mastery: Differences Between fragmentManager and childFragmentManager

fragmentManager

childFragmentManager

Key Differences

Summary

💡 Pro Tips for Mastery: The viewLifecycleOwner instance in a Fragment

What is viewLifecycleOwner?

Difference Between lifecycleOwner and viewLifecycleOwner

Summary

Practical Questions

What is Service?

1. Started Service

2. Bound Service

3. Foreground Service

Key Differences Between Service Types

Best Practices for Using Services

Summary

💡 Pro Tips for Mastery: How do you handle foreground service?

Key Differences Between Service and Foreground Service

Best Practices for Using Services

Summary

💡 Pro Tips for Mastery: The lifecycle of the service

Lifecycle Methods for Started Service

Lifecycle Methods for Bound Service

Key Differences Between Started and Bound Service Lifecycle

Summary

What is BroadcastReceiver?

Purpose of BroadcastReceiver

Types of Broadcasts

Declaring a BroadcastReceiver

Registering a BroadcastReceiver

Important Considerations

Use Cases for BroadcastReceiver

Summary

What is ContentProvider?

Purpose of ContentProvider

Key Components of a ContentProvider

Implementing a ContentProvider

Registering a ContentProvider

Accessing Data from a ContentProvider

Use Cases for ContentProvider

Summary

💡 Pro Tips for Mastery: Using ContentProvider to initialize resources at app startup

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

Memory Management in Android

Avoiding Memory Leaks

Best Practices to Avoid Memory Leaks

Summary

ANR (Application Not Responding) Errors

How to Prevent ANRs

Summary

Practical Questions

Deep Links

Step 1: Define Deep Links in the Manifest

Step 2: Handle the Deep Link in the Activity

Step 3: Testing the Deep Link

Additional Considerations

Summary

Tasks and Back Stack

Tasks

Back Stack

Launch Modes

Intent Flags

Use Cases

Example

Summary

ActivityManager

Common Methods of ActivityManager

Example Usage

ActivityManager in LeakCanary

Summary

Practical Questions

Looper, Handler, and HandlerThread

Looper

Handler

HandlerThread

Key Differences and Relationships

Use Cases

Summary

Practical Questions

SparseArray

Key Characteristics of SparseArray

Benefits of Using SparseArray Over an Array or HashMap

Limitations of SparseArray

Summary

Exception Tracing

Exception Logging with Logcat

Handling Exceptions with try-catch

Using a Global Exception Handler

Using Firebase Crashlytics

Debugging with Breakpoints

Capturing a Bug Report

Summary

Accessibility

Leveraging Content Descriptions

Supporting Dynamic Font Sizes

Focus Management and Navigation

Color Contrast and Visual Accessibility

Custom Views and Accessibility

Testing for Accessibility

Summary

Practical Questions

Build Variants and Flavors

Build Variants

Product Flavors

Combining Build Types and Flavors

Advantages of Using Build Variants and Flavors

Summary

APK vs. AAB

APK (Android Package)

AAB (Android App Bundle)

Key Differences Between APK and AAB

Summary

R8 Optimization

How R8 Works

Key Features of R8 Optimization

R8 Configuration

Advantages of R8

Limitations of R8

Summary

Reducing Application Size

Remove Unused Resources

Enable Code Shrinking with R8

Use Resource Optimization

Use Android App Bundles (AAB)

Remove Unnecessary Dependencies

Optimize Native Libraries

Reduce Debug Information by Configuring the Proguard Rules

Use Dynamic Features

Avoid In-App Large Assets

Summary

Practical Questions

The Android File System

Key Components of the Android File System

Accessing Files in Android

File Permissions and Security

Summary

Android Runtime (ART), Dalvik, and Dex Compiler

Android Runtime (ART)

Dalvik

Dex Compiler

Transition from Dalvik to ART

Summary

Processes in Android

How Processes Work in Android

Application Components and Process Association

Processes and App Lifecycles

Security and Permissions

Summary

💡 Pro Tips for Mastery: Why are Activities, Services, Broadcast Receivers, and Content Providers called four major components in Android?

How Each Component Relates to the Android Process

Connection to Android Processes

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

The View Lifecycle

Summary

💡 Pro Tips for Mastery: What’s the findViewTreeLifecycleOwner() function in a View?

Why Use findViewTreeLifecycleOwner()?

Key Use Cases

Limitations

Summary

View vs ViewGroup

What is a View?

What is a ViewGroup?

Key Differences Between View and ViewGroup

Summary

Invalidation in the View System

How Invalidation Works

Key Methods for Invalidation

Using invalidate() to Update a Custom View

Best Practices for Invalidation

Summary

Practical Questions

ViewStub and Deferred Inflation

Key Characteristics of ViewStub

Common Use Cases for ViewStub

How to Use ViewStub

Advantages of ViewStub

Limitations of ViewStub

Summary

ConstraintLayout

Key Features of ConstraintLayout

Example of ConstraintLayout

Advantages of ConstraintLayout

Limitations of ConstraintLayout

Use Cases of ConstraintLayout

Summary

Dp and Sp Measurement Units

What is Dp?

What is Sp?

Key Differences Between Dp and Sp

When to Use Dp or Sp

Summary

💡 Pro Tips for Mastery: How would you handle screen breaking when using Sp units?

Strategies to Prevent Screen Breaking

1. Wrap Content Properly

2. Use minLines or maxLines for TextViews

3. Use Fixed Sizes for Critical UI Components

4. Test with Extreme Font Sizes

5. Consider Dynamic Sizing with Constraints

6. Use Dp size instead of Sp

Summary

Nine-Patch Images

Key Features of Nine-Patch Images

Example Usage in XML

Limitations of Nine-Patch Images

Summary

Practical Questions

Implementing Custom Views

1. Create a Custom View Class

2. Use Custom View in XML Layout

3. Add Custom Attributes (Optional)

4. Handle Layout Measurement (Optional)

Summary

💡 Pro Tips for Mastery: Why should you be cautious when using @JvmOverloads on the primary constructor for custom views?

Canvas and Custom Drawing

How Canvas Works

Common Operations with Canvas

Transformations

Use Cases

Summary

Practical Questions

Drawable Types in Android

1. BitmapDrawable (Raster Images)

2. VectorDrawable (Scalable Vector Graphics)

3. NinePatchDrawable (Resizable Images with Padding)

4. ShapeDrawable (Custom Shapes)

5. LayerDrawable (Multiple Drawables Stacked)

Summary

Bitmap Loading and Memory Management

The Problem with Large Bitmaps

Reading Bitmap Dimensions Without Allocating Memory

Loading Scaled-Down Bitmaps with Sampling

Full Decoding Process with Subsampling

Summary

💡 Pro Tips for Mastery: How would you implement caching for large bitmaps in a custom image loading system?

In-Memory Caching with LruCache

Disk Caching with DiskLruCache

Summary

Practical Questions

SurfaceView vs TextureView

Differences Between SurfaceView and TextureView

Summary

How RecyclerView Works Internally

Core Concepts of RecyclerView’s Internal Mechanism

How the Recycling Mechanism Works

Advantages of RecyclerView’s Object Pool Approach

Summary

💡 Pro Tips for Mastery: How would you implement different types of items in the same RecyclerView?

Steps to Implement Multiple Item Types

Example: Implementing Multiple Item Types

Key Points to Note

Summary

💡 Pro Tips for Mastery: How would you improve the performance of RecyclerView?

Steps to Use DiffUtil

Example: Implementing DiffUtil with RecyclerView

Key Benefits of DiffUtil

Considerations

Summary

Practical Questions

Animation Types in Android

View Property Animations

ObjectAnimator

AnimatorSet

ValueAnimator

XML-Based View Animations

MotionLayout

Drawable Animations

Physics-Based Animations

Summary

💡 Pro Tips for Mastery: How interpolator works with animations?

Summary

Practical Questions

The Window System

Key Features of a Window

Window Management

Common Use Cases for Windows

Summary

💡 Pro Tips for Mastery: What is WindowManager?

Key Responsibilities of WindowManager

Common Use Cases

Working with WindowManager

Limitations and Permissions

Summary

💡 Pro Tips for Mastery: What is PopupWindow

Summary

Rendering Web Content with WebView

Initializing WebView

Loading a Web Page

Enabling JavaScript

Customizing WebView Behavior

Binding JavaScript to Android Code

Security Considerations

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

The AppCompat Library

Why Use AppCompat?

Example Usage of AppCompatActivity

Summary

Material Design Components (MDC)

Key Features of Material Design Components

Example of Using Material Button

Summary

Practical Questions

ViewBinding

How ViewBinding Works

Advantages of ViewBinding

Comparison with DataBinding

Enabling ViewBinding

Summary

DataBinding

Enabling DataBinding

How DataBinding Works

Example of a DataBinding XML Layout

Binding Data in Code

Features of DataBinding

Advantages of DataBinding

Drawbacks of DataBinding

Summary

💡 Pro Tips for Mastery: What are the differences between ViewBinding and DataBinding?

Key Differences

Summary

Practical Questions

LiveData

Differences Between MutableLiveData and LiveData

Use Cases for LiveData

Summary

💡 Pro Tips for Mastery: What are the differences between the setValue() and postValue() methods in LiveData?

1. setValue()

2. postValue()

Key Differences

Common Usage Patterns

Summary

Jetpack ViewModel

Features of ViewModel

ViewModel Creation and Usage

Summary

💡 Pro Tips for Mastery: What is the lifecycle of a ViewModel?

💡 Pro Tips for Mastery: How can ViewModel be retained even after the configuration changes?

Summary

💡 Pro Tips for Mastery: What are the differences between Jetpack ViewModel and Microsoft’s MVVM architecture’s ViewModel?

Differences Between Jetpack ViewModel and MVVM ViewModel

Summary

Practical Questions

The Jetpack Navigation Library

Navigation Graph

NavHostFragment

NavController

Safe Args

Deep Linking

Benefits of the Jetpack Navigation Library

Summary

Practical Questions

Dagger 2 and Hilt

What is Dagger 2?

What is Hilt?

Key Differences Between Dagger 2 and Hilt

Annotations Provided by Hilt and Dagger 2

Shared Annotations (Provided by Dagger and Used by Hilt)

Hilt-Specific Annotations

Summary

💡 Pro Tips for Mastery: Can you implement a manual dependency injection?

💡 Pro Tips for Mastery: What are the alternative libraries for Dagger 2 and Hilt?

Koin: A Lightweight and Easy-to-Use DI Library

Key Features of Koin:

Example:

Dagger 2 vs. Koin for dependency injection?

Is Koin a service locator pattern?

Metro: A Compile-Time DI Framework for Kotlin Multiplatform

Key Features of Metro:

Example

Choosing the Right Library

Practical Questions

The Jetpack Paging Library

Components of the Paging Library

How the Paging Library Works

Sample Implementation of Jetpack Paging

Summary

Baseline Profiles

How Baseline Profiles Work

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

Managing Long-Running Background Tasks

Using WorkManager for Persistent Tasks

Using Services for Continuous Tasks

Using Kotlin Coroutines and Dispatchers

Using JobScheduler for System-Level Tasks

Summary

Practical Questions

JSON Serialization

What are Serialization and Deserialization?

Manual Serialization and Deserialization

kotlinx.serialization

Moshi

Gson

Choosing a Serialization Library

Network Requests with Retrofit and OkHttp

Using Retrofit for Network Requests

Using OkHttp for Custom HTTP Requests

Integrating OkHttp with Retrofit

Summary

💡 Pro Tips for Mastery: How do you refresh the OAuth token using OkHttp Authenticator and Interceptors?

Using OkHttp Authenticator

Using OkHttp Interceptor

Key Differences Between Authenticator and Interceptor

Summary

💡 Pro Tips for Mastery: What is Retrofit CallAdapter?

How CallAdapter Works

Default CallAdapter in Retrofit

Example: Using a Coroutine CallAdapter with Retrofit

Custom CallAdapter Example

Summary

Practical Questions

Paging Systems for Large Datasets

Steps to Implement a Paging System

Summary

Image Loading from the Network

Glide

Coil

Fresco

Choosing an Image Loading Library

Practical Questions

Local Data Storage in Android

SharedPreferences

DataStore

Room Database

File Storage

Summary

Practical Questions

Offline-First Architecture

Key Concepts for Offline-First Architecture

Practical Implementation

Offline-First Best Practices

Data Loading Patterns: LaunchedEffect vs. ViewModel.init()

Both are Anti-Patterns: Use Lazy Observation

Best Practices for Lazy Observation

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

The Structure of Jetpack Compose

Compose Compiler

Compose Runtime

💡 Pro Tips for Mastery: Migrating from a gap buffer to a link table

Compose UI

Summary

The Compose Phases

Composition

Layout

Drawing

Summary

Practical Questions

Why Jetpack Compose Is a Declarative UI Framework

Key Characteristics of Declarative UI in Jetpack Compose

Jetpack Compose vs. XML

Summary

Recomposition

Conditions That Trigger Recomposition

Recomposition and Performance

Summary

Practical Questions

Compiler Transformation

Composition and Recomposition Internals

Remember and State Management

Summary

💡 Pro Tips for Mastery: Compose Compiler and Composer

Transformation of Composable Functions

The Role of the Composer

Summary

💡 Pro Tips for Mastery: Why Should You Avoid Calling Business Logic Directly Inside Composable Functions?

Examples of Side-Effect-Free and Side-Effect Composables

Composable Functions Can Execute in Any Order

Summary

Practical Questions

Understanding Stability

Stable vs. Unstable

Inferring Composable Functions

Summary

💡 Pro Tips for Mastery: Smart Recomposition

How Smart Recomposition Works

Why Avoiding Unnecessary Recomposition Matters

Summary

💡 Pro Tips for Mastery: Stability Annotations

@Immutable

@Stable

Differences Between @Immutable and @Stable

Summary

💡 Pro Tips for Mastery: What Happens if You Misuse @Stable Over @Immutable?

Performance Optimization Strategies

Immutable Collections

Lambda Stability

Wrapper Classes

Stability Configuration File

Strong Skipping Mode

Compose Stability Analyzer

Summary

Testing Compose Performance in Release Mode

Impact of Debug Mode on Compose

Live Edit Literals and Developer Tools

R8 Optimization in Release Mode

Why Baseline Profiles Matter

Practical Testing Recommendations

Summary

Practical Questions

Composition and How to Create It

Creating a Composition

Using the ComponentActivity.setContent() Function

Embedding Compose in XML Layouts

Summary

Migration Strategies from XML to Compose

1. Incremental Migration

2. Screen-by-Screen Migration

3. Gradual Component Migration

4. Full Rewrite

5. Leverage Interoperability for Libraries

6. Test and Monitor During Migration

Summary

💡 Pro Tips for Mastery: Does mixing XML and Jetpack Compose impact the app size?

Kotlin Idioms in Jetpack Compose

Default Arguments

Higher-Order Functions and Lambda Expressions

Trailing Lambdas

Scopes and Receivers

Delegated Properties

Destructuring Data Classes

Singleton Objects

Type-Safe Builders and DSLs

Kotlin Coroutines

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

State and Composition

Managing State in Compose

Summary

State Hoisting

Example

Key Advantages of State Hoisting

Summary

💡 Pro Tips for Mastery: Stateful vs. Stateless, Understanding State Hoisting With Code

Practical Questions

Understanding remember

Understanding rememberSaveable

Key Differences

When to Use

Summary

💡 Pro Tips for Mastery: remember and rememberSaveable internals

Understanding remember Internals

Understanding rememberSaveable Internals

Practical Questions

Safely Creating Coroutine Scopes in Composables

Why Use rememberCoroutineScope?

Example Usage

How It Works

Best Practices

Summary

💡 Pro Tips for Mastery: rememberCoroutineScope internals

Internal Implementation of rememberCoroutineScope

1. CompositionScopedCoroutineScopeCanceller

2. createCompositionCoroutineScope

How rememberCoroutineScope Works Internally

Summary

Safely Collecting Flows in Composable Functions

Using collectAsState

Using collectAsStateWithLifecycle

Choosing the Right Approach

Summary

Practical Questions

Side-Effect Handler APIs

LaunchedEffect: Run Suspend Functions in the Scope of a Composable

DisposableEffect: Effects That Require Cleanup

SideEffect: Publish Compose State to Non-Compose Code

Summary

rememberUpdatedState

How It Works

Use Cases

Explanation

Key Benefits

Summary

💡 Pro Tips for Mastery: rememberUpdatedState internals

produceState

Syntax

Example Usage

Explanation of the Example

Benefits of produceState

Best Practices

Summary

💡 Pro Tips for Mastery: produceState internals

Practical Questions

snapshotFlow

Key Characteristics of snapshotFlow

When to Use snapshotFlow

How to Use snapshotFlow

How Does snapshotFlow Work Internally?

Things to Keep in Mind

Summary

derivedStateOf

When to Use derivedStateOf

How to Use derivedStateOf

How Does derivedStateOf Work?

Key Points to Keep in Mind

Advanced Example: Calculating Derived State in Real Time

Incorrect Usage

Summary

Practical Questions

Composition Lifecycle

1. Initial Composition

2. Recomposition

3. Leaving the Composition

Key Points About the Composition Lifecycle

Summary

SaveableStateHolder

Example: SaveableStateHolder with Navigation

Key Concepts in the Example

Advantages of SaveableStateHolder

Summary

The Snapshot System

Why Use Snapshot.takeSnapshot()?

Example: Using Snapshot.takeSnapshot()

Explanation of the Example

Key Features of Snapshot.takeSnapshot()

Benefits of Using Read-Only Snapshots

Summary

💡 Pro Tips for Mastery: How do you create a mutable snapshot?

Example: Creating and Using a Mutable Snapshot

Steps in the Example

Key Points

Advantages of Mutable Snapshots

When to Use Mutable Snapshots

Summary

mutableStateListOf and mutableStateMapOf

mutableStateListOf

mutableStateMapOf

Common Usages

Summary

CompositionLocals

Why Use CompositionLocal?

Example Usage

Summary

💡 Pro Tips for Mastery: Why should you use CompositionLocal with caution?

compositionLocalOf: Dynamic State with Fine-Grained Recomposition

staticCompositionLocalOf: Efficient for Static Values

Recomposition Considerations

Summary

Practical Questions

Chapter Summary

Key Terms

Side-Effect APIs

State Persistence

CompositionLocal APIs

Observable Collections

Important Concepts

What to Remember

Chapter Overview

What is Modifier?

Importance of Modifier Order

Commonly Used Modifiers

Sizing and Constraints

Layout Positioning

Scoped Modifiers

Summary

💡 Pro Tips for Mastery: Rules for Using Modifiers

1. Apply Modifiers to the Outermost Layout

2. Use a Single Modifier Parameter

3. Avoid Reusing Modifier Parameters Across Components

Summary

💡 Pro Tips for Mastery: How Do You Create a Custom Modifier?

Composable Modifier Factory

composed {}

Modifier.Node

Summary

Practical Questions

The Layout Composable

How Layout Works

Key Components of Layout

When to Use Layout

Summary

💡 Pro Tips for Mastery: SubcomposeLayout

How SubcomposeLayout Works

Example Usage

Key Considerations

Summary

Box Layout

How Box Works

Example Usage

Key Features

Summary

💡 Pro Tips for Mastery: BoxWithConstraints

How BoxWithConstraints Works

Example Usage

Key Features

Summary

Arrangement and Alignment

What is Arrangement?

Example of Arrangement

What is Alignment?

Example of Alignment

Key Differences

Summary

Practical Questions

The Painter Abstraction

How Painter Works

Example Usage

Key Features

Summary

Loading Images from the Network

Coil

Glide

Landscapist

Summary

Efficiently Rendering Large Lists

Using LazyColumn for Vertical Lists

Using LazyRow for Horizontal Lists

Using LazyVerticalGrid for Grid Layouts

Optimizing Performance with Keys

Summary

Implementing Pagination with Lazy Lists

Detecting Scroll Position for Pagination

ViewModel for Managing Pagination

Summary

Practical Questions

Canvas

Example Usage

Basic Transformations

Summary

The graphicsLayer Modifier

How graphicsLayer Works

Example Usage

Applying Transformations

Translation (Moving an Element)

Rotation (Rotating Around X, Y, or Z Axis)

Clipping and Shaping

Alpha (Opacity Control)

Compositing Strategies

Writing a Composable to a Bitmap

Summary

Visual Animations

Using AnimatedVisibility for Appearance and Disappearance

Creating Smooth Transitions with Crossfade

Animating Content Changes with AnimatedContent

Using animate*AsState for Property Animations

Handling Size Changes with animateContentSize

Summary

Practical Questions

Navigating Between Screens

Manual Navigation

Jetpack Compose Navigation

1. Defining Navigation with NavHost

2. Navigating Between Screens

Summary

Compose Preview

Using @Preview to Render Composables

Customizing Previews

Multiple Previews with @PreviewParameter

Interactive Mode in Previews

MultiPreview Annotations

Summary

Unit Testing Compose UI

Setting Up Compose UI Tests

Testing UI Interactions

Synchronization and Idling Resources

Testing Lazy Lists

Verifying UI Semantics and Accessibility

Summary

Screenshot Testing

Compose Screenshot Testing Plugin

Paparazzi

Roborazzi

Summary

Accessibility in Jetpack Compose

Semantics Modifier

contentDescription for Images and Icons

Merging Semantics for Grouped Content

Custom Accessibility Actions

Testing Accessibility

Summary

Practical Questions

Chapter Summary

Key Terms

Important Concepts

What to Remember