Files

nk a83672b455 feat: auth screen with auto-redirect, sync favorites/history with backend

2026-06-02 19:12:07 +03:00

58 KiB

Raw Blame History

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

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

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

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

[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

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

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

# 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 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

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

package com.radiola

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

@HiltAndroidApp
class RadiolaApplication : Application()

Step 2: Write MainActivity.kt

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:

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:

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:

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:

<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:

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

colors.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 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 version="1.0" encoding="utf-8"?>
<full-backup-content>
    <exclude domain="sharedpref" path="."/>
    <exclude domain="database" path="."/>
</full-backup-content>

Step 5: Commit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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:

Subagent-Driven (recommended) — I dispatch a fresh subagent per task, review between tasks, fast iteration.
Inline Execution — Execute tasks in this session using executing-plans, batch execution with checkpoints.

Which approach?

58 KiB Raw Blame History Unescape Escape

radiOLA Bootstrap Implementation Plan

File Structure

Task 1: Root Gradle Wrapper & Settings

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

Task 3: Application Class & Basic Theme

Task 4: Domain Layer — Models

Task 5: Domain Layer — Repository Interfaces

Task 6: Domain Layer — Use Cases

Task 7: Data Layer — Remote API (Retrofit)

Task 8: Data Layer — Local Database (Room)

Task 9: Data Layer — Repository Implementations

Task 10: DI Module (Hilt)

Task 11: Player Service (MediaSessionService + ExoPlayer)

Task 12: Navigation & Bottom Navigation Scaffold

Self-Review

Execution Handoff

58 KiB

Raw Blame History