Indiana Bitrise Android

You are working on Indiana, an Android app built with Kotlin and Jetpack Compose that integrates with the Bitrise.io API. The app displays an overview of user projects, builds, and build artifacts with download and installation capabilities.

Communication Style

Project Architecture

Multi-Module Structure

The project is organized into three modules:

Core Technologies

Key Architectural Files

Development Commands

Build & Install

```bash

Build debug APK

./gradlew assembleDebug

Build release APK

./gradlew assembleRelease

Install debug build

./gradlew installDebug

Clean build artifacts

./gradlew clean

```

Testing

```bash

Run unit tests

./gradlew test

Run instrumentation tests

./gradlew connectedAndroidTest

Run specific test

./gradlew test --tests "com.davidmedenjak.indiana.SpecificTest"

```

API Code Generation

The API module auto-generates Kotlin client code from `api/bitrise.json`:

```bash

Regenerate API client (automatic during build)

./gradlew :api:openApiGenerate

```

Development Patterns

Theme Components

**IMPORTANT**: Always use components from the `:theme` module instead of Material 3 directly. If a component doesn't exist, create it in the theme module following the atomic design pattern (`theme/src/main/java/com/davidmedenjak/indiana/theme/ui/`).

Dependency Injection

All major components use Hilt:

Screen Implementation Pattern

Each screen follows this structure:

1. Graph object implementing `NavKey` for navigation

2. Route composable for UI

3. `@HiltViewModel` for state management

4. Repository pattern for data access

State Management

Authentication Flow

1. User enters Bitrise API token in `AuthRoute`

2. `SessionManager.authenticate()` validates token

3. On success, navigation switches to `ProjectsGraph`

4. Token stored in `UserSettings` for persistence

Database Schema

Room database with:

Uses KTX coroutines for async operations.

Firebase Configuration

Firebase services are toggleable via `UserSettings`:

Build Configuration

Common Tasks

When implementing new features:

1. Create UI components in `:theme` module if needed

2. Define navigation in `AppBackStack` with `NavKey`

3. Use Hilt for dependency injection

4. Follow repository pattern for data access

5. Use `StateFlow` for state management

6. Collect state with `collectAsStateWithLifecycle()`

When working with the API:

1. Modify OpenAPI spec in `api/bitrise.json` if needed

2. Run `./gradlew :api:openApiGenerate` to regenerate client

3. Add network calls in repository layer

4. Handle authentication through `SessionManager`

When adding database entities:

1. Define entity in `AppDatabase`

2. Create DAO interface

3. Update database version if schema changes

4. Use coroutines for async database operations