Graduate Course Syllabus for Android

Grade: Graduate
Subject: Android Application Development (Legacy & Modern Systems)

Course Description:

This course provides an exhaustive, end-to-end study of Android application development, tracing the complete architectural evolution from legacy Android paradigms (Java, AsyncTask, Imperative XML Views, Support Fragments, SharedPreferences) to current modern Android standards (Kotlin, Jetpack Compose, Coroutines, Flow, Hilt, Room, DataStore, and Clean Architecture).

Course Outline:

Module 1: Programming Languages & Paradigms (Legacy Java & Modern Kotlin)

  • Modern Kotlin: Null safety (?, ?:, !!), immutability (val vs var), extension functions, scope functions (let, run, with, apply, also), delegation, sealed classes/interfaces, inline classes, DSLs

  • Legacy Java in Android: Java 7/8 syntax, anonymous inner classes, interfaces, getter/setter patterns, imperative thread management

  • Language Interoperability: Calling Java from Kotlin (@JvmStatic, @JvmOverloads, @JvmField), calling Kotlin from Java

Module 2: Android System Architecture & Runtime Evolution

  • Execution Runtimes: Dalvik Virtual Machine (DVM) vs Android Runtime (ART), Ahead-Of-Time (AOT) vs Just-In-Time (JIT) compilation, Profile-Guided Optimization (PGO)

  • Compilation Pipeline: Java/Kotlin code -> Bytecode -> DEX files (classes.dex) -> APK / AAB

  • Android OS Evolution: History from Android 1.0 (Cupcake, Donut) through key releases (KitKat, Lollipop, Marshmallow, Oreo, Android 10, to Android 14/15+)

  • Four Core Application Components: Activity, Service, BroadcastReceiver, ContentProvider

  • Application manifest (AndroidManifest.xml), process model, sandboxing, UID assignment

Module 3: Application Lifecycle, Process Management & Permissions

  • Activity Lifecycle: onCreate, onStart, onResume, onPause, onStop, onDestroy, onRestart

  • State Preservation: Process Death, onSaveInstanceState, SavedStateHandle, ViewModel persistence

  • Application & Process Lifecycle: Application class, onTrimMemory, Low Memory Killer (LMK)

  • Permissions Model: Install-time permissions, Runtime permissions (Android 6.0+), Scoped Storage permissions, Granular Media Permissions (Android 13+)

Module 4: Modern Declarative UI with Jetpack Compose

  • Compose Mental Model: Declarative vs Imperative UI, Recomposition triggers, State Hoisting

  • Core Composables: Text, Button, TextField, Image, Icon, Card, Surface

  • Layout Managers: Column, Row, Box, LazyColumn, LazyRow, LazyVerticalGrid, LazyHorizontalGrid, ConstraintLayout in Compose

  • State Management: remember, rememberSaveable, mutableStateOf, derivedStateOf, CompositionLocal

  • Side-Effect Handlers: LaunchedEffect, SideEffect, DisposableEffect, rememberCoroutineScope, snapshotFlow

  • Material Design 3 (M3): Dynamic Color (Monet), Light/Dark themes, Typography, Shapes, Adaptive layouts for foldable/large screens

Module 5: Legacy View System & Imperative XML Layouts (Previous Android)

  • XML Layout Managers: LinearLayout, RelativeLayout, FrameLayout, ConstraintLayout, TableLayout, ScrollView

  • UI Widgets: TextView, EditText, ImageView, Button, CheckBox, RadioButton, Spinner, ProgressBar

  • Collection Views: Legacy ListView / GridView with BaseAdapter vs RecyclerView (ViewHolder pattern, LayoutManager, DiffUtil, ItemDecoration, ItemTouchHelper)

  • Legacy Component Architecture: Fragment, FragmentManager, FragmentTransaction, Support Library / AndroidX migration

  • View Customization: Extending View / ViewGroup, custom attributes (attrs.xml), lifecycle hooks (onMeasure, onLayout, onDraw), Canvas, Paint, Path

  • View Binding and Legacy Data Binding frameworks

Module 6: UI Interoperability & Animation Systems

  • Interoperability Bridge: Hosting Compose in View layouts via ComposeView, embedding legacy Views in Compose via AndroidView and AndroidViewBinding

  • Legacy Animation Frameworks: View Animations (AnimationUtils), Property Animations (ValueAnimator, ObjectAnimator, AnimatorSet), Transitions API, MotionLayout

  • Compose Animation APIs: AnimatedVisibility, animate*AsState, Crossfade, updateTransition, rememberInfiniteTransition

Module 7: Navigation & Deep Linking Architecture

  • Navigation Frameworks: Manual Fragment Transactions vs Jetpack Navigation Component

  • Jetpack Navigation: NavHost, NavController, NavGraph, SafeArgs plugin

  • Type-Safe Navigation in Jetpack Compose

  • Advanced Routing: Nested navigation graphs, Bottom Navigation Bar integration, Conditional navigation (Authentication flow), Deep Links (Implicit, Explicit, App Links)

Module 8: Architecture Patterns & State Holders

  • Architecture Guidelines: Presentation Layer, Domain Layer (Use Cases), Data Layer (Repositories, Data Sources)

  • Pattern Evolution: Model-View-Controller (MVC), Model-View-Presenter (MVP), Model-View-ViewModel (MVVM), Model-View-Intent (MVI)

  • Architecture Components: ViewModel, LifecycleOwner, LifecycleObserver, repeatOnLifecycle

  • Reactive State Stream Evolution: LiveData vs StateFlow vs SharedFlow vs Legacy RxJava (Observable, Single, Completable)

Module 9: Asynchronous Programming, Concurrency & Streams

  • Kotlin Coroutines: Builders (launch, async, runBlocking), Dispatchers (Main, IO, Default, Unconfined), Job hierarchy, SupervisorJob

  • Structured Concurrency: Cancellation propagation, Exception handling (CoroutineExceptionHandler, supervisorScope)

  • Reactive Data Streams with Kotlin Flow: Cold streams, Hot streams (stateIn, sharedIn), Operators (map, filter, flatMapLatest, zip, combine, catch)

  • Legacy Concurrency Mechanisms: AsyncTask (Deprecated), Handler, Looper, HandlerThread, Java Executors, ThreadPoolExecutor

Module 10: Dependency Injection (DI)

  • Principles: Inversion of Control (IoC), Dependency Inversion Principle, Manual Dependency Injection vs Automated Frameworks

  • Modern Injection: Hilt (Built on Dagger 2): @HiltAndroidApp, @AndroidEntryPoint, Modules (@Module, @InstallIn), Scopes (@Singleton, @ActivityRetainedScoped, @ViewModelScoped), @Inject, @Binds, @Provides

  • Legacy / Low-level Injection: Pure Dagger 2 (Components, Subcomponents, Scope annotations)

  • Alternative Frameworks: Service Locators, Koin

Module 11: Networking, API Integration & Serialization

  • Protocols & Transport: HTTP/HTTPS, RESTful APIs, WebSockets, gRPC

  • Networking Clients: Retrofit 2, Ktor Client, OkHttp (Interceptors, Logging, Caching, Certificate Pinning)

  • Data Serialization: Kotlinx Serialization, Moshi, Legacy Gson, XML Parsers

  • Image Loading Frameworks: Coil (Kotlin-first), Glide, Picasso (Legacy)

Module 12: Data Storage, Persistence & Offline-First Architecture

  • Modern Key-Value Storage: Jetpack DataStore (Preferences DataStore, Proto DataStore with Protocol Buffers)

  • Legacy Key-Value Storage: SharedPreferences

  • Relational Database Persistence: Room Persistence Library (Entities, DAOs, Database instances, TypeConverters, Schema Migrations, AutoMigrations)

  • Legacy Relational Storage: Raw SQLite Databases (SQLiteOpenHelper), SQLite Cursors, Content Providers

  • Persistence Strategies: Offline-first architecture, Repository pattern, Single Source of Truth (SSOT)

Module 13: Background Processing, Work Scheduling & Notifications

  • Modern Background Processing: Jetpack WorkManager (One-Time Work, Periodic Work, Work Constraints, Task Chaining, Expedited Jobs)

  • Services Architecture: Foreground Services, Notification Channels, Foreground Service Types (Media, Location, Data Sync)

  • Notification System: NotificationManager, Channels, Groups, Custom Layouts, Push Notifications via Firebase Cloud Messaging (FCM)

  • Legacy Background Processing: Background Services, IntentService (Deprecated), JobScheduler, AlarmManager (Exact vs Inexact Alarms), BroadcastReceiver

Module 14: Hardware Access, Sensors & Location

  • Location APIs: Fused Location Provider API, Geofencing, Location Request strategies, Background location access

  • Camera Integration: CameraX API (Use cases: Preview, Image Capture, Image Analysis, Video Capture) vs Legacy Camera2 API

  • Device Sensors: SensorManager, Accelerometer, Gyroscope, Magnetometer

  • Wireless & Connectivity: Bluetooth Low Energy (BLE) Scanning & GATT, Near Field Communication (NFC), Wi-Fi Direct

Module 15: Security, Cryptography & Privacy Standards

  • Encryption: Android Keystore System, EncryptedSharedPreferences, EncryptedFile

  • Application Integrity & Protection: Code shrinking & Obfuscation (R8 / ProGuard), Resource Shrinking, Play Integrity API

  • Privacy Evolution: Scoped Storage, Photo Picker API, Runtime Permissions, Privacy Dashboard, Target SDK Enforcement

Module 16: Performance Optimization, Memory Management & Profiling

  • Profiling Tools: Android Studio Profiler (CPU Profiler, Memory Profiler, Network Profiler, Energy Profiler), System Trace, Perfetto

  • Memory Optimization: Garbage Collection mechanisms, Memory Leak detection with LeakCanary, avoiding static Context references

  • App Startup Optimization: App Startup Library, Baseline Profiles, Splash Screen API, Profile-Guided Optimization

Module 17: Testing & Quality Assurance

  • Unit Testing: JUnit 4 / JUnit 5, MockK, Mockito, Robolectric, Kotlinx Coroutines Test dispatchers (runTest, StandardTestDispatcher)

  • UI & Integration Testing: Compose Test Rule (createComposeRule), Espresso (onView, perform), UI Automator

  • Test Architectural Strategies: Test-Driven Development (TDD), Fakes vs Mocks, UI Component / Isolation Testing

Module 18: Build Tooling, App Distribution & Modern DevOps

  • Build Configuration: Gradle (build.gradle.kts vs legacy build.gradle), Version Catalogs (libs.versions.toml), Build Variants, Product Flavors, Build Types

  • App Packaging: APK vs Android App Bundle (AAB), Dynamic Delivery, Feature Modules

  • Signing & Release: Keystore generation, Play App Signing, v1/v2/v3/v4 Signing Schemes

  • Play Store Operations: Google Play Console (Internal, Alpha, Beta, Production tracks), In-App Billing (Google Play Billing Library), Crashlytics, Performance Monitoring