Android Camera Samples

Each sample is a Gradle library module located under samples/{api}-{feature}/ (package com.android.{api}.{feature}). Samples follow a layered, unidirectional pattern:

• {Feature}UiState: A sealed interface representing states like Initial, specific feature states, or Error.
• {Feature}ViewModel: A @HiltViewModel that exposes a single StateFlow<UiState>. It contains no Android or lifecycle references.
• {Feature}Controller: A @Stable state-holder that manages the camera SDK lifecycle. It is instantiated using remember{Feature}Controller(...).
• {Feature}Screen: A Composable that collects state using collectAsStateWithLifecycle, wraps the content in the shared scaffold, and renders the UI based on the current state using a when(state) block.

Lifecycle

• Do not override lifecycle methods like onResume in Activities or Fragments. Use LifecycleObserver or repeatOnLifecycle for lifecycle-dependent work.

Dependency Injection

• Use constructor injection as the primary method.
• Use Hilt for complex projects (multiple ViewModels, WorkManager, advanced Navigation) or manual DI for simpler apps.

To run the catalog, follow these steps:

1. Clone the repository.
2. Open the project in a recent version of Android Studio.
3. Run the app configuration on a physical device or an emulator.

Note: While emulators with a virtual camera can cover basic functionality, camera-dependent samples (such as Extensions, Slow Motion, or ML) perform best on a physical device. No Firebase or google-services.json is required.

To improve scalability and maintainability, use a layered architecture that promotes separation of concerns and follows Unidirectional Data Flow (UDF).

• Data Layer: Exposes application data and contains business logic. Always use a Repository to mediate between the UI and data sources (databases, network, etc.). UI components should never interact with data sources directly.
• UI Layer: Displays data and handles user interaction. In small apps, place these in a ui package or module.
• Domain Layer (Large Apps): Use use cases for reusable business logic across multiple ViewModels.
• Communication: Use Kotlin Coroutines and Flows for inter-layer communication.

Focus testing efforts on ViewModels (including Flows), data layer entities (repositories and data sources), and UI navigation for regression testing.

• Test Doubles: Prefer fakes over mocks.
• StateFlow Testing: Assert on the value property of StateFlows when possible. If using WhileSubscribed, create a collectJob to manage the collection during tests.

This sample is part of the Android AI Sample Catalog. To build and run the Gemini Multimodal Sample, you must clone the entire repository rather than just the sample directory.

Refer to the main repository's How to run instructions for specific build and execution steps.

The project uses Spotless (ktlint + Apache license headers) for code formatting. You should run the following command before committing any changes to ensure compliance with the project's code style.

./gradlew spotlessApply

Use lifecycle-aware state collection to ensure resources are managed correctly. In Jetpack Compose, use collectAsStateWithLifecycle(). You can then use a when expression to handle different states defined by a sealed class.

val uiState = viewModel.uiState.collectAsStateWithLifecycle()

when (uiState) {
    ScreenState.Initial -> {
      // Show initial state
    }

    ScreenState.Generating -> {
      // Show generating state
    }

    is ScreenState.Success -> {
      // Show success state
    }

    is ScreenState.Error -> {
      // Show error state
    }
}