Entwicklung / IDE & Tools / Android Praxis-Handbuch
Android Development – Das Praxis-Handbuch & Jetpack-Leitfaden
Android Development umfasst das Design, die Entwicklung, die Architektur und die Veröffentlichung mobiler Anwendungen auf dem weltgrößten mobilen Betriebssystem. Die moderne Android-Entwicklung setzt primär auf Kotlin, Jetpack Compose (deklarative Benutzeroberflächen), Coroutines & Flow, die MVVM/MVI-Architektur, Hilt (Dependency Injection) und Room (lokale Datenbank-Persistenz).
Dieses Handbuch bietet einen praxisnahen Überblick über die 4 Android-Kernkomponenten (Activity, Service, BroadcastReceiver, ContentProvider), den Activity Lifecycle, Jetpack Compose, MVVM-Architektur, Retrofit-Netzwerk-Abfragen, Local Storage, Testing und Google Play Store Deployment.
🚀 1. Android Kernkomponenten & Lifecycle
Die 4 Kernbausteine (App Components)
- Activity: Die visuelle Benutzeroberfläche und Einstiegspunkt für den Nutzer.
- Service: Führt langwierige Operationen im Hintergrund aus (z. B. Musikwiedergabe, Standort-Tracking), ohne ein UI anzuzeigen.
- Broadcast Receiver: Empfängt systemweite Benachrichtigungen (z. B. Akku schwach, Flugmodus aktiviert, System-Reboot).
- Content Provider: Verwalte und teile strukturierte Anwendungsdaten sicher mit anderen Apps (z. B. Kontakte, MediaStore).
Der Activity Lifecycle
Der Android-Manager durchläuft während der App-Nutzung strikte Lebenszyklus-Zustände:
onCreate(): Initialisierung der Views, ViewModels und Dependency Injection.onResume(): Die App ist interaktiv und für den Nutzer sichtbar.onPause()/onStop(): Freigabe teurer Ressourcen (z. B. Kamera, Sensoren), um Akku zu sparen.
🎨 2. Deklarative UIs mit Jetpack Compose
Jetpack Compose ist das moderne, von Google empfohlene Toolkit zur Erstellung nativer Android-Benutzeroberflächen in reiner Kotlin-Syntax (ersetzt alte XML-Layouts).
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun UserProfileCard(username: String, onFollowClick: () -> Unit) {
var isFollowing by remember { mutableStateOf(false) }
Card(
modifier = Modifier.fillMaxWidth().padding(16.dp),
elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
) {
Column(modifier = Modifier.padding(16.dp)) {
Text(text = username, style = MaterialTheme.typography.headlineMedium)
Spacer(modifier = Modifier.height(8.dp))
Button(onClick = {
isFollowing = !isFollowing
onFollowClick()
}) {
Text(if (isFollowing) "Folge ich" else "Folgen")
}
}
}
}
🏛️ 3. Architektur: MVVM, Hilt & StateFlow
Google empfiehlt eine klare Layer-Architektur mit Unidirectional Data Flow (UDF):
1. ViewModel & StateFlow
Das ViewModel überlebt Konfigurationsänderungen (wie Bildschirm-Rotationen) und verwaltet den UI-Zustand via StateFlow:
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
sealed interface UiState {
object Loading : UiState
data class Success(val items: List<String>) : UiState
data class Error(val msg: String) : UiState
}
class MainViewModel(private val repository: DataRepository) : ViewModel() {
private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
val uiState: StateFlow<UiState> = _uiState.asStateFlow()
init {
loadData()
}
private fun loadData() {
viewModelScope.launch {
try {
val data = repository.fetchRemoteData()
_uiState.value = UiState.Success(data)
} catch (e: Exception) {
_uiState.value = UiState.Error(e.message ?: "Fehler")
}
}
}
}
2. Dependency Injection mit Hilt
Hilt injiziert Abhängigkeiten (Repositories, DBs, APIs) typsicher zur Kompilierzeit:
@HiltViewModel
class NewsViewModel @Inject constructor(
private val newsRepository: NewsRepository
) : ViewModel() { ... }
💾 4. Datenspeicherung & Netzwerk
Local Persistence: Room Database
Room bietet eine typsichere Abstraktion über SQLite mit SQL-Validierung beim Kompilieren:
@Entity(tableName = "users")
data class UserEntity(
@PrimaryKey(autoGenerate = true) val id: Int = 0,
val name: String
)
@Dao
interface UserDao {
@Query("SELECT * FROM users ORDER BY name ASC")
fun getAllUsers(): Flow<List<UserEntity>>
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertUser(user: UserEntity)
}
Remote Network: Retrofit 2 & OkHttp
Netzwerkabfragen mit Kotlin Coroutines:
interface ApiService {
@GET("users/{id}")
suspend fun getUserById(@Path("id") userId: Int): UserResponse
}
🧪 5. Testing, Debugging & Performance
- Unit Testing (JUnit 5 & MockK): Testen von Repositories und ViewModels in Isolation.
- UI Testing (Espresso & Compose Test Rule): Automatisierte Integrationstests der Compose-UI.
- LeakCanary: Erkennt und meldet automatisch Memory Leaks (Arbeitsspeicher-Löcher) zur Entwicklungszeit.
- Chucker: Zeigt HTTP-Netzwerk-Requests und -Responses direkt als System-Benachrichtigung im Handy an.
📦 6. Deployment & Google Play Store
- Android App Bundle (AAB): Generieren des optimierten
.aab-Formats für den Play Store (./gradlew bundleRelease). - App Signing: Signieren der Anwendung mit einem sicheren Keystore.
- Google Play Console: Hochladen des AAB, Verfassen des Store-Eintrags, Screenshots & Veröffentlichung in Staging- oder Production-Tracks.