Improve IO Exception on interceptors improve linter about asStateFlow

Author: aleksandar-apostolov

stream-android-core-lint/src/main/java/io/getstream/android/core/lint/detectors/ExposeAsStateFlowDetector.kt

@@ -51,23 +51,23 @@ class ExposeAsStateFlowDetector : Detector(), Detector.UastScanner {
         object : UElementHandler() {
 
             override fun visitField(node: UField) {
-                // Kotlin 'val state: StateFlow<T> = ...' compiles to a field with initializer
+                // Kotlin `val state: StateFlow<T> = ...` compiles to a field with initializer
                 checkPropertyInitializer(context, node, node.type, node.uastInitializer, node)
             }
 
             override fun visitVariable(node: UVariable) {
-                // top-level Kotlin 'val state: StateFlow<T> = ...'
+                // top-level Kotlin `val state: StateFlow<T> = ...`
                 checkPropertyInitializer(context, node, node.type, node.uastInitializer, node)
             }
 
             override fun visitMethod(node: UMethod) {
                 // Kotlin property getter or Java getter
-                // Only consider non-private, returning StateFlow<*>
                 if (!isApiVisible(node)) return
                 val returnType = node.returnType ?: return
                 if (!isStateFlowType(context, returnType)) return
 
                 val returnExpr = findReturnExpression(node) ?: return
+
                 // Ignore already-safe: receiver.asStateFlow()
                 if (isAlreadyAsStateFlowCall(returnExpr)) return
 
@@ -153,16 +153,26 @@ class ExposeAsStateFlowDetector : Detector(), Detector.UastScanner {
     }
 
     private fun isAlreadyAsStateFlowCall(expr: UExpression): Boolean {
-        // Match: <receiver>.asStateFlow()
-        val call = expr as? UCallExpression ?: return false
-        val name = call.methodName ?: return false
-        return name == "asStateFlow" && call.receiver != null
+        // Match: <receiver>.asStateFlow() or (<receiver>)?.asStateFlow()
+        return when (expr) {
+            is UCallExpression -> expr.methodName == "asStateFlow"
+            is UQualifiedReferenceExpression -> {
+                val call = expr.selector as? UCallExpression
+                call?.methodName == "asStateFlow"
+            }
+            else -> false
+        }
     }
 
     private fun isClearlyMutableQualified(expr: UExpression, context: JavaContext): Boolean {
         // Qualified reference like holder._state, where receiver or selector type is
         // MutableStateFlow
         val qualified = expr as? UQualifiedReferenceExpression ?: return false
+
+        // If this is X.asStateFlow(), it's already safe → don't mark as mutable
+        val selCall = qualified.selector as? UCallExpression
+        if (selCall?.methodName == "asStateFlow") return false
+
         val selType = qualified.selector.getExpressionType()
         val recvType = qualified.receiver.getExpressionType()
         return (selType != null && isMutableStateFlowType(context, selType)) ||
@@ -186,12 +196,12 @@ class ExposeAsStateFlowDetector : Detector(), Detector.UastScanner {
     }
 
     /**
-     * Extracts the returned expression from a getter or method. Handles both expression bodies and
-     * block bodies.
+     * Extracts the returned expression from a getter or method. Handles both block bodies (`return
+     * expr`) and expression-bodied getters (`get() = expr`).
      */
     private fun findReturnExpression(method: UMethod): UExpression? {
         val body = method.uastBody ?: return null
-        when (body) {
+        return when (body) {
             is UBlockExpression -> {
                 var last: UExpression? = null
                 body.accept(
@@ -202,10 +212,10 @@ class ExposeAsStateFlowDetector : Detector(), Detector.UastScanner {
                         }
                     }
                 )
-                return last
+                last
             }
+            else -> body as? UExpression // expression-bodied getter: get() = _state.asStateFlow()
         }
-        return null
     }
 
     companion object {

stream-android-core/src/main/java/io/getstream/android/core/api/model/exceptions/Exceptions.kt

@@ -16,7 +16,7 @@
 package io.getstream.android.core.api.model.exceptions
 
 import io.getstream.android.core.annotations.StreamCoreApi
-import okio.IOException
+import java.io.IOException
 
 /**
  * Base exception for all Stream client errors.
@@ -39,10 +39,14 @@ open class StreamClientException(message: String = "", cause: Throwable? = null)
  * @property message The error message describing the failure.
  * @property apiError The structured error response returned by the Stream API, if available, or
  *   `null` otherwise.
+ * @property cause The original exception that caused this error, if available, or `null` otherwise.
  */
 @StreamCoreApi
-class StreamEndpointException(message: String = "", val apiError: StreamEndpointErrorData?) :
-    IOException(message, null)
+class StreamEndpointException(
+    message: String = "",
+    val apiError: StreamEndpointErrorData? = null,
+    cause: Throwable? = null,
+) : IOException(message, cause)
 
 /**
  * Exception representing multiple errors that occurred during a single operation.

stream-android-core/src/main/java/io/getstream/android/core/internal/client/StreamClientImpl.kt

@@ -36,6 +36,7 @@ import io.getstream.android.core.internal.socket.model.ConnectUserData
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 
 internal class StreamClientImpl(
@@ -58,7 +59,7 @@ internal class StreamClientImpl(
 
     private var handle: StreamSubscription? = null
     override val connectionState: StateFlow<StreamConnectionState>
-        get() = mutableConnectionState
+        get() = mutableConnectionState.asStateFlow()
 
     override fun subscribe(listener: StreamClientListener): Result<StreamSubscription> =
         subscriptionManager.subscribe(listener)

stream-android-core/src/main/java/io/getstream/android/core/internal/http/interceptor/StreamApiKeyInterceptor.kt

@@ -15,7 +15,7 @@
  */
 package io.getstream.android.core.internal.http.interceptor
 
-import io.getstream.android.core.api.model.exceptions.StreamClientException
+import io.getstream.android.core.api.model.exceptions.StreamEndpointException
 import io.getstream.android.core.api.model.value.StreamApiKey
 import okhttp3.Interceptor
 import okhttp3.Response
@@ -42,7 +42,7 @@ internal class StreamApiKeyInterceptor(private val apiKey: StreamApiKey) : Inter
 
         if (apiKey.rawValue.isBlank()) {
             // StreamApiKey is self enforced via the fromString, but still we are defensive here
-            throw StreamClientException("API key must not be blank!")
+            throw StreamEndpointException("API key must not be blank!")
         }
 
         val urlWithApiKey =

stream-android-core/src/main/java/io/getstream/android/core/internal/http/interceptor/StreamAuthInterceptor.kt

@@ -61,7 +61,9 @@ internal class StreamAuthInterceptor(
     }
 
     override fun intercept(chain: Interceptor.Chain): Response {
-        val token = runBlocking { tokenManager.loadIfAbsent() }.getOrThrow()
+        val token =
+            runBlocking { tokenManager.loadIfAbsent() }
+                .getOrEndpointException("Failed to load token.")
         val original = chain.request()
         val authed = original.withAuthHeaders(authType, token.rawValue)
 
@@ -77,12 +79,16 @@ internal class StreamAuthInterceptor(
         val alreadyRetried = original.header(HEADER_RETRIED_ON_AUTH) == "present"
 
         if (parsed.isSuccess) {
-            val error = parsed.getOrThrow()
+            val error = parsed.getOrEndpointException("Failed to parse error body.")
             if (!alreadyRetried && isTokenInvalidErrorCode(error.code)) {
                 // Refresh and retry once.
                 firstResponse.close()
-                tokenManager.invalidate().getOrThrow()
-                val refreshed = runBlocking { tokenManager.refresh() }.getOrThrow()
+                tokenManager
+                    .invalidate()
+                    .getOrEndpointException(message = "Failed to invalidate token")
+                val refreshed =
+                    runBlocking { tokenManager.refresh() }
+                        .getOrEndpointException("Failed to refresh token")
 
                 val retried =
                     original
@@ -96,7 +102,7 @@ internal class StreamAuthInterceptor(
 
             // Non-token error or we already retried: surface a structured exception.
             firstResponse.close()
-            throw StreamEndpointException("Failed request: ${original.url}", error)
+            throw StreamEndpointException("Failed request: ${original.url}", error, null)
         } else {
             // Couldn’t parse error, still fail in a consistent way.
             firstResponse.close()
@@ -114,4 +120,8 @@ internal class StreamAuthInterceptor(
             .build()
 
     fun isTokenInvalidErrorCode(code: Int): Boolean = code == 40 || code == 41 || code == 42
+
+    private fun <T> Result<T>.getOrEndpointException(message: String = ""): T = getOrElse {
+        throw StreamEndpointException(message, null, it)
+    }
 }