Modern Android Development with Jetpack Compose

Build a calculator app with Jetpack Compose, enabling dark and light themes, implementing button input, expressions, and results. Follow Figma designs and configure color palettes for a calculator theme.

Learn how Jetpack Compose uses the weight modifier in a column to allocate remaining space, handle wrap content, and apply padding and rounded corners with clip and per-corner radii.

Learn to handle click events with the clickable modifier, log events via Logcat and log levels, and drive UI updates in Jetpack Compose with mutableStateOf and recomposition.

Learn how StateFlow and ViewModel enable reliable UI updates across screens in Jetpack Compose, with collectAsState and asStateFlow for encapsulation and lifecycle alignment.

Learn to format and display a live math expression by appending input and using enum values for symbols. Implement getCorrectParentheses logic and update the expression state for reliable display.

Explore clean architecture by building a notes app with presentation, domain, and data layers; use cases like GetAllNodesUseCase and AddNodeUseCase drive the app's business logic around the Node entity.

Define the domain layer by creating the Node entity and use cases, apply the invoke operator and Flow for reactive data, and follow single responsibility and least knowledge principles.

Finish the domain layer by defining the NodesRepository interface with addNode, deleteNode, edit, switchPinnedStatus; expose getAllNodes and search as flows, and getNodeById; use cases delegate to it.

Explore mvvm in clean architecture by building a nodes screen with a view model, using flatMapLatest to switch between all nodes and search results, and manage pin status.

Prepare the first screen by wiring the view model to a search query flow, updating the UI on input, and refining use cases for adding and getting nodes.

Design a reusable notes card by following three rules: expose a modifier, pass data from outside, and use callbacks; then optimize lists with LazyColumn and LazyRow.

Build a notes screen in Jetpack Compose by composing a title, a Material Design search bar with a slot API, and note cards with click, long-press, and pinning interactions.

Format timestamps into user-friendly strings in the presentation layer with DateFormatter.FormatDateToString, TimeUnit, and locale-aware short dates, and improve readability by constraining pinned node width to 160dp.

Create a node screen as a composable with scaffold and top app bar, including title and content fields, a date display, and a save button wired to the view model.

Explore side effects in Jetpack Compose by distinguishing pure functions from impure ones, and learn when to use SideEffect or LaunchedEffect to handle actions outside composition.

Implement a simple custom navigation in Jetpack Compose using a navgraph for nodes, createNode, and editNode, manage state with remember and mutableStateOf, and examine back button and viewmodel lifecycles.

Learn to implement Jetpack Compose navigation by wiring the navigation library, creating a rememberNavController, configuring navHost with a start destination and string-based screen routes.

Learn how to pass node ids during navigation in Jetpack Compose by building root strings with a slash, retrieving NodeID from the bundle, and using a dedicated getNodeId method.

Replace the test repository with persistent storage by using Room to create a nodes table and define id as a primary key with auto generate.

Demonstrate creating a room database table via Node entity and auto-generated primary key, while enforcing clean architecture by placing data models in the data layer and mapping to domain entities.

Explore SQL basics and build a Room DAO for the nodes table, with select, order by, where like, and suspend insert, update, delete; use flow to observe updates.

Learn to use the Context class and its Activity and Application subclasses to build a singleton database, pass Application Context to avoid leaks, and obtain Context in Compose with LocalContext.

Create a Room database by declaring an abstract NodeDatabase with NodeDBModel as the entity, version 1, and exportSchema false. Implement a thread-safe getInstance using Room.databaseBuilder to obtain a NodesDEO DAO.

Create a singleton NodesRepositoryImpl that uses a context to instantiate the database, access the NodesDao, and map NodeDB models to domain nodes via toEntities extension.

Explore how a component provides dependencies and enables property injection to supply the example viewModel in an activity, using lateinit vars and an inject method.

Learn to use a data model to provide repository implementations when constructors can't be annotated, and manage the database via a provider method in a singleton component.

Learn how assisted injection resolves runtime parameters by building a ViewModelFactory that combines component-provided dependencies with a runtime item, explaining manual and Hilt approaches.

Learn to use Hilt Navigation Compose for injecting viewmodels directly in composables, with HiltViewModel, AssistedInject, and factory creation callbacks, reducing activity-wide viewmodel passing.

Add content-item as a sealed interface to support text and image elements for nodes, serialize the collection to JSON with kotlinx serialization, and map between domain and data models.

Set up image-ready content handling in the add and edit screens, implement text content and save logic, and explain database versioning and destructive migrations for development.

Learn to retrieve images from the gallery using the activity result API in Jetpack Compose, including a top bar icon and GetContent contract.

Learn to save images to the database and enhance the node creation screen with multi-field text and image inputs, managed by a view model with addImage and inputContent commands.

Copy images from external storage into internal storage to avoid runtime permissions and data loss. Implement ImageFileManager using suspend functions, streams, and context-based access to safely store and delete images.

Process content for storage by saving new images to internal storage, keep text unchanged, and remove old images using dependence injection with an image file manager.

Explore gradients using brushes to create vertical, horizontal, linear, and radial effects, with tail modes and transparency. Then learn to localize apps by moving strings to resources and supporting locales.

Explore database normalization and denormalization in a notes app, replacing a JSON content field with a separate content elements table linked by note id to optimize search.

Learn database normalization by linking notes and content with ContentItemDBModel, composite keys, and cascade delete; map notes with content using embedded and relational annotations, and implement multi-table search.

Use room transactions and the transaction annotation to atomically add a node and its content, rolling back if any step fails to avoid partial data across nodes and content tables.

Explore a news app demo where you subscribe to topics, read and share articles, and apply filters. Configure background updates, notifications, and settings with datastore and Retrofit.

Define the domain layer with an article entity and a news repository, exposing flows for subscriptions and articles, and implement Room storage with tables, a composite key, and cascade deletes.

Explore making endpoint requests to a public api and parsing JSON into DTO classes using kotlinx serialization. Manage api keys, query parameters like q, and nulls with defaults.

Implement the repository by wiring the API service to the database, mapping server responses to database models, handling errors, and loading articles in parallel for subscriptions with flows.

Build the SubscriptionScreen with scaffold and a lazy column to display subscriptions and articles, and handle refresh, clear, and settings actions via vModel and callbacks.

Explore how Android components (Activity, Services, Broadcast Receivers, and Content Providers) work with WorkManager to enable periodic background updates even when the app is closed.

Learn to integrate WorkManager with Hilt and KSP, implement a RefreshDataWorker using coroutines, and schedule a 15-minute periodic task with enqueueUniquePeriodicWork and periodicWorkRequestBuilder.

Implement a datastore-based repository for settings, bind it for dependency injection, and read and write settings via flows using key-value pairs with domain layer defaults.

Apply worker constraints using the AndroidX WorkManager builder to start periodic refresh only when relevant settings change. Convert settings to a refreshConfig and react with distinctUntilChanged to trigger updates.

Implement StartRefreshDataUseCase in the domain layer that uses NewsRepository and SettingsRepository to start periodic data refreshing, wired to AppStartupManager at application onCreate.

Create and show new articles notifications with a NotificationHelper and NotificationManager, including a channel, icons, and string resources. Handle API level checks and request post notifications permission.

Enable notifications for new articles by returning updated topics from the load use case and loading data in the user’s language via settings.

Design a reusable settings screen using card components and a parameterized exposed drop-down menu for language and interval selections.

Construct a navigation graph with a remember navController and NavHost, defining Subscriptions and Settings as routes and a start destination, enabling forward and back navigation.

Finish the Modern Android Development with Jetpack Compose course by mastering MVVM, clean architecture, Hilt, Room, Retrofit, Coil, and Datastore, plus navigation with Jetpack and Pulse.