thebushidocollective Android - Architecture
Modern Android architecture patterns following Google's recommended practices.
Key Concepts
MVVM Architecture
Model-View-ViewModel separates UI from business logic:
// UI State
data class UserUiState(
val user: User? = null,
val isLoading: Boolean = false,
val error: String? = null
)
// ViewModel
class UserViewModel(
private val userRepository: UserRepository
) : ViewModel() {
private val _uiState = MutableStateFlow(UserUiState())
val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
fun loadUser(userId: String) {
viewModelScope.launch {
_uiState.update { it.copy(isLoading = true, error = null) }
userRepository.getUser(userId)
.onSuccess { user ->
_uiState.update { it.copy(user = user, isLoading = false) }
}
.onFailure { error ->
_uiState.update { it.copy(error = error.message, isLoading = false) }
}
}
}
}
// Composable
@Composable
fun UserScreen(viewModel: UserViewModel = hiltViewModel()) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
when {
uiState.isLoading -> LoadingIndicator()
uiState.error != null -> ErrorMessage(uiState.error!!)
uiState.user != null -> UserContent(uiState.user!!)
}
}
Clean Architecture Layers
app/
├── data/
│ ├── local/ # Room database, DataStore
│ │ ├── dao/
│ │ └── entities/
│ ├── remote/ # Retrofit, network
│ │ ├── api/
│ │ └── dto/
│ └── repository/ # Repository implementations
├── domain/
│ ├── model/ # Domain models
│ ├── repository/ # Repository interfaces
│ └── usecase/ # Business logic
└── presentation/
├── ui/ # Composables
└── viewmodel/ # ViewModels
Repository Pattern
// Domain layer - interface
interface UserRepository {
fun getUser(id: String): Flow<User>
suspend fun saveUser(user: User): Result<Unit>
suspend fun deleteUser(id: String): Result<Unit>
}
// Data layer - implementation
class UserRepositoryImpl(
private val userApi: UserApi,
private val userDao: UserDao
) : UserRepository {
override fun getUser(id: String): Flow<User> = flow {
// Emit cached data first
userDao.getUser(id)?.let { emit(it.toDomain()) }
// Fetch fresh data
try {
val remoteUser = userApi.getUser(id)
userDao.insertUser(remoteUser.toEntity())
emit(remoteUser.toDomain())
} catch (e: Exception) {
// Network error, cached data already emitted
}
}
override suspend fun saveUser(user: User): Result<Unit> = runCatching {
userApi.updateUser(user.toDto())
userDao.insertUser(user.toEntity())
}
}
Best Practices
Dependency Injection with Hilt
// Module definition
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
@Provides
@Singleton
fun provideRetrofit(): Retrofit {
return Retrofit.Builder()
.baseUrl(BuildConfig.API_BASE_URL)
.addConverterFactory(MoshiConverterFactory.create())
.build()
}
@Provides
@Singleton
fun provideUserApi(retrofit: Retrofit): UserApi {
return retrofit.create(UserApi::class.java)
}
}
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
@Binds
@Singleton
abstract fun bindUserRepository(impl: UserRepositoryImpl): UserRepository
}
// ViewModel injection
@HiltViewModel
class UserViewModel @Inject constructor(
private val getUserUseCase: GetUserUseCase,
private val savedStateHandle: SavedStateHandle
) : ViewModel() {
private val userId: String = savedStateHandle.get<String>("userId")
?: throw IllegalArgumentException("userId required")
// ViewModel implementation
}
Use Cases for Business Logic
class GetUserUseCase @Inject constructor(
private val userRepository: UserRepository,
private val analyticsTracker: AnalyticsTracker
) {
operator fun invoke(userId: String): Flow<Result<User>> = flow {
emit(Result.Loading)
userRepository.getUser(userId)
.catch { e ->
analyticsTracker.trackError("get_user_failed", e)
emit(Result.Error(e))
}
.collect { user ->
emit(Result.Success(user))
}
}
}
// Sealed class for results
sealed class Result<out T> {
data class Success<T>(val data: T) : Result<T>()
data class Error(val exception: Throwable) : Result<Nothing>()
object Loading : Result<Nothing>()
}
Room Database Setup
@Entity(tableName = "users")
data class UserEntity(
@PrimaryKey val id: String,
val name: String,
val email: String,
@ColumnInfo(name = "created_at") val createdAt: Long
)
@Dao
interface UserDao {
@Query("SELECT * FROM users WHERE id = :id")
suspend fun getUser(id: String): UserEntity?
@Query("SELECT * FROM users ORDER BY name ASC")
fun getAllUsers(): Flow<List<UserEntity>>
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertUser(user: UserEntity)
@Delete
suspend fun deleteUser(user: UserEntity)
}
@Database(entities = [UserEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
abstract fun userDao(): UserDao
}
// Hilt module
@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
@Provides
@Singleton
fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
return Room.databaseBuilder(
context,
AppDatabase::class.java,
"app_database"
).build()
}
@Provides
fun provideUserDao(database: AppDatabase): UserDao {
return database.userDao()
}
}
Data Mapping
// DTO (Data Transfer Object) - from API
data class UserDto(
@Json(name = "id") val id: String,
@Json(name = "full_name") val fullName: String,
@Json(name = "email_address") val email: String
)
// Entity - for Room
@Entity(tableName = "users")
data class UserEntity(
@PrimaryKey val id: String,
val name: String,
val email: String
)
// Domain model
data class User(
val id: String,
val name: String,
val email: String
)
// Mappers
fun UserDto.toEntity() = UserEntity(
id = id,
name = fullName,
email = email
)
fun UserDto.toDomain() = User(
id = id,
name = fullName,
email = email
)
fun UserEntity.toDomain() = User(
id = id,
name = name,
email = email
)
fun User.toEntity() = UserEntity(
id = id,
name = name,
email = email
)
Common Patterns
Single Source of Truth
class OfflineFirstRepository @Inject constructor(
private val api: ItemApi,
private val dao: ItemDao
) : ItemRepository {
override fun getItems(): Flow<List<Item>> {
return dao.getAllItems()
.map { entities -> entities.map { it.toDomain() } }
.onStart {
// Refresh from network in background
refreshItems()
}
}
private suspend fun refreshItems() {
try {
val remoteItems = api.getItems()
dao.deleteAll()
dao.insertAll(remoteItems.map { it.toEntity() })
} catch (e: Exception) {
// Log error, local data still available
}
}
}
Navigation with Type-Safe Args
// Define routes
sealed class Screen(val route: String) {
object Home : Screen("home")
object Detail : Screen("detail/{itemId}") {
fun createRoute(itemId: String) = "detail/$itemId"
}
object Settings : Screen("settings")
}
// Navigation setup
@Composable
fun AppNavigation(navController: NavHostController) {
NavHost(navController = navController, startDestination = Screen.Home.route) {
composable(Screen.Home.route) {
HomeScreen(
itemId ->
navController.navigate(Screen.Detail.createRoute(itemId))
}
)
}
composable(
route = Screen.Detail.route,
arguments = listOf(navArgument("itemId") { type = NavType.StringType })
) { backStackEntry ->
DetailScreen(
itemId = backStackEntry.arguments?.getString("itemId") ?: return@composable
)
}
}
}
Error Handling
sealed class UiState<out T> {
object Loading : UiState<Nothing>()
data class Success<T>(val data: T) : UiState<T>()
data class Error(val message: String, val retry: (() -> Unit)? = null) : UiState<Nothing>()
}
@Composable
fun <T> StateHandler(
state: UiState<T>,
onRetry: () -> Unit = {},
content: @Composable (T) -> Unit
) {
when (state) {
is UiState.Loading -> {
Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
CircularProgressIndicator()
}
}
is UiState.Error -> {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Text(state.message)
Spacer(modifier = Modifier.height(16.dp))
Button(onClick = onRetry) {
Text("Retry")
}
}
}
is UiState.Success -> content(state.data)
}
}
Anti-Patterns
God Activity/Fragment
Bad: All logic in one Activity.
Good: Use MVVM with clear separation of concerns.
Network Calls in ViewModel
Bad:
class BadViewModel : ViewModel() {
fun loadData() {
val client = OkHttpClient() // Direct network dependency
// ...
}
}
Good: Inject repository through constructor.
Exposing Mutable State
Bad:
class BadViewModel : ViewModel() {
val uiState = MutableStateFlow(UiState()) // Mutable exposed!
}
Good:
class GoodViewModel : ViewModel() {
private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow<UiState> = _uiState.asStateFlow()
}
Related Skills
- android-jetpack-compose: UI layer patterns
- android-kotlin-coroutines: Async operations