feat: Implement Radio Browser API with server status monitoring

- Add RadioBrowserApi class with robust server discovery and mirror management
- Implement server status monitoring with detailed health checks
- Add support for both IPv4 and IPv6 server addresses
- Create ServerStatusView component for monitoring server health
- Integrate server status view into main UI with toggle functionality
- Add proper error handling and retry mechanisms
- Implement search functionality for radio stations
- Add support for filtering stations by country, language, and tags

Technical details:
- Use Ktor client for HTTP requests with proper timeout handling
- Implement coroutine-based async operations
- Add comprehensive logging for debugging
- Use Material Design components for UI
- Implement proper state management with ViewModel
- Add retry mechanism for failed requests
- Support both IPv4 and IPv6 server addresses with proper URL formatting

UI Components:
- Add ServerStatusView for monitoring server health
- Create StationCard for displaying radio station information
- Implement search bar with real-time updates
- Add loading and error states
- Support toggling between server status and radio content

This commit establishes the core functionality of the Radio Browser application
with proper server management and user interface.

Author: arya458

.idea/misc.xml

@@ -5,11 +5,29 @@ plugins {
     alias(libs.plugins.jetbrainsCompose)
 }
 
+repositories {
+    mavenCentral()
+    google()
+    maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
+    maven("https://jitpack.io")
+}
+
 kotlin {
-    jvm("desktop")
+    jvm("desktop") {
+        compilations.all {
+            kotlinOptions.jvmTarget = "17"
+        }
+    }
+    
     sourceSets {
-        val desktopMain by getting
-        val koin_version = "3.2.0"
+        val desktopMain by getting {
+            dependencies {
+                implementation(compose.desktop.currentOs)
+                implementation("ch.qos.logback:logback-classic:1.4.11")
+                implementation("org.slf4j:slf4j-api:2.0.9")
+            }
+        }
+        val koin_version = "4.0.3"
 
         commonMain.dependencies {
             implementation(compose.runtime)
@@ -18,38 +36,53 @@ kotlin {
             implementation(compose.ui)
             implementation(compose.components.resources)
             implementation(compose.components.uiToolingPreview)
-            implementation("de.sfuhrm:radiobrowser4j:3.0.0")
             implementation("com.darkrockstudios:mpfilepicker:3.1.0")
 
-            implementation("io.insert-koin:koin-core:$koin_version")
+            // Koin
+            implementation(platform("io.insert-koin:koin-bom:$koin_version"))
+            implementation("io.insert-koin:koin-core")
+            implementation("io.insert-koin:koin-core-coroutines")
+            implementation("io.insert-koin:koin-compose")
+            implementation("io.insert-koin:koin-compose-viewmodel")
+            implementation("io.insert-koin:koin-logger-slf4j")
+            
+            // Ktor for HTTP requests
+            implementation("io.ktor:ktor-client-core:2.3.8")
+            implementation("io.ktor:ktor-client-cio:2.3.8")
+            implementation("io.ktor:ktor-client-content-negotiation:2.3.8")
+            implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.8")
+            
             api("io.github.qdsfdhvh:image-loader:1.7.8")
             api("io.github.qdsfdhvh:image-loader-extension-moko-resources:1.7.8")
-//            implementation("io.insert-koin:koin-core-coroutines:$koin_version")
-//            implementation("io.insert-koin:koin-compose:$koin_version")
-            implementation("io.insert-koin:koin-logger-slf4j:$koin_version")
-
-
-        }
-        desktopMain.dependencies {
-            implementation(compose.desktop.currentOs)
         }
     }
 }
 
-
 compose.desktop {
     application {
-        mainClass = "MainKt"
+        mainClass = "main.MainKt"
+        jvmArgs += listOf("-Xmx2G")
+        buildTypes {
+            release {
+                proguard {
+                    configurationFiles.from("compose-desktop.pro")
+                }
+            }
+        }
         nativeDistributions {
             targetFormats(TargetFormat.Exe)
+            packageName = "RadioBrowser"
+            packageVersion = "1.0.0"
             windows {
                 iconFile.set(project.file("src/commonMain/composeResources/drawable/icon.ico"))
-                shortcut = true
             }
-            appResourcesRootDir.set(project.layout.projectDirectory.dir("resources"))
-            includeAllModules = true
-            packageName = "RadioBrowser"
-            packageVersion = "1.0.2"
         }
     }
 }
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "17"
+        freeCompilerArgs = listOf("-Xjsr305=strict")
+    }
+}

composeApp/build.gradle.kts

@@ -1,43 +1,18 @@
 package main.di
 
-import org.koin.core.module.dsl.bind
-import org.koin.core.module.dsl.createdAtStart
-import org.koin.core.module.dsl.singleOf
-import org.koin.core.module.dsl.withOptions
-import player.data.repository.PlayerImpl
-import org.koin.core.qualifier.named
 import org.koin.dsl.module
+import player.data.repository.PlayerImpl
 import player.domain.repository.PlayerRepository
 import player.presentation.viewmodel.PlayerViewModel
-
-
-val SharedModule = module(createdAtStart=true) {
-
-//    single<PlayerRepository>(named("playerRepository")) {
-//        PlayerImpl()
-//    }
-
-    singleOf(::PlayerImpl) withOptions {
-        // definition options
-        named("playerRepository")
-        bind<PlayerRepository>()
-        createdAtStart()
-    }
-
-
-    single<PlayerViewModel>{
-        PlayerViewModel()
-    } withOptions {
-        // definition options
-        named("playerViewModel")
-        createdAtStart()
-    }
-
-
-
-
-//    single<PlayerRepository> { PlayerImpl() as PlayerRepository } withOptions {
-//        named("playerRepository")
-//        createdAtStart()
-//    }
+import radio.data.api.RadioBrowserApi
+import radio.data.repository.RadioImpl
+import radio.domain.repository.RadioRepository
+import radio.presentation.viewmodel.RadioViewModel
+
+val sharedModule = module {
+    single<PlayerRepository> { PlayerImpl() }
+    single { RadioBrowserApi() }
+    single<RadioRepository> { RadioImpl(get()) }
+    single { PlayerViewModel(get()) }
+    single { RadioViewModel(get(), get()) }
 }

composeApp/src/desktopMain/kotlin/main.kt

@@ -1,42 +1,149 @@
 package main.presentation
 
+import androidx.compose.animation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import org.koin.java.KoinJavaComponent.getKoin
-import player.presentation.compose.SetupPlayer
-import player.presentation.viewmodel.PlayerViewModel
-import player.util.PlayerState
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import org.koin.compose.koinInject
 import radio.presentation.Page.RadioPage
+import player.presentation.viewmodel.PlayerViewModel
+import player.presentation.compose.SetupPlayer
+import radio.presentation.viewmodel.RadioViewModel
 
 @Composable
-fun App(player: PlayerViewModel = getKoin().get()) {
-    MaterialTheme() {
-
-
-
-
-        val playerState  by player.playerState.collectAsState()
-
-
-
-        Surface(Modifier.fillMaxSize(), color = MaterialTheme.colors.background) {
-            when (playerState) {
-
-                is PlayerState.Empty -> {
-
-                    SetupPlayer()
-
-                }
-
-                else -> {
-                    RadioPage()
-
+fun App() {
+    val radioViewModel: RadioViewModel = koinInject()
+    val playerViewModel: PlayerViewModel = koinInject()
+    val playerState by playerViewModel.playerState.collectAsState()
+
+    MaterialTheme(
+        colors = MaterialTheme.colors.copy(
+            primary = Color(0xFF2196F3),
+            secondary = Color(0xFF03DAC6),
+            background = Color(0xFF121212),
+            surface = Color(0xFF1E1E1E),
+            onPrimary = Color.White,
+            onSecondary = Color.Black,
+            onBackground = Color.White,
+            onSurface = Color.White,
+            onError = Color.White,
+            error = Color(0xFFCF6679)
+        ),
+        typography = MaterialTheme.typography.copy(
+            body1 = MaterialTheme.typography.body1.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Normal,
+                color = Color.White
+            ),
+            button = MaterialTheme.typography.button.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 14.sp,
+                fontWeight = FontWeight.Medium,
+                color = Color.White
+            ),
+            h1 = MaterialTheme.typography.h1.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 32.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            h2 = MaterialTheme.typography.h2.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 24.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            h3 = MaterialTheme.typography.h3.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 20.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            h4 = MaterialTheme.typography.h4.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            h5 = MaterialTheme.typography.h5.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            h6 = MaterialTheme.typography.h6.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 14.sp,
+                fontWeight = FontWeight.Bold,
+                color = Color.White
+            ),
+            subtitle1 = MaterialTheme.typography.subtitle1.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+                color = Color.White
+            ),
+            subtitle2 = MaterialTheme.typography.subtitle2.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 14.sp,
+                fontWeight = FontWeight.Medium,
+                color = Color.White
+            ),
+            caption = MaterialTheme.typography.caption.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 12.sp,
+                fontWeight = FontWeight.Normal,
+                color = Color.White
+            ),
+            overline = MaterialTheme.typography.overline.copy(
+                fontFamily = FontFamily.Default,
+                fontSize = 10.sp,
+                fontWeight = FontWeight.Normal,
+                color = Color.White
+            )
+        )
+    ) {
+        Surface(
+            modifier = Modifier.fillMaxSize(),
+            color = MaterialTheme.colors.background
+        ) {
+            AnimatedVisibility(
+                visible = true,
+                enter = fadeIn() + expandVertically(),
+                exit = fadeOut() + shrinkVertically()
+            ) {
+                if (playerState == null) {
+                    Card(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(16.dp),
+                        elevation = 8.dp,
+                        backgroundColor = MaterialTheme.colors.surface
+                    ) {
+                        SetupPlayer(playerViewModel)
+                    }
+                } else {
+                    Card(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(16.dp),
+                        elevation = 8.dp,
+                        backgroundColor = MaterialTheme.colors.surface
+                    ) {
+                        RadioPage(
+                            viewModel = radioViewModel,
+                            playerViewModel = playerViewModel
+                        )
+                    }
                 }
             }
         }
-
-
     }
 }

composeApp/src/desktopMain/kotlin/main/di/SharedModule.kt

@@ -1,15 +1,7 @@
 package player.presentation.viewmodel
 
-import de.sfuhrm.radiobrowser4j.Station
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.flow
 import org.koin.java.KoinJavaComponent
 import player.domain.repository.PlayerRepository
-import player.util.PlayerReadyState
-import player.util.PlayerState
 
 class SharedViewModel(private val player: PlayerRepository = KoinJavaComponent.getKoin().get()) {