Android Developer

app/
├── di/                          # Hilt modules
│   ├── AppModule.kt
│   ├── NetworkModule.kt
│   └── DatabaseModule.kt
├── data/
│   ├── local/
│   │   ├── dao/                 # Room DAOs
│   │   ├── entity/              # Room entities
│   │   └── AppDatabase.kt
│   ├── remote/
│   │   ├── api/                 # Retrofit interfaces
│   │   ├── dto/                 # Data transfer objects
│   │   └── interceptor/         # OkHttp interceptors
│   └── repository/              # Repository implementations
├── domain/
│   ├── model/                   # Business models
│   ├── repository/              # Repository interfaces
# ... (condensed) ...
│       ├── home/
│       │   ├── HomeScreen.kt
│       │   └── HomeViewModel.kt
│       ├── detail/
│       └── settings/
├── util/                        # Extension functions, helpers
└── MyApplication.kt             # @HiltAndroidApp

@Composable
fun ProductListScreen(
    viewModel: ProductListViewModel = hiltViewModel(),
    onProductClick: (String) -> Unit,
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Products") },
                actions = {
                    IconButton(onClick = viewModel::refresh) {
                        Icon(Icons.Default.Refresh, contentDescription = "Refresh")
                    }
                }
            )
        }
    # ... (condensed) ...
                    onRetry = viewModel::refresh,
                    modifier = Modifier.padding(padding)
                )
            }
        }
    }
}

@Composable
fun ProductCard(
    product: Product,
    onClick: () -> Unit,
    modifier: Modifier = Modifier,
) {
    Card(
        onClick = onClick,
        modifier = modifier.fillMaxWidth(),
        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
    ) {
        Row(
            modifier = Modifier.padding(16.dp),
            horizontalArrangement = Arrangement.spacedBy(12.dp),
        ) {
            AsyncImage(
                model = ImageRequest.Builder(LocalContext.current)
                    .data(product.imageUrl)
                    # ... (condensed) ...
                    style = MaterialTheme.typography.bodyLarge,
                    color = MaterialTheme.colorScheme.primary,
                )
            }
        }
    }
}

@HiltViewModel
class ProductListViewModel @Inject constructor(
    private val getProductsUseCase: GetProductsUseCase,
    private val savedStateHandle: SavedStateHandle,
) : ViewModel() {

    private val _uiState = MutableStateFlow<ProductUiState>(ProductUiState.Loading)
    val uiState: StateFlow<ProductUiState> = _uiState.asStateFlow()

    private val categoryId: String = savedStateHandle["categoryId"] ?: "all"

    init {
        loadProducts()
    }

    fun refresh() {
        loadProducts()
    }
# ... (condensed) ...
}

sealed interface ProductUiState {
    data object Loading : ProductUiState
    data class Success(val products: List<Product>) : ProductUiState
    data class Error(val message: String) : ProductUiState
}

// Entity
@Entity(tableName = "products")
data class ProductEntity(
    @PrimaryKey val id: String,
    val name: String,
    val description: String,
    val price: Double,
    @ColumnInfo(name = "image_url") val imageUrl: String?,
    @ColumnInfo(name = "category_id") val categoryId: String,
    @ColumnInfo(name = "updated_at") val updatedAt: Long = System.currentTimeMillis(),
)

// DAO
@Dao
interface ProductDao {
    @Query("SELECT * FROM products ORDER BY name ASC")
    fun observeAll(): Flow<List<ProductEntity>>

    # ... (condensed) ...
    exportSchema = true,
)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    abstract fun productDao(): ProductDao
    abstract fun categoryDao(): CategoryDao
}

// API interface
interface ProductApi {
    @GET("products")
    suspend fun getProducts(
        @Query("category") categoryId: String? = null,
        @Query("page") page: Int = 1,
        @Query("limit") limit: Int = 20,
    ): ApiResponse<List<ProductDto>>

    @GET("products/{id}")
    suspend fun getProduct(@Path("id") id: String): ApiResponse<ProductDto>

    @POST("products")
    suspend fun createProduct(@Body product: CreateProductRequest): ApiResponse<ProductDto>

    @Multipart
    @POST("products/{id}/image")
    suspend fun uploadImage(
        # ... (condensed) ...
        .build()

    @Provides
    @Singleton
    fun provideProductApi(retrofit: Retrofit): ProductApi =
        retrofit.create(ProductApi::class.java)
}

class ProductRepositoryImpl @Inject constructor(
    private val api: ProductApi,
    private val dao: ProductDao,
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO,
) : ProductRepository {

    supersede fun getProducts(categoryId: String): Flow<List<Product>> = flow {
        // Emit cached data first
        emitAll(
            dao.observeByCategory(categoryId).map { entities ->
                entities.map { it.toDomain() }
            }
        )
    }.onStart {
        // Trigger network refresh in background
        try {
            val response = withContext(dispatcher) {
                api.getProducts(categoryId)
            # ... (condensed) ...
            }.recoverCatching {
                // Fallback to cache
                dao.getById(id)?.toDomain()
                    ?: throw ProductNotFoundException(id)
            }
        }
}

@HiltWorker
class SyncWorker @AssistedInject constructor(
    @Assisted context: Context,
    @Assisted params: WorkerParameters,
    private val repository: ProductRepository,
) : CoroutineWorker(context, params) {

    supersede suspend fun doWork(): Result {
        return try {
            repository.syncPendingChanges()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) {
                Result.retry()
            } else {
                Result.failure(workDataOf("error" to e.message))
            }
        }
    # ... (condensed) ...
                "product_sync",
                ExistingPeriodicWorkPolicy.KEEP,
                request,
            )
        }
    }
}

// Routes
@Serializable data object Home
@Serializable data object Search
@Serializable data class ProductDetail(val productId: String)
@Serializable data class CategoryProducts(val categoryId: String, val title: String)

// NavHost
@Composable
fun AppNavigation(navController: NavHostController = rememberNavController()) {
    NavHost(navController = navController, startDestination = Home) {
        composable<Home> {
            HomeScreen(
                onProductClick = { id -> navController.navigate(ProductDetail(id)) },
                onCategoryClick = { id, title ->
                    navController.navigate(CategoryProducts(id, title))
                },
                onSearchClick = { navController.navigate(Search) },
            )
        # ... (condensed) ...
                title = args.title,
                onProductClick = { id -> navController.navigate(ProductDetail(id)) },
                onBack = { navController.popBackStack() },
            )
        }
    }
}

@HiltAndroidApp
class MyApplication : Application()

// App-level module
@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun provideAppDatabase(@ApplicationContext context: Context): AppDatabase =
        Room.databaseBuilder(context, AppDatabase::class.java, "myapp.db")
            .addMigrations(MIGRATION_2_3)
            .build()

    @Provides
    fun provideProductDao(db: AppDatabase): ProductDao = db.productDao()
}
# ... (condensed) ...
// Use case injection
class GetProductsUseCase @Inject constructor(
    private val repository: ProductRepository,
) {
    operator fun invoke(categoryId: String): Flow<List<Product>> =
        repository.getProducts(categoryId)
}

# proguard-rules.pro

# Keep data classes used with Moshi/Gson
-keep class com.myapp.data.remote.dto.** { *; }
-keep class com.myapp.data.local.entity.** { *; }

# Moshi
-keepclassmembers class * {
    @com.squareup.moshi.Json <fields>;
}
-keep @com.squareup.moshi.JsonQualifier @interface *

# Retrofit
-keepattributes Signature
-keepattributes Exceptions
-keepclassmembers,allowshrinking,allowobfuscation interface * {
    @retrofit2.http.* <methods>;
}
# ... (condensed) ...
-keepclassmembers class * implements android.os.Parcelable {
    public static final ** CREATOR;
}

# Debugging - keep source file names and line numbers
-keepattributes SourceFile,LineNumberTable
-renamesourcefileattribute SourceFile