Feat/network interface refresh

app/src/androidTest/java/tech/capullo/radio/RadioBroadcasterEspotiConnectTest.kt

@@ -4,13 +4,15 @@ import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.test.SemanticsMatcher
 import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
 import androidx.compose.ui.test.hasContentDescription
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.onRoot
 import androidx.compose.ui.test.printToLog
 import org.junit.Rule
 import org.junit.Test
+import tech.capullo.radio.data.RadioRepository.IPv4AddressesResult
 import tech.capullo.radio.snapcast.Client
 import tech.capullo.radio.ui.BroadcasterScreenContent
 import tech.capullo.radio.ui.model.AudioChannel
@@ -33,6 +35,7 @@ class RadioBroadcasterEspotiConnectTest {
             BroadcasterScreenContent(
                 uiState,
                 onAudioChannelChange = { },
+                onRefreshHostAddresses = { },
             )
         }
         composeTestRule.onRoot().printToLog("TAG")
@@ -64,6 +67,7 @@ class RadioBroadcasterEspotiConnectTest {
             BroadcasterScreenContent(
                 uiState,
                 onAudioChannelChange = { },
+                onRefreshHostAddresses = { },
             )
         }
         composeTestRule.onRoot().printToLog("TAG")
@@ -75,13 +79,15 @@ class RadioBroadcasterEspotiConnectTest {
     }
 
     @Test
-    fun whenPlayerReadyState_showsRabioBroadcasterPlaybackScreen() {
+    fun whenPlayerReadyState_showsRadioBroadcasterPlaybackScreen() {
         // Given: UI state is EspotiPlayerReady
-        val hostAddresses = listOf("192.168.0.1", "10.0.0.2")
+        var ipv4AddressesResult: IPv4AddressesResult = IPv4AddressesResult.Success(
+            listOf("192.168.0.1", "10.0.0.2"),
+        )
         val mockClients = emptyList<Client>()
 
-        val uiState = BroadcasterUiState.EspotiPlayerReady(
-            hostAddresses = hostAddresses,
+        var uiState = BroadcasterUiState.EspotiPlayerReady(
+            ipv4AddressesResult = ipv4AddressesResult,
             snapcastClients = mockClients,
             audioChannel = AudioChannel.STEREO,
         )
@@ -91,12 +97,19 @@ class RadioBroadcasterEspotiConnectTest {
             BroadcasterScreenContent(
                 uiState,
                 onAudioChannelChange = { },
+                onRefreshHostAddresses = { },
             )
         }
 
         // Then: Broadcaster host addresses are displayed
         composeTestRule.onNodeWithText("Host Addresses:").assertIsDisplayed()
         composeTestRule.onNodeWithText("192.168.0.1").assertIsDisplayed()
         composeTestRule.onNodeWithText("10.0.0.2").assertIsDisplayed()
+
+        val refreshIpAdressesButton = SemanticsMatcher.expectValue(
+            SemanticsProperties.Role,
+            Role.Button,
+        ) and hasContentDescription("Refresh ip addresses")
+        composeTestRule.onNode(refreshIpAdressesButton).assertIsEnabled()
     }
 }

app/src/main/java/tech/capullo/radio/data/RadioAdvertisingDataSource.kt

@@ -4,22 +4,24 @@ import android.content.Context
 import android.os.Build
 import android.provider.Settings
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import java.net.NetworkInterface
 import java.util.Collections
 import javax.inject.Inject
 
 class RadioAdvertisingDataSource @Inject constructor(
     @ApplicationContext private val applicationContext: Context,
 ) {
-    fun getInetAddresses(): List<String> =
-        Collections.list(NetworkInterface.getNetworkInterfaces()).flatMap { networkInterface ->
-            Collections.list(networkInterface.inetAddresses).filter { inetAddress ->
-                inetAddress.hostAddress != null &&
-                    inetAddress.hostAddress?.takeIf {
-                        it.indexOf(":") < 0 && !inetAddress.isLoopbackAddress
-                    }?.let { true } ?: false
-            }.map { it.hostAddress!! }
+    // TODO: injected dispatcher
+    suspend fun getIPv4Addresses(): List<String> = withContext(Dispatchers.Default) {
+        NetworkInterface.getNetworkInterfaces().toList().flatMap { networkInterface ->
+            networkInterface.inetAddresses.toList().filter { inetAddress ->
+                inetAddress.address.size == 4 && !inetAddress.isLoopbackAddress
+            }.map { it.hostAddress }
         }
+    }
 
     fun getDeviceName(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
         val deviceName = Settings.Global.getString(

app/src/main/java/tech/capullo/radio/data/RadioRepository.kt

@@ -14,7 +14,17 @@ class RadioRepository @Inject constructor(
 
     fun getCacheDirPath(): String = pipeFileDataSource.getCacheDirPath()
 
-    fun getInetAddresses(): List<String> = radioAdvertisingDataSource.getInetAddresses()
+    sealed class IPv4AddressesResult {
+        object Loading : IPv4AddressesResult()
+        data class Success(val addresses: List<String>) : IPv4AddressesResult()
+        data class Error(val message: String?) : IPv4AddressesResult()
+    }
+
+    suspend fun getIPv4Addresses(): IPv4AddressesResult = try {
+        IPv4AddressesResult.Success(radioAdvertisingDataSource.getIPv4Addresses())
+    } catch (e: Exception) {
+        IPv4AddressesResult.Error(e.message)
+    }
 
     fun getDeviceName(): String = radioAdvertisingDataSource.getDeviceName()
 

app/src/main/java/tech/capullo/radio/ui/BroadcasterScreen.kt

@@ -1,6 +1,9 @@
 package tech.capullo.radio.ui
 
 import android.content.res.Configuration.UI_MODE_NIGHT_YES
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -13,8 +16,10 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularWavyProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
@@ -28,17 +33,20 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import tech.capullo.radio.R
+import tech.capullo.radio.data.RadioRepository.IPv4AddressesResult
 import tech.capullo.radio.snapcast.Client
 import tech.capullo.radio.snapcast.ClientConfig
 import tech.capullo.radio.snapcast.Host
@@ -59,30 +67,33 @@ fun BroadcasterScreen(viewModel: BroadcasterViewModel = hiltViewModel()) {
     BroadcasterScreenContent(
         uiState = uiState,
         onAudioChannelChange = viewModel::updateAudioChannel,
+        onRefreshHostAddresses = viewModel::refreshIPv4Addresses,
     )
 }
 
 @Composable
 fun BroadcasterScreenContent(
     uiState: BroadcasterUiState,
     onAudioChannelChange: (AudioChannel) -> Unit,
+    onRefreshHostAddresses: () -> Unit,
 ) {
-    when (val state = uiState) {
+    when (uiState) {
         is BroadcasterUiState.EspotiPlayerReady -> {
             BroadcasterPlayback(
-                hostAddresses = state.hostAddresses,
-                snapcastClients = state.snapcastClients,
-                audioChannel = state.audioChannel,
+                ipv4AddressesResult = uiState.ipv4AddressesResult,
+                snapcastClients = uiState.snapcastClients,
+                audioChannel = uiState.audioChannel,
+                onRefreshHostAddresses = onRefreshHostAddresses,
                 onAudioChannelChange = onAudioChannelChange,
             )
         }
 
         is BroadcasterUiState.EspotiConnect -> {
-            if (state.isLoading) {
+            if (uiState.isLoading) {
                 LoadingSessionScreen()
             } else {
                 BroadcasterEspotiConnect(
-                    deviceName = state.deviceName,
+                    deviceName = uiState.deviceName,
                 )
             }
         }
@@ -91,9 +102,10 @@ fun BroadcasterScreenContent(
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable fun BroadcasterPlayback(
-    hostAddresses: List<String>,
+    ipv4AddressesResult: IPv4AddressesResult,
     snapcastClients: List<Client> = emptyList(),
     audioChannel: AudioChannel,
+    onRefreshHostAddresses: () -> Unit,
     onAudioChannelChange: (AudioChannel) -> Unit,
 ) {
     var showChannelDialog by remember { mutableStateOf(false) }
@@ -115,28 +127,7 @@ fun BroadcasterScreenContent(
                 .fillMaxSize()
                 .padding(innerPadding),
         ) {
-            Card(
-                modifier = Modifier
-                    .padding(vertical = 4.dp, horizontal = 8.dp)
-                    .fillMaxWidth(),
-                elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
-                shape = MaterialTheme.shapes.medium,
-            ) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Host Addresses:",
-                        style = Typography.bodyMedium,
-                    )
-                    LazyColumn(modifier = Modifier.padding(vertical = 4.dp)) {
-                        items(items = hostAddresses) { name ->
-                            Text(
-                                text = name,
-                                style = Typography.titleLarge,
-                            )
-                        }
-                    }
-                }
-            }
+            IPv4AddressesCard(ipv4AddressesResult, onRefreshHostAddresses)
 
             SnapclientList(snapcastClients)
         }
@@ -155,6 +146,74 @@ fun BroadcasterScreenContent(
     }
 }
 
+@Composable
+fun IPv4AddressesCard(
+    ipv4AddressesResult: IPv4AddressesResult,
+    onRefreshHostAddresses: () -> Unit,
+) {
+    Card(
+        modifier = Modifier
+            .padding(vertical = 4.dp, horizontal = 8.dp)
+            .fillMaxWidth(),
+        elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
+        shape = MaterialTheme.shapes.medium,
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(
+                    text = "Host Addresses:",
+                    style = Typography.titleLarge,
+                )
+                IconButton(
+                    onClick = {
+                        onRefreshHostAddresses()
+                    },
+                    enabled = ipv4AddressesResult !is IPv4AddressesResult.Loading,
+                ) {
+                    if (ipv4AddressesResult is IPv4AddressesResult.Loading) {
+                        @OptIn(ExperimentalMaterial3ExpressiveApi::class)
+                        // LoadingIndicator(modifier = Modifier.size(32.dp))
+                        CircularWavyProgressIndicator()
+                    } else {
+                        Icon(
+                            Icons.Filled.Refresh,
+                            contentDescription = "Refresh ip addresses",
+                            modifier = Modifier
+                                .size(32.dp),
+                        )
+                    }
+                }
+            }
+
+            when (ipv4AddressesResult) {
+                is IPv4AddressesResult.Success -> {
+                    LazyColumn(modifier = Modifier.padding(vertical = 4.dp)) {
+                        items(items = ipv4AddressesResult.addresses) { address ->
+                            Text(
+                                text = address,
+                                style = Typography.displaySmall,
+                            )
+                        }
+                    }
+                }
+                is IPv4AddressesResult.Error -> {
+                    Text(
+                        text =
+                        ipv4AddressesResult.message
+                            ?: "Error loading network interfaces",
+                        style = Typography.displaySmall,
+                    )
+                }
+                else -> Unit
+            }
+        }
+    }
+}
+
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun LoadingSessionScreen() {
@@ -233,6 +292,22 @@ fun PreviewBroadcasterEspotiConnect() {
     }
 }
 
+@Preview(
+    showBackground = true,
+    uiMode = UI_MODE_NIGHT_YES,
+    name = "PreviewLoadingIPv4AddressesCard",
+)
+@Preview(showBackground = true)
+@Composable
+fun PreviewLoadingIPv4AddressesCard() {
+    RadioTheme(schemeChoice = SchemeChoice.GREEN) {
+        IPv4AddressesCard(
+            ipv4AddressesResult = IPv4AddressesResult.Loading,
+            onRefreshHostAddresses = {},
+        )
+    }
+}
+
 @Preview(
     showBackground = true,
     uiMode = UI_MODE_NIGHT_YES,
@@ -258,7 +333,9 @@ fun PreviewLoadingIndicator() {
 )
 @Composable
 fun PreviewBroadcasterPlayback() {
-    val hostAddresses = listOf("192.168.0.1", "0.0.0.0", "100.10.14.7")
+    val ipv4AddressesResult = IPv4AddressesResult.Success(
+        listOf("192.168.0.1", "0.0.0.0", "100.10.14.7"),
+    )
 
     val sampleClients = listOf(
         Client(
@@ -334,10 +411,11 @@ fun PreviewBroadcasterPlayback() {
 
     RadioTheme(schemeChoice = SchemeChoice.GREEN) {
         BroadcasterPlayback(
-            hostAddresses = hostAddresses,
+            ipv4AddressesResult = ipv4AddressesResult,
             snapcastClients = sampleClients,
             audioChannel = AudioChannel.STEREO,
             onAudioChannelChange = { _: AudioChannel -> },
+            onRefreshHostAddresses = {},
         )
     }
 }