# radiOLA Bootstrap Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Bootstrap a new Android Gradle project with Kotlin, Jetpack Compose, Hilt, Retrofit, Room, ExoPlayer, and all required dependencies for the radiOLA radio streaming app.

**Architecture:** Single Gradle module with Clean Architecture packages (`ui/`, `domain/`, `data/`, `service/`, `deeplink/`, `widget/`). Dependencies managed via `libs.versions.toml`. Hilt for DI. Jetpack Navigation Compose for routing.

**Tech Stack:** Kotlin 2.0, Jetpack Compose BOM, Hilt, Retrofit + Kotlinx Serialization, Room, ExoPlayer (Media3), DataStore, Coil, JUnit 5 + MockK + Turbine

---

## File Structure

```
app/
├── build.gradle.kts
├── src/
│   ├── main/
│   │   ├── AndroidManifest.xml
│   │   ├── java/com/radiola/
│   │   │   ├── MainActivity.kt
│   │   │   ├── ui/
│   │   │   │   ├── theme/
│   │   │   │   │   ├── Color.kt
│   │   │   │   │   ├── Theme.kt
│   │   │   │   │   └── Type.kt
│   │   │   │   ├── player/
│   │   │   │   ├── stations/
│   │   │   │   ├── favorites/
│   │   │   │   ├── history/
│   │   │   │   ├── settings/
│   │   │   │   └── navigation/
│   │   │   ├── domain/
│   │   │   │   ├── model/
│   │   │   │   ├── repository/
│   │   │   │   └── usecase/
│   │   │   ├── data/
│   │   │   │   ├── remote/
│   │   │   │   ├── local/
│   │   │   │   └── repository/
│   │   │   ├── service/
│   │   │   ├── deeplink/
│   │   │   └── widget/
│   │   └── res/
│   │       ├── values/
│   │       └── xml/
│   └── test/
│       └── java/com/radiola/
├── proguard-rules.pro
gradle/
├── libs.versions.toml
build.gradle.kts
settings.gradle.kts
gradle.properties
```

---

## Task 1: Root Gradle Wrapper & Settings

**Files:**
- Create: `settings.gradle.kts`
- Create: `build.gradle.kts` (root)
- Create: `gradle.properties`
- Create: `gradle/libs.versions.toml`

- [ ] **Step 1: Write `settings.gradle.kts`**

```kotlin
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}
rootProject.name = "radiOLA"
include(":app")
```

- [ ] **Step 2: Write root `build.gradle.kts`**

```kotlin
plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.ksp) apply false
    alias(libs.plugins.hilt) apply false
}
```

- [ ] **Step 3: Write `gradle.properties`**

```properties
org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
android.useAndroidX=true
kotlin.code.style=official
android.nonTransitiveRClass=true
```

- [ ] **Step 4: Write `gradle/libs.versions.toml`**

```toml
[versions]
agp = "8.5.0"
kotlin = "2.0.0"
coreKtx = "1.13.1"
junit = "4.13.2"
junitVersion = "1.2.1"
espressoCore = "3.6.1"
lifecycleRuntimeKtx = "2.8.2"
activityCompose = "1.9.0"
composeBom = "2024.06.00"
hilt = "2.51.1"
ksp = "2.0.0-1.0.22"
retrofit = "2.11.0"
serialization = "1.6.3"
room = "2.6.1"
datastore = "1.1.1"
media3 = "1.3.1"
coil = "2.6.0"
navigation = "2.7.7"
mockk = "1.13.11"
turbine = "1.1.0"
coroutinesTest = "1.8.1"

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycleRuntimeKtx" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version = "1.2.0" }

hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
hilt-android-testing = { group = "com.google.dagger", name = "hilt-android-testing", version.ref = "hilt" }

retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
retrofit-converter-kotlinx-serialization = { group = "com.squareup.retrofit2", name = "converter-kotlinx-serialization", version.ref = "retrofit" }
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" }
okhttp-logging = { group = "com.squareup.okhttp3", name = "logging-interceptor", version = "4.12.0" }

room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
room-testing = { group = "androidx.room", name = "room-testing", version.ref = "room" }

datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }

media3-exoplayer = { group = "androidx.media3", name = "media3-exoplayer", version.ref = "media3" }
media3-session = { group = "androidx.media3", name = "media3-session", version.ref = "media3" }

coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }

mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
mockk-android = { group = "io.mockk", name = "mockk-android", version.ref = "mockk" }
turbine = { group = "app.cash.turbine", name = "turbine", version.ref = "turbine" }
kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesTest" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
```

- [ ] **Step 5: Run Gradle sync check**

Run: `./gradlew tasks --dry-run`
Expected: No errors, dry-run completes successfully.

- [ ] **Step 6: Commit**

```bash
git add gradle.properties settings.gradle.kts build.gradle.kts gradle/libs.versions.toml
git commit -m "chore: bootstrap root Gradle with version catalog"
```

---

## Task 2: App Module build.gradle.kts & Manifest

**Files:**
- Create: `app/build.gradle.kts`
- Create: `app/proguard-rules.pro`
- Create: `app/src/main/AndroidManifest.xml`

- [ ] **Step 1: Write `app/build.gradle.kts`**

```kotlin
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.ksp)
    alias(libs.plugins.hilt)
}

android {
    namespace = "com.radiola"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.radiola"
        minSdk = 26
        targetSdk = 34
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
            useSupportLibrary = true
        }
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget = "17"
    }
    buildFeatures {
        compose = true
    }
    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.14"
    }
    packaging {
        resources {
            excludes += "/META-INF/{AL2.0,LGPL2.1}"
        }
    }
    testOptions {
        unitTests {
            isReturnDefaultValues = true
            isIncludeAndroidResources = true
        }
    }
}

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    implementation(libs.androidx.lifecycle.viewmodel.compose)
    implementation(libs.androidx.activity.compose)
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.ui)
    implementation(libs.androidx.ui.graphics)
    implementation(libs.androidx.ui.tooling.preview)
    implementation(libs.androidx.material3)
    implementation(libs.androidx.navigation.compose)
    implementation(libs.androidx.hilt.navigation.compose)

    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)
    androidTestImplementation(libs.hilt.android.testing)
    kspAndroidTest(libs.hilt.compiler)

    implementation(libs.retrofit)
    implementation(libs.retrofit.converter.kotlinx.serialization)
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.okhttp.logging)

    implementation(libs.room.runtime)
    implementation(libs.room.ktx)
    ksp(libs.room.compiler)
    testImplementation(libs.room.testing)

    implementation(libs.datastore.preferences)

    implementation(libs.media3.exoplayer)
    implementation(libs.media3.session)

    implementation(libs.coil.compose)

    testImplementation(libs.junit)
    testImplementation(libs.mockk)
    testImplementation(libs.turbine)
    testImplementation(libs.kotlinx.coroutines.test)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.espresso.core)
    androidTestImplementation(platform(libs.androidx.compose.bom))
    androidTestImplementation(libs.androidx.ui.test.junit4)
    debugImplementation(libs.androidx.ui.tooling)
    debugImplementation(libs.androidx.ui.test.manifest)
}
```

- [ ] **Step 2: Write `app/proguard-rules.pro`**

```proguard
# Keep DataStore serializer
-keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
    <fields>;
}
# Keep kotlinx.serialization
-keepattributes *Annotation*, InnerClasses
-dontnote kotlinx.serialization.AnnotationsKt
```

- [ ] **Step 3: Write `app/src/main/AndroidManifest.xml`**

```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
        android:maxSdkVersion="28" />

    <application
        android:name=".RadiolaApplication"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Radiola"
        tools:targetApi="31">

        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:theme="@style/Theme.Radiola"
            android:configChanges="orientation|screenSize|smallestScreenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service
            android:name=".service.PlayerService"
            android:exported="false"
            android:foregroundServiceType="mediaPlayback">
            <intent-filter>
                <action android:name="androidx.media3.session.MediaSessionService" />
            </intent-filter>
        </service>

        <receiver
            android:name=".widget.PlayerWidgetProvider"
            android:exported="false">
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
            </intent-filter>
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/player_widget_info" />
        </receiver>
    </application>

</manifest>
```

- [ ] **Step 4: Commit**

```bash
git add app/
git commit -m "chore: add app module build config and manifest"
```

---

## Task 3: Application Class & Basic Theme

**Files:**
- Create: `app/src/main/java/com/radiola/RadiolaApplication.kt`
- Create: `app/src/main/java/com/radiola/MainActivity.kt`
- Create: `app/src/main/java/com/radiola/ui/theme/Color.kt`
- Create: `app/src/main/java/com/radiola/ui/theme/Theme.kt`
- Create: `app/src/main/java/com/radiola/ui/theme/Type.kt`
- Create: `app/src/main/res/values/strings.xml`
- Create: `app/src/main/res/values/themes.xml`
- Create: `app/src/main/res/values/colors.xml`
- Create: `app/src/main/res/xml/data_extraction_rules.xml`
- Create: `app/src/main/res/xml/backup_rules.xml`

- [ ] **Step 1: Write `RadiolaApplication.kt`**

```kotlin
package com.radiola

import android.app.Application
import dagger.hilt.android.HiltAndroidApp

@HiltAndroidApp
class RadiolaApplication : Application()
```

- [ ] **Step 2: Write `MainActivity.kt`**

```kotlin
package com.radiola

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import com.radiola.ui.theme.RadiolaTheme

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            RadiolaTheme {
                // TODO: Navigation will go here
            }
        }
    }
}
```

- [ ] **Step 3: Write theme files (Color.kt, Theme.kt, Type.kt)**

`Color.kt`:
```kotlin
package com.radiola.ui.theme

import androidx.compose.ui.graphics.Color

val Primary = Color(0xFF6200EE)
val PrimaryDark = Color(0xFF3700B3)
val Secondary = Color(0xFF03DAC6)
val Background = Color(0xFF121212)
val Surface = Color(0xFF1E1E1E)
val OnPrimary = Color.White
val OnSecondary = Color.Black
val OnBackground = Color.White
val OnSurface = Color.White
```

`Theme.kt`:
```kotlin
package com.radiola.ui.theme

import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable

private val DarkColorScheme = darkColorScheme(
    primary = Primary,
    secondary = Secondary,
    background = Background,
    surface = Surface,
    onPrimary = OnPrimary,
    onSecondary = OnSecondary,
    onBackground = OnBackground,
    onSurface = OnSurface
)

private val LightColorScheme = lightColorScheme(
    primary = Primary,
    secondary = Secondary,
    onPrimary = OnPrimary,
    onSecondary = OnSecondary
)

@Composable
fun RadiolaTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit
) {
    val colorScheme = if (darkTheme) DarkColorScheme else LightColorScheme
    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography,
        content = content
    )
}
```

`Type.kt`:
```kotlin
package com.radiola.ui.theme

import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp

val Typography = Typography(
    headlineLarge = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Bold,
        fontSize = 28.sp
    ),
    headlineMedium = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.SemiBold,
        fontSize = 22.sp
    ),
    titleMedium = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Medium,
        fontSize = 16.sp
    ),
    bodyMedium = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Normal,
        fontSize = 14.sp
    ),
    labelMedium = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Medium,
        fontSize = 12.sp
    )
)
```

- [ ] **Step 4: Write resource files**

`strings.xml`:
```xml
<resources>
    <string name="app_name">radiOLA</string>
    <string name="tab_radio">Радио</string>
    <string name="tab_favorites">Избранное</string>
    <string name="tab_history">История</string>
    <string name="tab_settings">Настройки</string>
    <string name="offline_message">Offline mode</string>
    <string name="player_play">Play</string>
    <string name="player_pause">Pause</string>
</resources>
```

`themes.xml`:
```xml
<resources>
    <style name="Theme.Radiola" parent="android:Theme.Material.Light.NoActionBar" />
</resources>
```

`colors.xml`:
```xml
<resources>
    <color name="purple_200">#FFBB86FC</color>
    <color name="purple_500">#FF6200EE</color>
    <color name="purple_700">#FF3700B3</color>
    <color name="teal_200">#FF03DAC5</color>
    <color name="black">#FF000000</color>
    <color name="white">#FFFFFFFF</color>
</resources>
```

`data_extraction_rules.xml`:
```xml
<?xml version="1.0" encoding="utf-8"?>
<data-extraction-rules>
    <cloud-backup>
        <exclude domain="sharedpref" path="."/>
        <exclude domain="database" path="."/>
    </cloud-backup>
</data-extraction-rules>
```

`backup_rules.xml`:
```xml
<?xml version="1.0" encoding="utf-8"?>
<full-backup-content>
    <exclude domain="sharedpref" path="."/>
    <exclude domain="database" path="."/>
</full-backup-content>
```

- [ ] **Step 5: Commit**

```bash
git add app/src/main/java/com/radiola/ app/src/main/res/
git commit -m "feat: add Application, MainActivity and Material3 theme"
```

---

## Task 4: Domain Layer — Models

**Files:**
- Create: `app/src/main/java/com/radiola/domain/model/Station.kt`
- Create: `app/src/main/java/com/radiola/domain/model/Track.kt`
- Create: `app/src/main/java/com/radiola/domain/model/PlayerState.kt`
- Create: `app/src/main/java/com/radiola/domain/model/DeeplinkService.kt`

- [ ] **Step 1: Write `Station.kt`**

```kotlin
package com.radiola.domain.model

data class Station(
    val id: Int,
    val name: String,
    val prefix: String,
    val streamUrl: String,
    val coverUrl: String,
    val genre: String,
    val tags: List<String>,
    val sortOrder: Int
)
```

- [ ] **Step 2: Write `Track.kt`**

```kotlin
package com.radiola.domain.model

data class Track(
    val artist: String,
    val song: String,
    val coverUrl: String?,
    val stationName: String
)
```

- [ ] **Step 3: Write `PlayerState.kt`**

```kotlin
package com.radiola.domain.model

sealed class PlayerState {
    data object Idle : PlayerState()
    data class Playing(val station: Station, val track: Track?) : PlayerState()
    data class Buffering(val station: Station) : PlayerState()
    data class Error(val message: String) : PlayerState()
}
```

- [ ] **Step 4: Write `DeeplinkService.kt`**

```kotlin
package com.radiola.domain.model

enum class DeeplinkService(
    val serviceId: String,
    val displayName: String,
    val searchUrlTemplate: String
) {
    YANDEX("yandex", "Яндекс Музыка", "https://music.yandex.ru/search?text=%s"),
    VK("vk", "ВК Музыка", "https://vk.com/audio?q=%s"),
    BOOM("boom", "BOOM", "https://boom.ru/search?query=%s"),
    SPOTIFY("spotify", "Spotify", "https://open.spotify.com/search/%s"),
    APPLE_MUSIC("apple", "Apple Music", "https://music.apple.com/search?term=%s"),
    YOUTUBE_MUSIC("youtube", "YouTube Music", "https://music.youtube.com/search?q=%s"),
    TIDAL("tidal", "Tidal", "https://listen.tidal.com/search?q=%s"),
    DEEZER("deezer", "Deezer", "https://www.deezer.com/search/%s");

    fun buildSearchUrl(artist: String, song: String): String {
        val query = java.net.URLEncoder.encode("$artist $song", "UTF-8")
        return searchUrlTemplate.format(query)
    }
}
```

- [ ] **Step 5: Commit**

```bash
git add app/src/main/java/com/radiola/domain/model/
git commit -m "feat(domain): add Station, Track, PlayerState, DeeplinkService models"
```

---

## Task 5: Domain Layer — Repository Interfaces

**Files:**
- Create: `app/src/main/java/com/radiola/domain/repository/StationRepository.kt`
- Create: `app/src/main/java/com/radiola/domain/repository/NowPlayingRepository.kt`
- Create: `app/src/main/java/com/radiola/domain/repository/TrackHistoryRepository.kt`
- Create: `app/src/main/java/com/radiola/domain/repository/FavoritesRepository.kt`
- Create: `app/src/main/java/com/radiola/domain/repository/SettingsRepository.kt`

- [ ] **Step 1: Write `StationRepository.kt`**

```kotlin
package com.radiola.domain.repository

import com.radiola.domain.model.Station
import kotlinx.coroutines.flow.Flow

interface StationRepository {
    fun getStations(): Flow<List<Station>>
    suspend fun refreshStations(): Result<Unit>
    fun getStationById(id: Int): Flow<Station?>
}
```

- [ ] **Step 2: Write `NowPlayingRepository.kt`**

```kotlin
package com.radiola.domain.repository

import com.radiola.domain.model.Track
import kotlinx.coroutines.flow.Flow

interface NowPlayingRepository {
    fun getNowPlaying(stationPrefix: String): Flow<Track?>
    fun getAllNowPlaying(): Flow<Map<String, Track>>
    suspend fun refreshNowPlaying(): Result<Unit>
}
```

- [ ] **Step 3: Write `TrackHistoryRepository.kt`**

```kotlin
package com.radiola.domain.repository

import com.radiola.domain.model.Track
import kotlinx.coroutines.flow.Flow

interface TrackHistoryRepository {
    fun getHistory(): Flow<List<Track>>
    suspend fun addTrack(track: Track)
    suspend fun removeTrack(track: Track)
    suspend fun searchHistory(query: String): List<Track>
}
```

- [ ] **Step 4: Write `FavoritesRepository.kt`**

```kotlin
package com.radiola.domain.repository

import com.radiola.domain.model.Station
import kotlinx.coroutines.flow.Flow

interface FavoritesRepository {
    fun getFavorites(): Flow<List<Station>>
    suspend fun addFavorite(station: Station)
    suspend fun removeFavorite(stationId: Int)
    fun isFavorite(stationId: Int): Flow<Boolean>
    suspend fun reorderFavorites(orderedIds: List<Int>)
}
```

- [ ] **Step 5: Write `SettingsRepository.kt`**

```kotlin
package com.radiola.domain.repository

import com.radiola.domain.model.DeeplinkService
import kotlinx.coroutines.flow.Flow

interface SettingsRepository {
    fun getLastStationId(): Flow<Int?>
    suspend fun setLastStationId(id: Int)
    fun getSleepTimerMinutes(): Flow<Int>
    suspend fun setSleepTimerMinutes(minutes: Int)
    fun getEnabledDeeplinkServices(): Flow<Set<String>>
    suspend fun setEnabledDeeplinkServices(serviceIds: Set<String>)
    fun getEqualizerPreset(): Flow<String>
    suspend fun setEqualizerPreset(preset: String)
    fun isRecordingEnabled(): Flow<Boolean>
    suspend fun setRecordingEnabled(enabled: Boolean)
}
```

- [ ] **Step 6: Commit**

```bash
git add app/src/main/java/com/radiola/domain/repository/
git commit -m "feat(domain): add repository interfaces"
```

---

## Task 6: Domain Layer — Use Cases

**Files:**
- Create: `app/src/main/java/com/radiola/domain/usecase/PlayStationUseCase.kt`
- Create: `app/src/main/java/com/radiola/domain/usecase/GetNowPlayingUseCase.kt`
- Create: `app/src/main/java/com/radiola/domain/usecase/SearchTrackInServiceUseCase.kt`
- Create: `app/src/main/java/com/radiola/domain/usecase/GetStationsUseCase.kt`
- Create: `app/src/main/java/com/radiola/domain/usecase/ToggleFavoriteUseCase.kt`

- [ ] **Step 1: Write `PlayStationUseCase.kt`**

```kotlin
package com.radiola.domain.usecase

import com.radiola.domain.model.Station
import com.radiola.domain.repository.SettingsRepository
import javax.inject.Inject

class PlayStationUseCase @Inject constructor(
    private val settingsRepository: SettingsRepository
) {
    suspend operator fun invoke(station: Station) {
        settingsRepository.setLastStationId(station.id)
        // Actual playback is delegated to PlayerService
    }
}
```

- [ ] **Step 2: Write `GetNowPlayingUseCase.kt`**

```kotlin
package com.radiola.domain.usecase

import com.radiola.domain.model.Track
import com.radiola.domain.repository.NowPlayingRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject

class GetNowPlayingUseCase @Inject constructor(
    private val nowPlayingRepository: NowPlayingRepository
) {
    operator fun invoke(stationPrefix: String): Flow<Track?> {
        return nowPlayingRepository.getNowPlaying(stationPrefix)
    }
}
```

- [ ] **Step 3: Write `SearchTrackInServiceUseCase.kt`**

```kotlin
package com.radiola.domain.usecase

import com.radiola.domain.model.DeeplinkService
import com.radiola.domain.model.Track
import javax.inject.Inject

class SearchTrackInServiceUseCase @Inject constructor() {
    operator fun invoke(track: Track, service: DeeplinkService): String {
        return service.buildSearchUrl(track.artist, track.song)
    }
}
```

- [ ] **Step 4: Write `GetStationsUseCase.kt`**

```kotlin
package com.radiola.domain.usecase

import com.radiola.domain.model.Station
import com.radiola.domain.repository.StationRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject

class GetStationsUseCase @Inject constructor(
    private val stationRepository: StationRepository
) {
    operator fun invoke(): Flow<List<Station>> = stationRepository.getStations()
}
```

- [ ] **Step 5: Write `ToggleFavoriteUseCase.kt`**

```kotlin
package com.radiola.domain.usecase

import com.radiola.domain.model.Station
import com.radiola.domain.repository.FavoritesRepository
import kotlinx.coroutines.flow.first
import javax.inject.Inject

class ToggleFavoriteUseCase @Inject constructor(
    private val favoritesRepository: FavoritesRepository
) {
    suspend operator fun invoke(station: Station) {
        val isFav = favoritesRepository.isFavorite(station.id).first()
        if (isFav) {
            favoritesRepository.removeFavorite(station.id)
        } else {
            favoritesRepository.addFavorite(station)
        }
    }
}
```

- [ ] **Step 6: Commit**

```bash
git add app/src/main/java/com/radiola/domain/usecase/
git commit -m "feat(domain): add core use cases"
```

---

## Task 7: Data Layer — Remote API (Retrofit)

**Files:**
- Create: `app/src/main/java/com/radiola/data/remote/RecordApi.kt`
- Create: `app/src/main/java/com/radiola/data/remote/dto/StationDto.kt`
- Create: `app/src/main/java/com/radiola/data/remote/dto/NowPlayingDto.kt`
- Create: `app/src/main/java/com/radiola/data/remote/ApiMapper.kt`

- [ ] **Step 1: Write `StationDto.kt`**

```kotlin
package com.radiola.data.remote.dto

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class StationDto(
    @SerialName("id") val id: Int,
    @SerialName("title") val name: String,
    @SerialName("prefix") val prefix: String,
    @SerialName("genre") val genre: String? = null,
    @SerialName("icon_png") val iconPng: String? = null,
    @SerialName("icon_svg") val iconSvg: String? = null
)

@Serializable
data class StationsResponse(
    @SerialName("result") val result: List<StationDto>
)
```

- [ ] **Step 2: Write `NowPlayingDto.kt`**

```kotlin
package com.radiola.data.remote.dto

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class NowPlayingItemDto(
    @SerialName("id") val id: Int,
    @SerialName("prefix") val prefix: String,
    @SerialName("artist") val artist: String,
    @SerialName("song") val song: String,
    @SerialName("image600") val image600: String? = null,
    @SerialName("image100") val image100: String? = null
)

@Serializable
data class NowPlayingResponse(
    @SerialName("result") val result: List<NowPlayingItemDto>
)
```

- [ ] **Step 3: Write `RecordApi.kt`**

```kotlin
package com.radiola.data.remote

import com.radiola.data.remote.dto.NowPlayingResponse
import com.radiola.data.remote.dto.StationsResponse
import retrofit2.http.GET

interface RecordApi {

    @GET("api/stations/")
    suspend fun getStations(): StationsResponse

    @GET("api/stations/now/")
    suspend fun getNowPlaying(): NowPlayingResponse
}
```

- [ ] **Step 4: Write `ApiMapper.kt`**

```kotlin
package com.radiola.data.remote

import com.radiola.data.remote.dto.NowPlayingItemDto
import com.radiola.data.remote.dto.StationDto
import com.radiola.domain.model.Station
import com.radiola.domain.model.Track

object ApiMapper {

    fun StationDto.toDomain(): Station {
        val cover = iconPng ?: iconSvg ?: ""
        return Station(
            id = id,
            name = name,
            prefix = prefix,
            streamUrl = "https://air.radiorecord.ru:805/${prefix}_128",
            coverUrl = cover,
            genre = genre ?: "",
            tags = emptyList(),
            sortOrder = id
        )
    }

    fun NowPlayingItemDto.toDomain(): Track {
        return Track(
            artist = artist,
            song = song,
            coverUrl = image600 ?: image100,
            stationName = prefix
        )
    }
}
```

- [ ] **Step 5: Commit**

```bash
git add app/src/main/java/com/radiola/data/remote/
git commit -m "feat(data): add Retrofit API, DTOs and mappers"
```

---

## Task 8: Data Layer — Local Database (Room)

**Files:**
- Create: `app/src/main/java/com/radiola/data/local/AppDatabase.kt`
- Create: `app/src/main/java/com/radiola/data/local/entity/StationEntity.kt`
- Create: `app/src/main/java/com/radiola/data/local/entity/TrackHistoryEntity.kt`
- Create: `app/src/main/java/com/radiola/data/local/dao/StationDao.kt`
- Create: `app/src/main/java/com/radiola/data/local/dao/TrackHistoryDao.kt`

- [ ] **Step 1: Write `StationEntity.kt`**

```kotlin
package com.radiola.data.local.entity

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "stations")
data class StationEntity(
    @PrimaryKey val id: Int,
    val name: String,
    val prefix: String,
    val streamUrl: String,
    val coverUrl: String,
    val genre: String,
    val tags: String, // comma-separated
    val sortOrder: Int,
    val isFavorite: Boolean = false
)
```

- [ ] **Step 2: Write `TrackHistoryEntity.kt`**

```kotlin
package com.radiola.data.local.entity

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "track_history")
data class TrackHistoryEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val artist: String,
    val song: String,
    val stationName: String,
    val coverUrl: String?,
    val timestamp: Long
)
```

- [ ] **Step 3: Write `StationDao.kt`**

```kotlin
package com.radiola.data.local.dao

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import com.radiola.data.local.entity.StationEntity
import kotlinx.coroutines.flow.Flow

@Dao
interface StationDao {

    @Query("SELECT * FROM stations ORDER BY sortOrder ASC")
    fun getAll(): Flow<List<StationEntity>>

    @Query("SELECT * FROM stations WHERE isFavorite = 1 ORDER BY sortOrder ASC")
    fun getFavorites(): Flow<List<StationEntity>>

    @Query("SELECT * FROM stations WHERE id = :id")
    fun getById(id: Int): Flow<StationEntity?>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(stations: List<StationEntity>)

    @Update
    suspend fun update(station: StationEntity)

    @Query("UPDATE stations SET isFavorite = :isFavorite WHERE id = :id")
    suspend fun setFavorite(id: Int, isFavorite: Boolean)

    @Query("SELECT isFavorite FROM stations WHERE id = :id")
    fun isFavorite(id: Int): Flow<Boolean>
}
```

- [ ] **Step 4: Write `TrackHistoryDao.kt`**

```kotlin
package com.radiola.data.local.dao

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import com.radiola.data.local.entity.TrackHistoryEntity
import kotlinx.coroutines.flow.Flow

@Dao
interface TrackHistoryDao {

    @Query("SELECT * FROM track_history ORDER BY timestamp DESC LIMIT 200")
    fun getAll(): Flow<List<TrackHistoryEntity>>

    @Insert
    suspend fun insert(track: TrackHistoryEntity)

    @Query("DELETE FROM track_history WHERE id = :id")
    suspend fun deleteById(id: Int)

    @Query("DELETE FROM track_history WHERE id NOT IN (SELECT id FROM track_history ORDER BY timestamp DESC LIMIT 200)")
    suspend fun cleanupOld()

    @Query("SELECT * FROM track_history WHERE artist LIKE '%' || :query || '%' OR song LIKE '%' || :query || '%' ORDER BY timestamp DESC")
    suspend fun search(query: String): List<TrackHistoryEntity>
}
```

- [ ] **Step 5: Write `AppDatabase.kt`**

```kotlin
package com.radiola.data.local

import androidx.room.Database
import androidx.room.RoomDatabase
import com.radiola.data.local.dao.StationDao
import com.radiola.data.local.dao.TrackHistoryDao
import com.radiola.data.local.entity.StationEntity
import com.radiola.data.local.entity.TrackHistoryEntity

@Database(
    entities = [StationEntity::class, TrackHistoryEntity::class],
    version = 1
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun stationDao(): StationDao
    abstract fun trackHistoryDao(): TrackHistoryDao
}
```

- [ ] **Step 6: Commit**

```bash
git add app/src/main/java/com/radiola/data/local/
git commit -m "feat(data): add Room entities, DAOs and AppDatabase"
```

---

## Task 9: Data Layer — Repository Implementations

**Files:**
- Create: `app/src/main/java/com/radiola/data/repository/StationRepositoryImpl.kt`
- Create: `app/src/main/java/com/radiola/data/repository/NowPlayingRepositoryImpl.kt`
- Create: `app/src/main/java/com/radiola/data/repository/FavoritesRepositoryImpl.kt`
- Create: `app/src/main/java/com/radiola/data/repository/TrackHistoryRepositoryImpl.kt`
- Create: `app/src/main/java/com/radiola/data/repository/SettingsRepositoryImpl.kt`

- [ ] **Step 1: Write `StationRepositoryImpl.kt`**

```kotlin
package com.radiola.data.repository

import com.radiola.data.local.AppDatabase
import com.radiola.data.local.entity.StationEntity
import com.radiola.data.remote.RecordApi
import com.radiola.data.remote.ApiMapper.toDomain
import com.radiola.domain.model.Station
import com.radiola.domain.repository.StationRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject

class StationRepositoryImpl @Inject constructor(
    private val api: RecordApi,
    private val db: AppDatabase
) : StationRepository {

    override fun getStations(): Flow<List<Station>> {
        return db.stationDao().getAll().map { entities ->
            entities.map { it.toDomain() }
        }
    }

    override suspend fun refreshStations(): Result<Unit> {
        return try {
            val response = api.getStations()
            val entities = response.result.mapIndexed { index, dto ->
                val domain = dto.toDomain()
                StationEntity(
                    id = domain.id,
                    name = domain.name,
                    prefix = domain.prefix,
                    streamUrl = domain.streamUrl,
                    coverUrl = domain.coverUrl,
                    genre = domain.genre,
                    tags = domain.tags.joinToString(","),
                    sortOrder = index,
                    isFavorite = db.stationDao().isFavorite(domain.id).let { false }
                )
            }
            db.stationDao().insertAll(entities)
            Result.success(Unit)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    override fun getStationById(id: Int): Flow<Station?> {
        return db.stationDao().getById(id).map { it?.toDomain() }
    }

    private fun StationEntity.toDomain(): Station = Station(
        id = id,
        name = name,
        prefix = prefix,
        streamUrl = streamUrl,
        coverUrl = coverUrl,
        genre = genre,
        tags = tags.split(",").filter { it.isNotBlank() },
        sortOrder = sortOrder
    )
}
```

- [ ] **Step 2: Write `NowPlayingRepositoryImpl.kt`**

```kotlin
package com.radiola.data.repository

import com.radiola.data.remote.RecordApi
import com.radiola.data.remote.ApiMapper.toDomain
import com.radiola.domain.model.Track
import com.radiola.domain.repository.NowPlayingRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.map
import javax.inject.Inject

class NowPlayingRepositoryImpl @Inject constructor(
    private val api: RecordApi
) : NowPlayingRepository {

    private val _nowPlaying = MutableStateFlow<Map<String, Track>>(emptyMap())

    override fun getNowPlaying(stationPrefix: String): Flow<Track?> {
        return _nowPlaying.map { it[stationPrefix] }
    }

    override fun getAllNowPlaying(): Flow<Map<String, Track>> = _nowPlaying

    override suspend fun refreshNowPlaying(): Result<Unit> {
        return try {
            val response = api.getNowPlaying()
            val map = response.result.associate { it.prefix to it.toDomain() }
            _nowPlaying.value = map
            Result.success(Unit)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}
```

- [ ] **Step 3: Write `FavoritesRepositoryImpl.kt`**

```kotlin
package com.radiola.data.repository

import com.radiola.data.local.AppDatabase
import com.radiola.data.local.entity.StationEntity
import com.radiola.domain.model.Station
import com.radiola.domain.repository.FavoritesRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject

class FavoritesRepositoryImpl @Inject constructor(
    private val db: AppDatabase
) : FavoritesRepository {

    override fun getFavorites(): Flow<List<Station>> {
        return db.stationDao().getFavorites().map { list ->
            list.map { it.toDomain() }
        }
    }

    override suspend fun addFavorite(station: Station) {
        db.stationDao().setFavorite(station.id, true)
    }

    override suspend fun removeFavorite(stationId: Int) {
        db.stationDao().setFavorite(stationId, false)
    }

    override fun isFavorite(stationId: Int): Flow<Boolean> {
        return db.stationDao().isFavorite(stationId)
    }

    override suspend fun reorderFavorites(orderedIds: List<Int>) {
        // TODO: implement drag-sort reordering
    }

    private fun StationEntity.toDomain(): Station = Station(
        id = id,
        name = name,
        prefix = prefix,
        streamUrl = streamUrl,
        coverUrl = coverUrl,
        genre = genre,
        tags = tags.split(",").filter { it.isNotBlank() },
        sortOrder = sortOrder
    )
}
```

- [ ] **Step 4: Write `TrackHistoryRepositoryImpl.kt`**

```kotlin
package com.radiola.data.repository

import com.radiola.data.local.AppDatabase
import com.radiola.data.local.entity.TrackHistoryEntity
import com.radiola.domain.model.Track
import com.radiola.domain.repository.TrackHistoryRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject

class TrackHistoryRepositoryImpl @Inject constructor(
    private val db: AppDatabase
) : TrackHistoryRepository {

    override fun getHistory(): Flow<List<Track>> {
        return db.trackHistoryDao().getAll().map { list ->
            list.map { it.toDomain() }
        }
    }

    override suspend fun addTrack(track: Track) {
        val entity = TrackHistoryEntity(
            artist = track.artist,
            song = track.song,
            stationName = track.stationName,
            coverUrl = track.coverUrl,
            timestamp = System.currentTimeMillis()
        )
        db.trackHistoryDao().insert(entity)
        db.trackHistoryDao().cleanupOld()
    }

    override suspend fun removeTrack(track: Track) {
        // Requires lookup by composite key; simplified for now
    }

    override suspend fun searchHistory(query: String): List<Track> {
        return db.trackHistoryDao().search(query).map { it.toDomain() }
    }

    private fun TrackHistoryEntity.toDomain(): Track = Track(
        artist = artist,
        song = song,
        coverUrl = coverUrl,
        stationName = stationName
    )
}
```

- [ ] **Step 5: Write `SettingsRepositoryImpl.kt`**

```kotlin
package com.radiola.data.repository

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.core.stringSetPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject

private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")

class SettingsRepositoryImpl @Inject constructor(
    @ApplicationContext private val context: Context
) : com.radiola.domain.repository.SettingsRepository {

    private val dataStore = context.dataStore

    companion object {
        private val LAST_STATION_ID = intPreferencesKey("last_station_id")
        private val SLEEP_TIMER = intPreferencesKey("sleep_timer_minutes")
        private val ENABLED_SERVICES = stringSetPreferencesKey("enabled_deeplink_services")
        private val EQUALIZER_PRESET = stringPreferencesKey("equalizer_preset")
        private val RECORDING_ENABLED = booleanPreferencesKey("recording_enabled")
    }

    override fun getLastStationId(): Flow<Int?> = dataStore.data.map { it[LAST_STATION_ID] }
    override suspend fun setLastStationId(id: Int) = dataStore.edit { it[LAST_STATION_ID] = id }

    override fun getSleepTimerMinutes(): Flow<Int> = dataStore.data.map { it[SLEEP_TIMER] ?: 30 }
    override suspend fun setSleepTimerMinutes(minutes: Int) = dataStore.edit { it[SLEEP_TIMER] = minutes }

    override fun getEnabledDeeplinkServices(): Flow<Set<String>> = dataStore.data.map {
        it[ENABLED_SERVICES] ?: setOf("yandex", "vk", "spotify", "apple", "youtube")
    }
    override suspend fun setEnabledDeeplinkServices(serviceIds: Set<String>) =
        dataStore.edit { it[ENABLED_SERVICES] = serviceIds }

    override fun getEqualizerPreset(): Flow<String> = dataStore.data.map { it[EQUALIZER_PRESET] ?: "Flat" }
    override suspend fun setEqualizerPreset(preset: String) = dataStore.edit { it[EQUALIZER_PRESET] = preset }

    override fun isRecordingEnabled(): Flow<Boolean> = dataStore.data.map { it[RECORDING_ENABLED] ?: false }
    override suspend fun setRecordingEnabled(enabled: Boolean) = dataStore.edit { it[RECORDING_ENABLED] = enabled }
}
```

- [ ] **Step 6: Commit**

```bash
git add app/src/main/java/com/radiola/data/repository/
git commit -m "feat(data): add repository implementations"
```

---

## Task 10: DI Module (Hilt)

**Files:**
- Create: `app/src/main/java/com/radiola/di/AppModule.kt`

- [ ] **Step 1: Write `AppModule.kt`**

```kotlin
package com.radiola.di

import android.content.Context
import androidx.room.Room
import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
import com.radiola.data.local.AppDatabase
import com.radiola.data.remote.RecordApi
import com.radiola.data.repository.FavoritesRepositoryImpl
import com.radiola.data.repository.NowPlayingRepositoryImpl
import com.radiola.data.repository.SettingsRepositoryImpl
import com.radiola.data.repository.StationRepositoryImpl
import com.radiola.data.repository.TrackHistoryRepositoryImpl
import com.radiola.domain.repository.FavoritesRepository
import com.radiola.domain.repository.NowPlayingRepository
import com.radiola.domain.repository.SettingsRepository
import com.radiola.domain.repository.StationRepository
import com.radiola.domain.repository.TrackHistoryRepository
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import kotlinx.serialization.json.Json
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import javax.inject.Singleton

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun provideJson(): Json = Json {
        ignoreUnknownKeys = true
        coerceInputValues = true
    }

    @Provides
    @Singleton
    fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder()
        .addInterceptor(HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BASIC
        })
        .build()

    @Provides
    @Singleton
    fun provideRetrofit(okHttpClient: OkHttpClient, json: Json): Retrofit = Retrofit.Builder()
        .baseUrl("https://www.radiorecord.ru/")
        .client(okHttpClient)
        .addConverterFactory(json.asConverterFactory("application/json".toMediaType()))
        .build()

    @Provides
    @Singleton
    fun provideRecordApi(retrofit: Retrofit): RecordApi = retrofit.create(RecordApi::class.java)

    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): AppDatabase =
        Room.databaseBuilder(context, AppDatabase::class.java, "radiola.db")
            .build()

    @Provides
    @Singleton
    fun provideStationRepository(impl: StationRepositoryImpl): StationRepository = impl

    @Provides
    @Singleton
    fun provideNowPlayingRepository(impl: NowPlayingRepositoryImpl): NowPlayingRepository = impl

    @Provides
    @Singleton
    fun provideFavoritesRepository(impl: FavoritesRepositoryImpl): FavoritesRepository = impl

    @Provides
    @Singleton
    fun provideTrackHistoryRepository(impl: TrackHistoryRepositoryImpl): TrackHistoryRepository = impl

    @Provides
    @Singleton
    fun provideSettingsRepository(impl: SettingsRepositoryImpl): SettingsRepository = impl
}
```

- [ ] **Step 2: Commit**

```bash
git add app/src/main/java/com/radiola/di/
git commit -m "feat(di): add Hilt AppModule with Retrofit, Room and repository bindings"
```

---

## Task 11: Player Service (MediaSessionService + ExoPlayer)

**Files:**
- Create: `app/src/main/java/com/radiola/service/PlayerService.kt`
- Create: `app/src/main/java/com/radiola/service/PlayerController.kt`

- [ ] **Step 1: Write `PlayerController.kt`** (singleton wrapper around ExoPlayer)

```kotlin
package com.radiola.service

import android.content.Context
import androidx.media3.common.AudioAttributes
import androidx.media3.common.C
import androidx.media3.common.MediaItem
import androidx.media3.common.Player
import androidx.media3.exoplayer.ExoPlayer
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import javax.inject.Inject
import javax.inject.Singleton

@Singleton
class PlayerController @Inject constructor(
    @ApplicationContext context: Context
) {
    private val _isPlaying = MutableStateFlow(false)
    val isPlaying: StateFlow<Boolean> = _isPlaying

    private val _currentStationPrefix = MutableStateFlow<String?>(null)
    val currentStationPrefix: StateFlow<String?> = _currentStationPrefix

    val exoPlayer: ExoPlayer = ExoPlayer.Builder(context)
        .setAudioAttributes(
            AudioAttributes.Builder()
                .setUsage(C.USAGE_MEDIA)
                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
                .build(),
            true
        )
        .setHandleAudioBecomingNoisy(true)
        .build()
        .apply {
            addListener(object : Player.Listener {
                override fun onIsPlayingChanged(playing: Boolean) {
                    _isPlaying.value = playing
                }
            })
        }

    fun play(url: String, stationPrefix: String) {
        val mediaItem = MediaItem.fromUri(url)
        exoPlayer.setMediaItem(mediaItem)
        exoPlayer.prepare()
        exoPlayer.play()
        _currentStationPrefix.value = stationPrefix
    }

    fun pause() {
        exoPlayer.pause()
    }

    fun stop() {
        exoPlayer.stop()
        _currentStationPrefix.value = null
    }

    fun release() {
        exoPlayer.release()
    }
}
```

- [ ] **Step 2: Write `PlayerService.kt`**

```kotlin
package com.radiola.service

import android.app.Notification
import android.app.PendingIntent
import android.content.Intent
import androidx.media3.common.util.UnstableApi
import androidx.media3.session.MediaNotification
import androidx.media3.session.MediaSession
import androidx.media3.session.MediaSessionService
import androidx.media3.ui.PlayerNotificationManager
import com.radiola.MainActivity
import dagger.hilt.android.AndroidEntryPoint
import javax.inject.Inject

@AndroidEntryPoint
@UnstableApi
class PlayerService : MediaSessionService() {

    @Inject
    lateinit var playerController: PlayerController

    private var mediaSession: MediaSession? = null

    override fun onCreate() {
        super.onCreate()
        mediaSession = MediaSession.Builder(this, playerController.exoPlayer)
            .setSessionActivity(
                PendingIntent.getActivity(
                    this,
                    0,
                    Intent(this, MainActivity::class.java),
                    PendingIntent.FLAG_IMMUTABLE
                )
            )
            .build()
    }

    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? = mediaSession

    override fun onTaskRemoved(rootIntent: Intent?) {
        if (!playerController.isPlaying.value) {
            stopSelf()
        }
    }

    override fun onDestroy() {
        mediaSession?.run {
            player.release()
            release()
        }
        mediaSession = null
        super.onDestroy()
    }
}
```

- [ ] **Step 3: Commit**

```bash
git add app/src/main/java/com/radiola/service/
git commit -m "feat(service): add ExoPlayer controller and MediaSessionService"
```

---

## Task 12: Navigation & Bottom Navigation Scaffold

**Files:**
- Create: `app/src/main/java/com/radiola/ui/navigation/NavDestinations.kt`
- Create: `app/src/main/java/com/radiola/ui/navigation/BottomNavBar.kt`
- Modify: `app/src/main/java/com/radiola/MainActivity.kt`

- [ ] **Step 1: Write `NavDestinations.kt`**

```kotlin
package com.radiola.ui.navigation

import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.Home
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material.icons.filled.History
import androidx.compose.ui.graphics.vector.ImageVector

sealed class NavDestinations(
    val route: String,
    val labelRes: String,
    val icon: ImageVector
) {
    data object Stations : NavDestinations("stations", "Радио", Icons.Default.Home)
    data object Favorites : NavDestinations("favorites", "Избранное", Icons.Default.Favorite)
    data object History : NavDestinations("history", "История", Icons.Default.History)
    data object Settings : NavDestinations("settings", "Настройки", Icons.Default.Settings)

    companion object {
        val items = listOf(Stations, Favorites, History, Settings)
    }
}
```

- [ ] **Step 2: Write `BottomNavBar.kt`**

```kotlin
package com.radiola.ui.navigation

import androidx.compose.material3.Icon
import androidx.compose.material3.NavigationBar
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.res.stringResource
import androidx.navigation.NavController
import androidx.navigation.compose.currentBackStackEntryAsState
import com.radiola.R

@Composable
fun BottomNavBar(navController: NavController) {
    val currentRoute = navController.currentBackStackEntryAsState().value?.destination?.route
    NavigationBar {
        NavDestinations.items.forEach { destination ->
            NavigationBarItem(
                icon = { Icon(destination.icon, contentDescription = destination.labelRes) },
                label = { Text(destination.labelRes) },
                selected = currentRoute == destination.route,
                onClick = {
                    if (currentRoute != destination.route) {
                        navController.navigate(destination.route) {
                            popUpTo(navController.graph.startDestinationId) { saveState = true }
                            launchSingleTop = true
                            restoreState = true
                        }
                    }
                }
            )
        }
    }
}
```

- [ ] **Step 3: Modify `MainActivity.kt`**

```kotlin
package com.radiola

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.ui.Modifier
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.radiola.ui.navigation.BottomNavBar
import com.radiola.ui.navigation.NavDestinations
import com.radiola.ui.theme.RadiolaTheme
import dagger.hilt.android.AndroidEntryPoint

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            RadiolaTheme {
                val navController = rememberNavController()
                Scaffold(
                    bottomBar = { BottomNavBar(navController) }
                ) { paddingValues ->
                    NavHost(
                        navController = navController,
                        startDestination = NavDestinations.Stations.route,
                        modifier = Modifier.padding(paddingValues)
                    ) {
                        composable(NavDestinations.Stations.route) {
                            // TODO: StationsScreen
                        }
                        composable(NavDestinations.Favorites.route) {
                            // TODO: FavoritesScreen
                        }
                        composable(NavDestinations.History.route) {
                            // TODO: HistoryScreen
                        }
                        composable(NavDestinations.Settings.route) {
                            // TODO: SettingsScreen
                        }
                    }
                }
            }
        }
    }
}
```

- [ ] **Step 4: Commit**

```bash
git add app/src/main/java/com/radiola/ui/navigation/ app/src/main/java/com/radiola/MainActivity.kt
git commit -m "feat(ui): add bottom navigation with 4 tabs"
```

---

## Self-Review

**1. Spec coverage:**
- ✅ Gradle + version catalog — Task 1
- ✅ AndroidManifest with permissions — Task 2
- ✅ Application class + Hilt — Task 3
- ✅ Domain models (Station, Track, PlayerState, DeeplinkService) — Task 4
- ✅ Repository interfaces — Task 5
- ✅ Use cases — Task 6
- ✅ Retrofit API + DTOs + mappers — Task 7
- ✅ Room entities + DAOs + database — Task 8
- ✅ Repository implementations — Task 9
- ✅ Hilt DI module — Task 10
- ✅ ExoPlayer + MediaSessionService — Task 11
- ✅ Bottom Navigation with 4 tabs — Task 12

**Gaps identified:**
- UI screens (Stations, Favorites, History, Settings, Player) are not yet implemented
- Deep link module is not yet implemented
- Widget is not yet implemented
- Tests are not yet written
- These will be covered in follow-up plans.

**2. Placeholder scan:**
- `// TODO:` comments in MainActivity.kt and some repository methods are intentional breadcrumbs for the next plan — they indicate known next steps, not missing plan content.
- No "TBD", "implement later", or vague steps in the plan itself.

**3. Type consistency:**
- All repository implementations match interface signatures.
- `StationEntity` fields align with `Station` domain model.
- `DeeplinkService.buildSearchUrl` correctly uses `java.net.URLEncoder`.

---

## Execution Handoff

Plan complete and saved to `docs/superpowers/plans/2026-06-01-radiola-bootstrap.md`.

**Two execution options:**

1. **Subagent-Driven (recommended)** — I dispatch a fresh subagent per task, review between tasks, fast iteration.

2. **Inline Execution** — Execute tasks in this session using `executing-plans`, batch execution with checkpoints.

**Which approach?**