Android Development with Kotlin

You can write null-safe, functional Kotlin code using lambdas, data classes, and higher-order functions.

1. Kotlin basics: variables, types, None safety and operators120 min
   • val vs var
   • primitive types
   • Elvis operator ?:
   • safe calls ?
2. Control flow, functions and lambdas120 min
   • when expressions
   • named arguments
   • default parameters
   • lambda syntax
3. Collections and higher-order functions120 min
   • map
   • filter
   • reduce
   • immutable vs mutable lists
4. Object-oriented Kotlin: classes, data classes and objects120 min
   • primary constructors
   • data class componentN
   • object declarations
   • companion objects
5. Coroutines: the basics of asynchronous Kotlin120 min
   • suspend modifier
   • runBlocking
   • GlobalScope
   • delay function

Hands-on project: Build a CLI-based task management engine in Kotlin using sealed classes, collections, and higher-order filtering functions.

You can configure Android Studio, manage the app manifest, and handle activity lifecycles without memory leaks.

1. The Android platform and architecture120 min
   • Linux kernel layer
   • ART runtime
   • Application Framework
   • binder IPC
2. Setting up Android Studio, the SDK and emulators120 min
   • SDK Manager
   • AVD creation
   • Gradle sync
   • Logcat filtering
3. Your first app: project structure and the manifest120 min
   • AndroidManifest.xml
   • application tag
   • intent filters
   • res directory layout
4. Activities and the activity lifecycle120 min
   • onCreate
   • onStart
   • onResume
   • onPause
   • onStop
   • onDestroy
5. Logging, debugging and running on a device120 min
   • Log.d
   • Log.e
   • breakpoint debugging
   • Wireless Debugging over ADB

Hands-on project: Create a multi-activity logging utility that saves lifecycle state changes into local shared preferences.

You can build responsive, declarative user interfaces using Jetpack Compose composables, modifiers, and Material 3 design tokens.

1. Why Jetpack Compose: declarative UI on Android120 min
   • imperative vs declarative UI
   • Compose compiler
   • recomposition mechanics
   • State hoisting principle
2. Composable functions, state and recomposition120 min
   • @Composable annotation
   • remember
   • mutableStateOf
   • derivedStateOf
3. Layouts: Column, Row, Box and modifiers120 min
   • Modifier.padding
   • Modifier.fillMaxWidth
   • arrangement and alignment
   • BoxWithConstraints
4. Lists with LazyColumn and LazyRow120 min
   • LazyColumn
   • items key parameter
   • LazyRow
   • rememberLazyListState
5. Material Design 3 components and theming120 min
   • MaterialTheme
   • ColorScheme
   • Typography
   • Scaffold and TopAppBar

Hands-on project: Build a responsive profile screen dashboard using Column, Row, Box, custom Modifiers, and Material Design 3 color schemes.

You can wire up single-activity navigation flows, handle complex form inputs, and manage UI dialog state cleanly.

1. Navigation in Compose (Navigation Compose)120 min
   • NavHostController
   • NavHost
   • composable route strings
   • popBackStack
2. Passing data between screens120 min
   • navArgument types
   • SavedStateHandle
   • parcelable navigation arguments
   • deep links
3. Handling user input and forms120 min
   • OutlinedTextField
   • KeyboardActions
   • VisualTransformation
   • IME actions
4. State hoisting and managing UI state120 min
   • stateless composables
   • stateful wrappers
   • event callbacks
   • UI state immutability
5. Dialogs, bottom sheets and snackbars120 min
   • AlertDialog
   • ModalBottomSheet
   • SnackbarHostState
   • coroutine scope snackbars

Hands-on project: Build an e-commerce checkout flow with Navigation Compose, route parameters, form validation, and bottom sheet summaries.

You can architect maintainable apps using the MVVM pattern, ViewModels, StateFlow streams, and Hilt dependency injection.

1. App architecture and separation of concerns120 min
   • UI layer
   • domain layer
   • data layer
   • unidirectional data flow rules
2. ViewModel and its lifecycle120 min
   • ViewModelProvider
   • onCleared method
   • retained configuration changes
   • ViewModel scope
3. StateFlow, SharedFlow and LiveData120 min
   • MutableStateFlow
   • asStateFlow
   • shareIn operator
   • lifecycleScope.launchWhenStarted
4. The unidirectional data flow pattern120 min
   • UI events dispatch
   • ViewModel processing
   • state emission
   • stateless rendering
5. Dependency injection with Hilt120 min
   • @HiltAndroidApp
   • @AndroidEntryPoint
   • @Inject constructor
   • @Module and @Provides

Hands-on project: Refactor a monolithic weather app into clean MVVM architecture using Hilt modules, ViewModel, and StateFlow UI binding.

You can manage non-blocking asynchronous tasks and reactive data streams using Coroutine dispatchers and Kotlin Flow operators.

1. Coroutines in depth: scopes, dispatchers and jobs120 min
   • Dispatchers.IO
   • Dispatchers.Main
   • Dispatchers.Default
   • Job hierarchy
2. Suspending functions and structured concurrency120 min
   • supervisorScope
   • coroutineScope
   • async/await patterns
   • cancellation exceptions
3. Kotlin Flow for streams of data120 min
   • flow builder
   • emit function
   • cold streams
   • collect terminal operator
4. Combining, transforming and collecting flows120 min
   • map operator
   • filter operator
   • combine
   • zip
   • stateIn / shareIn
5. Error handling and cancellation120 min
   • catch operator
   • retryWhen
   • nonCancellable block
   • ensureActive

Hands-on project: Implement a real-time stock price ticker feed using cold Flows, state management operators, and structured coroutine scopes.

You can consume RESTful web services with Retrofit and Moshi, handling loading errors and JSON parsing safely.

1. HTTP and REST fundamentals120 min
   • GET/POST/PUT/DELETE methods
   • status codes
   • headers
   • query parameters
2. Retrofit and OkHttp120 min
   • Retrofit.Builder
   • OkHttpClient setup
   • HttpLoggingInterceptor
   • custom headers interceptor
3. JSON parsing with Moshi or Gson120 min
   • @JsonClass
   • @Json annotation
   • MoshiConverterFactory
   • adapter configuration
4. Calling APIs from a ViewModel with coroutines120 min
   • viewModelScope.launch
   • try-catch blocks
   • Result wrapper sealed class
   • network dispatchers
5. Loading, error and empty states120 min
   • CircularProgressIndicator
   • retry button triggers
   • empty state placeholders
   • error banner UI

Hands-on project: Build a GitHub repository search client using Retrofit, OkHttp logging interceptors, Moshi parsing, and robust error state handling.

You can persist structured relational data locally using Room databases and lightweight preferences using Jetpack DataStore.

1. The Room persistence library (SQLite)120 min
   • @Entity definition
   • @Dao interface
   • RoomDatabase builder
   • type converters
2. Entities, DAOs and the database120 min
   • @Insert(onConflict)
   • @Query statements
   • Flow return types for reactive queries
   • transactions
3. Queries, relationships and migrations120 min
   • @Relation
   • @Embedded
   • Migration strategies
   • fallbackToDestructiveMigration
4. DataStore and SharedPreferences120 min
   • Preferences DataStore
   • Proto DataStore
   • key-value pairs
   • asFlow reactive reads
5. Offline-first and caching patterns120 min
   • single source of truth
   • cache invalidation
   • network bound resource pattern
   • optimistic updates

Hands-on project: Implement an offline-first note-taking app that synchronizes local Room SQLite storage with remote API mutations via a repository layer.

You can integrate Firebase Authentication, Cloud Firestore real-time databases, and Cloud Messaging push alerts.

1. Adding Firebase to an Android app120 min
   • google-services.json setup
   • Firebase BoM dependency
   • Firebase initialization
   • crashlytics configuration
2. Authentication: email, Google and phone120 min
   • FirebaseAuth instance
   • createUserWithEmailAndPassword
   • Google Sign-In Credential Manager
   • authStateListener
3. Cloud Firestore: real-time data120 min
   • collection references
   • document snapshots
   • addSnapshotListener
   • firestore security rules
4. Cloud Storage for files and images120 min
   • FirebaseStorage reference
   • putFile upload task
   • downloadUrl retrieval
   • progress listeners
5. Push notifications with Firebase Cloud Messaging120 min
   • FirebaseMessagingService
   • onNewToken
   • onMessageReceived
   • NotificationCompat builder

Hands-on project: Build a real-time group chat application featuring Google Sign-In authentication, Cloud Firestore streams, and FCM push notifications.

You can request runtime permissions, capture camera images, fetch location data, and schedule deferrable background tasks.

1. Runtime permissions120 min
   • ActivityCompat.requestPermissions
   • shouldShowRequestPermissionRationale
   • Accompanist permissions library
   • ActivityResultContracts
2. Camera, gallery and image handling120 min
   • CameraX provider
   • ImageCapture use case
   • PhotoPicker API
   • Coil image loading library
3. Location and maps120 min
   • FusedLocationProviderClient
   • location request settings
   • Geocoding API
   • Google Maps Compose integration
4. Background work with WorkManager120 min
   • Worker class
   • CoroutineWorker
   • Constraints (NetworkType, Charging)
   • OneTimeWorkRequest
5. Notifications and app widgets overview120 min
   • NotificationChannels
   • importance levels
   • Glance for App Widgets
   • pending intents

Hands-on project: Build a field inspection app that captures geo-tagged photos, handles runtime permissions gracefully, and syncs uploads via WorkManager.

You can write unit and UI tests, profile memory leaks, optimize app bundles, and publish signed releases to Google Play.

1. Unit testing and UI testing with Compose120 min
   • JUnit5 framework
   • MockK mocking library
   • StandardTestDispatcher
   • ComposeTestRule
2. App architecture best practices and clean code120 min
   • SOLID principles in mobile
   • repository pattern abstraction
   • modularization strategies
   • lint checks
3. Performance, profiling and app size120 min
   • Android Studio Profiler
   • LeakCanary memory leak detector
   • R8 shrinking and obfuscation
   • App Bundle split APKs
4. Building a signed release (App Bundle)120 min
   • keystore generation
   • signing configs in build.gradle.kts
   • bundletool usage
   • release variant optimization
5. Publishing to the Google Play Store120 min
   • Google Play Console setup
   • store listing graphics
   • internal testing tracks
   • app review compliance guidelines

Hands-on project: Write JUnit viewmodel tests, Compose UI tests with createComposeRule, and generate a signed production App Bundle release.

You can ship an Android app that protects user data and passes Play's data-safety review.

1. Storing data safely on device90 min
   • EncryptedSharedPreferences
   • Keystore-backed keys
   • Why SharedPreferences leaks
2. Securing network traffic90 min
   • Network security config
   • Certificate pinning
   • Detecting MITM in testing
3. Secrets and reverse engineering90 min
   • Keys out of source
   • R8 and obfuscation
   • What an APK reveals
4. Permissions and Play policy90 min
   • Runtime permission rationale
   • Scoped storage
   • Data Safety form accuracy

Hands-on project: Harden the capstone app: move secrets out of the APK, encrypt local storage with EncryptedSharedPreferences, pin the API certificate, audit every runtime permission, and complete an accurate Data Safety declaration.

You can design, build, test, and publish a fully featured native Android capstone application to production standards.

1. Plan and design a full-featured native app120 min
   • product requirement document
   • wireframing user flows
   • data schema design
   • architecture blueprinting
2. Build it: Compose UI, MVVM, APIs, Room and Firebase120 min
   • modular feature integration
   • repository data sync wiring
   • Compose screen assembly
   • dependency injection graph setup
3. Add device features, background work and polish120 min
   • camera and location triggers
   • WorkManager sync scheduling
   • animation polish
   • error handling hardening
4. Test and publish to Google Play120 min
   • instrumented UI test execution
   • signed AAB packaging
   • Play Console submission
   • production release monitoring
5. Portfolio, GitHub, mock interviews and career prep120 min
   • GitHub repository README documentation
   • Android interview question prep
   • resume positioning
   • mock technical interview simulation

Hands-on project: Build and publish a production-grade native Android app integrating Jetpack Compose, MVVM, Retrofit, Room, Firebase, and full automated testing.