Add connection recovery handler and lifecycle monitor

app/src/main/java/io/getstream/android/core/sample/SampleActivity.kt

@@ -28,6 +28,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -40,24 +41,38 @@ import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
 import io.getstream.android.core.api.StreamClient
 import io.getstream.android.core.api.authentication.StreamTokenProvider
-import io.getstream.android.core.api.model.connection.network.StreamNetworkState
+import io.getstream.android.core.api.model.connection.StreamConnectionState
+import io.getstream.android.core.api.model.connection.recovery.Recovery
 import io.getstream.android.core.api.model.value.StreamApiKey
 import io.getstream.android.core.api.model.value.StreamHttpClientInfoHeader
 import io.getstream.android.core.api.model.value.StreamToken
 import io.getstream.android.core.api.model.value.StreamUserId
 import io.getstream.android.core.api.model.value.StreamWsUrl
+import io.getstream.android.core.api.socket.listeners.StreamClientListener
+import io.getstream.android.core.api.subscribe.StreamSubscription
+import io.getstream.android.core.api.subscribe.StreamSubscriptionManager
 import io.getstream.android.core.sample.client.createStreamClient
 import io.getstream.android.core.sample.ui.ConnectionStateCard
-import io.getstream.android.core.sample.ui.NetworkInfoCard
 import io.getstream.android.core.sample.ui.theme.StreamandroidcoreTheme
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 
-class SampleActivity : ComponentActivity() {
+class SampleActivity : ComponentActivity(), StreamClientListener {
 
     val userId = StreamUserId.fromString("petar")
     var streamClient: StreamClient? = null
 
+    var handle: StreamSubscription? = null
+
+    override fun onRecovery(recovery: Recovery) {
+        super.onRecovery(recovery)
+        Log.d("SampleActivity", "Recovery: $recovery")
+    }
+
+    override fun onError(err: Throwable) {
+        super.onError(err)
+        Log.e("SampleActivity", "Error: $err")
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         val streamClient2 =
@@ -91,7 +106,21 @@ class SampleActivity : ComponentActivity() {
             )
         streamClient = streamClient2
         lifecycleScope.launch {
-            repeatOnLifecycle(Lifecycle.State.RESUMED) { streamClient?.connect() }
+            repeatOnLifecycle(Lifecycle.State.CREATED) { streamClient?.connect() }
+        }
+
+        if (handle == null) {
+            handle =
+                streamClient2
+                    .subscribe(
+                        this,
+                        options =
+                            StreamSubscriptionManager.Options(
+                                retention =
+                                    StreamSubscriptionManager.Options.Retention.KEEP_UNTIL_CANCELLED
+                            ),
+                    )
+                    .getOrThrow()
         }
         enableEdgeToEdge()
         setContent {
@@ -108,16 +137,43 @@ class SampleActivity : ComponentActivity() {
                     ) {
                         Greeting(name = "Android")
                         ClientInfo(streamClient = streamClient2)
+                        val state = streamClient?.connectionState?.collectAsStateWithLifecycle()
+                        val buttonState =
+                            when (state?.value) {
+                                is StreamConnectionState.Connected -> {
+                                    Triple(
+                                        "Disconnect",
+                                        true,
+                                        {
+                                            lifecycleScope.launch { streamClient?.disconnect() }
+                                            Unit
+                                        },
+                                    )
+                                }
+
+                                is StreamConnectionState.Connecting -> {
+                                    Triple("Connecting", false, { Unit })
+                                }
+
+                                else -> {
+                                    Triple(
+                                        "Connect",
+                                        true,
+                                        {
+                                            lifecycleScope.launch { streamClient?.connect() }
+                                            Unit
+                                        },
+                                    )
+                                }
+                            }
+                        Button(onClick = buttonState.third, enabled = buttonState.second) {
+                            Text(text = buttonState.first)
+                        }
                     }
                 }
             }
         }
     }
-
-    override fun onStop() {
-        runBlocking { streamClient?.disconnect() }
-        super.onStop()
-    }
 }
 
 @Composable
@@ -134,18 +190,8 @@ fun GreetingPreview() {
 @Composable
 fun ClientInfo(streamClient: StreamClient) {
     val state = streamClient.connectionState.collectAsStateWithLifecycle()
-    val networkSnapshot = streamClient.networkState.collectAsStateWithLifecycle()
     Log.d("SampleActivity", "Client state: ${state.value}")
-    val networkState = networkSnapshot.value
     Column(verticalArrangement = Arrangement.spacedBy(16.dp)) {
         ConnectionStateCard(state = state.value)
-        when (networkState) {
-            is StreamNetworkState.Available -> {
-                NetworkInfoCard(snapshot = networkState.snapshot)
-            }
-            else -> {
-                NetworkInfoCard(snapshot = null)
-            }
-        }
     }
 }

app/src/main/java/io/getstream/android/core/sample/client/StreamClient.kt

@@ -28,11 +28,13 @@ import io.getstream.android.core.api.model.value.StreamApiKey
 import io.getstream.android.core.api.model.value.StreamHttpClientInfoHeader
 import io.getstream.android.core.api.model.value.StreamUserId
 import io.getstream.android.core.api.model.value.StreamWsUrl
+import io.getstream.android.core.api.observers.lifecycle.StreamLifecycleMonitor
 import io.getstream.android.core.api.observers.network.StreamNetworkMonitor
 import io.getstream.android.core.api.processing.StreamBatcher
 import io.getstream.android.core.api.processing.StreamRetryProcessor
 import io.getstream.android.core.api.processing.StreamSerialProcessingQueue
 import io.getstream.android.core.api.processing.StreamSingleFlightProcessor
+import io.getstream.android.core.api.recovery.StreamConnectionRecoveryEvaluator
 import io.getstream.android.core.api.serialization.StreamEventSerialization
 import io.getstream.android.core.api.socket.StreamConnectionIdHolder
 import io.getstream.android.core.api.socket.StreamWebSocketFactory
@@ -109,6 +111,15 @@ fun createStreamClient(
                     logger = logProvider.taggedLogger("SCNetworkMonitorSubscriptions")
                 ),
         )
+    val lifecycleMonitor =
+        StreamLifecycleMonitor(
+            logger = logProvider.taggedLogger("SCLifecycleMonitor"),
+            subscriptionManager =
+                StreamSubscriptionManager(
+                    logger = logProvider.taggedLogger("SCLifecycleMonitorSubscriptions")
+                ),
+            lifecycle = androidComponentsProvider.lifecycle(),
+        )
 
     return StreamClient(
         scope = scope,
@@ -136,6 +147,12 @@ fun createStreamClient(
                     override fun deserialize(raw: String): Result<Unit> = Result.success(Unit)
                 }
             ),
+        lifecycleMonitor = lifecycleMonitor,
+        connectionRecoveryEvaluator =
+            StreamConnectionRecoveryEvaluator(
+                logger = logProvider.taggedLogger("SCConnectionRecoveryEvaluator"),
+                singleFlightProcessor = singleFlight,
+            ),
         batcher = batcher,
     )
 }

gradle/libs.versions.toml

@@ -11,6 +11,7 @@ junitVersion = "1.3.0"
 espressoCore = "3.7.0"
 appcompat = "1.7.1"
 kotlinxCoroutines = "1.10.2"
+lifecycleRuntime = "2.9.4"
 lintApi = "31.12.0"
 material = "1.12.0"
 jetbrainsKotlinJvm = "2.2.0"
@@ -35,6 +36,8 @@ annotationJvm = "1.9.1"
 [libraries]
 androidx-core = { module = "androidx.test:core", version.ref = "core" }
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-lifecycle-runtime = { module = "androidx.lifecycle:lifecycle-runtime", version.ref = "lifecycleRuntime" }
+androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "lifecycleRuntime" }
 detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }

gradle/scripts/sonar.gradle

@@ -22,6 +22,15 @@ ext.sonar.ignoreModules.each {
     ext.sonar.excludeFilter << "**/${it}/**"
 }
 
+
+def coverageReports = rootProject.subprojects
+    .findAll { !rootProject.ext.sonar.ignoreModules.contains(it.name) }
+    .collect { "${it.buildDir}/reports/kover/report.xml" }
+
+if (coverageReports.isEmpty()) {
+    coverageReports << "${rootProject.buildDir}/reports/kover/report.xml"
+}
+
 sonarqube {
     properties {
         property("sonar.host.url", "https://sonarcloud.io")
@@ -32,6 +41,13 @@ sonarqube {
         property "sonar.java.coveragePlugin", "jacoco"
         property "sonar.sourceEncoding", "UTF-8"
         property "sonar.java.binaries", "${rootDir}/**/build/tmp/java-classes/debug"
+        property "sonar.coverage.jacoco.xmlReportPaths", coverageReports.join(",")
         property "sonar.coverage.exclusions", rootProject.ext.sonar.excludeFilter
     }
 }
+
+tasks.named("sonar").configure {
+    rootProject.subprojects
+        .findAll { !rootProject.ext.sonar.ignoreModules.contains(it.name) }
+        .each { dependsOn("${it.path}:koverXmlReport") }
+}

stream-android-core/build.gradle.kts

@@ -65,6 +65,8 @@ dependencies {
 
     // Android
     implementation(libs.androidx.annotation.jvm)
+    implementation(libs.androidx.lifecycle.runtime)
+    implementation(libs.androidx.lifecycle.process)
 
     // Network
     implementation(libs.moshi)

stream-android-core/src/main/AndroidManifest.xml

@@ -18,5 +18,6 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
 
 </manifest>