Android Development Career Options for Students in Noida

// ProfileScreen.kt — a Jetpack Compose screen from a real app
// This is what an Android interview actually tests in 2026.

package com.example.app.ui.profile

import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel

@Composable
fun ProfileScreen(
    userId: String,
    viewModel: ProfileViewModel = viewModel(),
    onEditClick: () -> Unit = {},
) {
    val state by viewModel.state.collectAsState()

    when (val s = state) {
        is ProfileState.Loading -> {
            Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                CircularProgressIndicator()
            }
        }
        is ProfileState.Error -> {
            Column(
                Modifier.fillMaxSize().padding(24.dp),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.Center,
            ) {
                Text("Could not load profile", style = MaterialTheme.typography.titleMedium)
                Text(s.message, style = MaterialTheme.typography.bodySmall)
                Spacer(Modifier.height(12.dp))
                Button(onClick = { viewModel.retry(userId) }) { Text("Retry") }
            }
        }
        is ProfileState.Success -> {
            ProfileContent(
                user = s.user,
                onEditClick = onEditClick,
            )
        }
    }
}

@Composable
private fun ProfileContent(user: User, onEditClick: () -> Unit) {
    Column(
        Modifier
            .fillMaxSize()
            .padding(24.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Profile photo",
            modifier = Modifier
                .size(96.dp)
                .clip(CircleShape),
        )
        Spacer(Modifier.height(16.dp))
        Text(user.name, style = MaterialTheme.typography.headlineSmall)
        Text(user.email, style = MaterialTheme.typography.bodyMedium)
        Spacer(Modifier.height(24.dp))
        Button(onClick = onEditClick) { Text("Edit profile") }
    }
}

// What interviewers look for:
// - Sealed class for state (Loading / Error / Success) — no nullable soup
// - collectAsStateWithLifecycle or collectAsState (state flows correctly)
// - Separation of UI and ViewModel
// - Reusable composables (ProfileContent)
// - Loading and error states handled, not forgotten
// - AsyncImage for image loading (Coil), contentDescription for a11y
//
// This one screen, done cleanly with state handling, is worth
// more than 10 "hello world" apps on GitHub.

// ProfileViewModel.kt + Repository — real Android architecture
// Interviewers care about this more than UI code.

package com.example.app.ui.profile

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

sealed interface ProfileState {
    data object Loading : ProfileState
    data class Error(val message: String) : ProfileState
    data class Success(val user: User) : ProfileState
}

class ProfileViewModel(
    private val repository: UserRepository,
) : ViewModel() {

    private val _state = MutableStateFlow<ProfileState>(ProfileState.Loading)
    val state: StateFlow<ProfileState> = _state.asStateFlow()

    fun load(userId: String) {
        viewModelScope.launch {
            _state.value = ProfileState.Loading
            repository.getUser(userId)
                .onSuccess { _state.value = ProfileState.Success(it) }
                .onFailure { _state.value = ProfileState.Error(it.message ?: "Unknown error") }
        }
    }

    fun retry(userId: String) = load(userId)
}

// UserRepository.kt
class UserRepository(
    private val api: UserApi,
    private val dao: UserDao,
) {
    suspend fun getUser(userId: String): Result<User> = runCatching {
        // Try cache first (works offline)
        val cached = dao.getById(userId)
        if (cached != null) return@runCatching cached.toDomain()

        // Fetch from network
        val remote = api.getUser(userId)
        dao.upsert(remote.toEntity())
        remote.toDomain()
    }
}

// What interviewers look for:
// - Sealed interface for state
// - StateFlow (not LiveData — modern Android uses StateFlow)
// - Repository pattern (cache + network)
// - runCatching for clean error handling
// - viewModelScope for lifecycle-aware coroutines
// - Domain / entity separation (mapper pattern)
//
// Why this matters:
// - UI code is easy. Architecture is what makes an app
//   maintainable, testable, and reliable.
// - Most Android interviews test architecture, not just UI.
// - If you only know Compose but not ViewModel + Repository,
//   you cannot pass a mid-level interview.

# build.gradle.kts + release steps — how an Android app actually ships
# Every Android developer needs to know this end-to-end.

# --- app/build.gradle.kts (simplified) ---
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("com.google.dagger.hilt.android")
    id("kotlin-kapt")
}

android {
    namespace = "com.example.app"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.example.app"
        minSdk = 24
        targetSdk = 34
        versionCode = 42
        versionName = "2.1.0"

        // Environment-specific config
        buildConfigField("String", "API_BASE_URL", "\"https://api.example.com\"")
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("release")
        }
        debug {
            applicationIdSuffix = ".debug"
            isDebuggable = true
        }
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions { jvmTarget = "17" }
    buildFeatures { compose = true }
    composeOptions { kotlinCompilerExtensionVersion = "1.5.8" }
}

dependencies {
    implementation("androidx.compose.material3:material3:1.2.0")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0")
    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.7.0")
    implementation("com.google.dagger:hilt-android:2.50")
    implementation("io.coil-kt:coil-compose:2.5.0")
    implementation("androidx.room:room-runtime:2.6.1")
    implementation("androidx.room:room-ktx:2.6.1")
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.1.5")
}

# --- Release steps (via terminal, a skill interviewers ask about) ---
# 1. Generate a signed AAB (Play Store format)
./gradlew bundleRelease

# 2. The AAB is at: app/build/outputs/bundle/release/app-release.aab
# 3. Upload to Play Console (or via fastlane / GitHub Actions)
# 4. For testing: generate an APK
./gradlew assembleRelease

# 5. Play Store requires:
#    - Signed with an upload key (kept secret)
#    - Target SDK within 1 year of latest
#    - Data safety form
#    - Content rating
#    - Privacy policy

# What interviewers look for:
# - Understanding of buildTypes (debug vs release)
# - ProGuard/R8 minification knowledge
# - Signing and key management awareness
# - Play Store release process (AAB not APK now)
# - Reproducible builds (CI/CD awareness)
#
# Why this matters for Noida students:
# - Most college projects stop at `./gradlew installDebug`
# - Being able to say "I've published a real app" instantly
#   separates you from other freshers
# - A published app is a permanent portfolio piece — Play Store
#   link on your resume is worth more than five course certificates