Hi, I'm Ravi Sorathiya

@Composable
fun MediaFilterBar(
    selected: MediaType,
    onSelect: (MediaType) -> Unit,
    modifier: Modifier = Modifier,
) {
    Row(
        modifier.horizontalScroll(rememberScrollState()),
        horizontalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        MediaType.entries.forEach { type ->
            FilterChip(
                selected = type == selected,
                onClick = { onSelect(type) },
                label = { Text(type.label) },
            )
        }
    }
}

@Composable
fun GalleryScreen(vm: GalleryViewModel = hiltViewModel()) {
    val state by vm.state.collectAsStateWithLifecycle()
    MediaFilterBar(state.filter, onSelect = vm::setFilter)
    MediaGrid(state.visibleItems)
}

class AlbumsViewModel(
    repository: MediaRepository,
    settings: SettingsRepository,
) : ViewModel() {

    private val query = MutableStateFlow("")

    val state: StateFlow<AlbumsState> = combine(
        repository.albums(),
        settings.sortOrder,
        query.debounce(300),
    ) { albums, sort, q ->
        AlbumsState(
            albums = albums
                .filter { it.name.contains(q, ignoreCase = true) }
                .sortedWith(sort.comparator),
        )
    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), AlbumsState())

    fun onSearch(text: String) { query.value = text }
}

@HiltAndroidApp
class GalleryApp : Application()

@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
    @Binds @Singleton
    abstract fun bindMediaRepository(impl: MediaRepositoryImpl): MediaRepository
}

class MediaRepositoryImpl @Inject constructor(
    private val dao: MediaDao,
    @ApplicationContext private val context: Context,
) : MediaRepository { /* … */ }

@HiltViewModel
class AlbumsViewModel @Inject constructor(
    private val getAlbums: GetAlbumsUseCase,
) : ViewModel()

// :domain (pure Kotlin, no Android imports)
interface CallLogRepository {
    fun recentCalls(): Flow<List<Call>>
}

class GetRecentCallsUseCase(private val repo: CallLogRepository) {
    operator fun invoke(): Flow<List<CallGroup>> =
        repo.recentCalls().map { calls ->
            calls.groupBy { it.number to it.date.toLocalDate() }
                .map { (_, group) -> CallGroup(group) }
        }
}

// :data (Android + Room live here)
class CallLogRepositoryImpl(
    private val dao: CallLogDao,
) : CallLogRepository {
    override fun recentCalls() = dao.observeAll().map { rows -> rows.map { it.toDomain() } }
}

@Entity(tableName = "alarms")
data class AlarmEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val hour: Int,
    val minute: Int,
    val days: Set<DayOfWeek>,
    val enabled: Boolean = true,
)

@Dao
interface AlarmDao {
    @Query("SELECT * FROM alarms ORDER BY hour, minute")
    fun observeAll(): Flow<List<AlarmEntity>>

    @Upsert
    suspend fun upsert(alarm: AlarmEntity)

    @Query("UPDATE alarms SET enabled = :on WHERE id = :id")
    suspend fun setEnabled(id: Long, on: Boolean)
}

class TrashCleanupWorker(
    context: Context,
    params: WorkerParameters,
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        val cutoff = System.currentTimeMillis() - 30.days.inWholeMilliseconds
        runCatching { TrashStore.from(applicationContext).deleteOlderThan(cutoff) }
            .fold(onSuccess = { Result.success() }, onFailure = { Result.retry() })
    }
}

fun scheduleTrashCleanup(context: Context) {
    val request = PeriodicWorkRequestBuilder<TrashCleanupWorker>(1, TimeUnit.DAYS)
        .setConstraints(Constraints.Builder().setRequiresBatteryNotLow(true).build())
        .build()
    WorkManager.getInstance(context)
        .enqueueUniquePeriodicWork("trash-cleanup", ExistingPeriodicWorkPolicy.KEEP, request)
}

@Composable
fun VideoPlayer(uri: Uri, modifier: Modifier = Modifier) {
    val context = LocalContext.current
    val player = remember {
        ExoPlayer.Builder(context).build().apply {
            repeatMode = Player.REPEAT_MODE_ONE
            playWhenReady = true
        }
    }
    LaunchedEffect(uri) {
        player.setMediaItem(MediaItem.fromUri(uri))
        player.prepare()
    }
    DisposableEffect(Unit) {
        onDispose { player.release() }
    }
    AndroidView(
        factory = { PlayerView(it).apply { this.player = player } },
        modifier = modifier,
    )
}

val imageCapture = ImageCapture.Builder()
    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
    .build()

val preview = Preview.Builder().build().also {
    it.setSurfaceProvider(previewView.surfaceProvider)
}

cameraProvider.unbindAll()
val camera = cameraProvider.bindToLifecycle(
    lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, preview, imageCapture,
)

fun capturePage(onPage: (Bitmap) -> Unit) =
    imageCapture.takePicture(executor, object : ImageCapture.OnImageCapturedCallback() {
        override fun onCaptureSuccess(image: ImageProxy) {
            onPage(image.toBitmap())   // → edge detection → crop → PDF
            image.close()
        }
    })

@RunWith(AndroidJUnit4::class)
class BaselineProfileGenerator {
    @get:Rule val rule = BaselineProfileRule()

    @Test
    fun generate() = rule.collect(packageName = TARGET_PACKAGE) {
        pressHome()
        startActivityAndWait()             // cold-start path
        device.findObject(By.res("list")).scroll(Direction.DOWN, 2f)
    }
}

class StartupBenchmark {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test
    fun coldStart() = rule.measureRepeated(
        packageName = TARGET_PACKAGE,
        metrics = listOf(StartupTimingMetric()),
        compilationMode = CompilationMode.Partial(BaselineProfileMode.Require),
        iterations = 10,
        startupMode = StartupMode.COLD,
    ) { pressHome(); startActivityAndWait() }
}

// presentation/scanner/build.gradle.kts
plugins {
    alias(libs.plugins.android.library)
    alias(libs.plugins.kotlin.compose)
}

android {
    namespace = "app.scanner"
    compileSdk = libs.versions.compileSdk.get().toInt()
    buildFeatures { compose = true }
}

dependencies {
    implementation(project(":domain"))
    implementation(platform(libs.compose.bom))
    implementation(libs.bundles.camerax)
    implementation(libs.androidx.work.runtime)
    testImplementation(libs.junit)
}