Kotlin: Modern Android Development with Type Safety and Concurrency

Null Safety and Type System

Kotlin eliminates NullPointerException: all types non-nullable by default. var name: String = "John" (cannot be null). Nullable type: var name: String? = null (explicitly nullable). Null checks: if (name != null) { println(name.length) } (compiler tracks null state). Safe call: name?.length (returns null if name is null, otherwise length). Elvis operator: val length = name?.length ?: 0 (default value if null). Not-null assertion: name!!.length (throws exception if null, avoid). Type hierarchy: Any (root type), subtypes: String, Int, List, etc. No implicit conversions: cannot assign Int to String (prevents bugs). Sealed classes: restrict inheritance. sealed class Result { class Success(val data: String) : Result(), class Error(val exception: Exception) : Result() }. Pattern matching: when (result) { is Result.Success -> ..., is Result.Error -> ... } (compiler ensures all cases covered).

Extension Functions and Functional Programming

Extension functions add methods to existing classes. fun String.isEmail(): Boolean { return contains("@") }. Usage: "test@example.com".isEmail() (looks like built-in method). Receivers: function receives this context. fun List.average(): Double { return sumOf { it } / size.toDouble() }. Higher-order functions: pass functions as parameters. fun apply(x: Int, operation: (Int) -> Int): Int { return operation(x) }. Lambda syntax: apply(5, { it * 2 }) or apply(5) { it * 2 } (trailing lambda). Collections: map, filter, reduce use lambdas. Example: listOf(1, 2, 3).map { it * 2 }.filter { it > 2 }.forEach { println(it) } (chained operations). Inline functions: inline fun apply(x: T, f: (T) -> T): T = f(x). Compiler inlines function code (zero overhead for lambdas). Scoping functions: let, apply, with, run, also. Example: user.apply { name = "John"; age = 30 }.also { println(it) } (modifies, returns self).

Coroutines and Asynchronous Programming

Coroutines: lightweight threads (1000s of concurrent tasks). Suspend function: suspend fun fetchUser(id: Int): User (pauses execution, doesn't block thread). Launch scope: launch { val user = fetchUser(1) } (fire-and-forget). Async scope: val user = async { fetchUser(1) }.await() (wait for result). Main dispatcher: runs on main thread (UI updates). IO dispatcher: runs on thread pool (I/O operations). Example: viewModelScope.launch(Dispatchers.Main) { val data = withContext(Dispatchers.IO) { repository.fetchData() }; updateUI(data) }. Structured concurrency: coroutine scope ensures all child coroutines complete (prevents orphan tasks). Cancellation: job.cancel() (cancels scope, all child tasks). Timeout: withTimeoutOrNull(5000) { ... } (cancels if exceeds 5 seconds). Flow: reactive streams. flow { for (i in 1..10) { emit(i); delay(100) } } (emit values over time). Collect: flow.collect { value -> println(value) } (observe values).

Data Classes and Collections

Data classes: reduce boilerplate. data class User(val id: Int, val name: String, val email: String). Compiler generates: equals(), hashCode(), toString(), copy(). Example: user.copy(name = "Jane") (creates copy with changed fields). Destructuring: val (id, name, email) = user (extract fields). Collections: List (immutable), MutableList (mutable). mutableListOf(1, 2, 3) (growable). Sequence (lazy evaluation). listOf(1..1000).map { it * 2 } (eager, creates intermediate list). sequenceOf(1..1000).map { it * 2 } (lazy, maps on-demand). Maps: mapOf("name" to "John", "age" to 30). Pair: "name" to "John" (syntactic sugar for Pair("name", "John")). Ranges: 1..10 (inclusive), 1 until 10 (exclusive). Iteration: for (i in 1..10) { ... }. Destructuring in loops: pairs.forEach { (key, value) -> println("$key: $value") }.

Android-Specific Features

Android Jetpack: modern Android development. ViewModel: holds state across configuration changes (screen rotation). LiveData: observable data. userLiveData.observe(this) { user -> updateUI(user) } (updates UI when data changes). Room database: type-safe database layer. @Entity data class User(...), @Dao interface UserDao { @Query("SELECT * FROM users") suspend fun getUsers(): List }. Dependency injection: Hilt simplifies. @HiltViewModel, class UserViewModel @Inject constructor(val repo: UserRepository). Fragments: modular UI components. Fragment lifecycle: onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy. Navigation: NavController routes between fragments (declarative). Binding: ViewBinding generates type-safe views. binding.userNameText.text = "John" (no findViewById, type-checked). Compose: declarative UI framework. @Composable, fun UserProfile(user: User) { Column { Text(user.name); Text(user.email) } }. Hot reload: changes reflected instantly (faster development).

Performance and Optimization

Startup time: cold start ~5-10 seconds (ART JIT compilation). Warm start <1 second (already compiled). Hot start <100ms (stays in memory). Optimization: lazy initialization (defer expensive operations). by lazy { expensiveOperation() } (computed once, on first access). Build optimization: ProGuard/R8 shrink/obfuscate bytecode (app size 30-50% reduction). Multidex: if APK exceeds 64K methods (break into multiple DEX files). Memory: typical app ~100-500MB (varies by features). Profiler: Memory Profiler monitors (detect leaks). CPU Profiler (identify bottlenecks). Heap dumps: analyze object allocation. Image optimization: WebP format (smaller than PNG/JPEG). Caching: Room database, SharedPreferences (persistence). Networking: OkHttp (connection pooling, caching). Retrofit (HTTP client with coroutines support).

Testing and Quality Assurance

Unit tests: JUnit + Mockito. @Test, fun testUserEmail() { assertEquals(user.email, "test@example.com") }. Instrumented tests: AndroidX Test Framework. @Test, @RunWith(AndroidJUnit4::class), fun testUIUpdate(). ViewMatchers: Espresso automates UI testing. onView(withId(R.id.userName)).perform(click()).check(matches(isDisplayed())). Mocking: Mockito.mock(), Mockito.verify(). Snapshot testing: verify UI doesn't change unexpectedly. Code coverage: JaCoCo generates reports (target 70%+). Lint: Android Lint detects issues (compatibility, performance, security). ProGuard warnings: check mapping.txt (identifies real errors). Crash reporting: Firebase Crashlytics (prod monitoring). Analytics: Firebase Analytics (track user behavior).

Publishing and Deployment

App signing: generate keystore (private key signs APK). release build: signed APK (required for Google Play). Version management: versionCode (integer, incremented on each release), versionName (user-visible, "1.0.0"). App Bundle: Play Console optimizes app delivery (splits APK by device configuration). Staged rollout: release to 5% users first (monitor crashes). If stable, 25%, then 100%. Rollback: instant (revert to previous version if issues). Release notes: describe changes (shown in Play Store). Screenshots/videos: improve discoverability. A/B testing: Firebase Remote Config (feature flags). Versioning: Semantic versioning (major.minor.patch). Backward compatibility: older Android versions (minSdk, targetSdk settings). CI/CD: GitHub Actions (build, test, deploy on push). Firebase Test Lab: automated testing on real devices. Analytics: download trends, crash rates, user retention. Monetization: in-app purchases, ads (AdMob integration).

Kotlin Android
Kotlin Android