Use ConnectionErrorEvent model instead of APIError

GetStream · Jun 11, 2024 · aece3a5 · aece3a5
1 parent a61c4a9
commit aece3a5
Show file tree

Hide file tree

Showing 3 changed files with 29 additions and 34 deletions.
diff --git a/stream-video-android-core/api/stream-video-android-core.api b/stream-video-android-core/api/stream-video-android-core.api
@@ -10063,6 +10063,11 @@ public final class org/openapitools/client/models/UnpinResponse {
 	public fun toString ()Ljava/lang/String;
 }
 
+public final class org/openapitools/client/models/UnsupportedVideoEventException : java/lang/Exception {
+	public fun <init> (Ljava/lang/String;)V
+	public final fun getType ()Ljava/lang/String;
+}
+
 public final class org/openapitools/client/models/UpdateCallMembersRequest {
 	public fun <init> ()V
 	public fun <init> (Ljava/util/List;Ljava/util/List;)V

diff --git a/...-android-core/src/main/kotlin/io/getstream/video/android/core/socket/CoordinatorSocket.kt b/...-android-core/src/main/kotlin/io/getstream/video/android/core/socket/CoordinatorSocket.kt
@@ -26,10 +26,10 @@ import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
 import okhttp3.WebSocket
 import org.openapitools.client.infrastructure.Serializer
-import org.openapitools.client.models.APIError
 import org.openapitools.client.models.ConnectUserDetailsRequest
 import org.openapitools.client.models.ConnectedEvent
-import org.openapitools.client.models.UnknownVideoEvent
+import org.openapitools.client.models.ConnectionErrorEvent
+import org.openapitools.client.models.UnsupportedVideoEventException
 import org.openapitools.client.models.VideoEvent
 import org.openapitools.client.models.WSAuthMessageRequest
 
@@ -89,41 +89,35 @@ public class CoordinatorSocket(
 
         scope.launch(singleThreadDispatcher) {
             try {
-                // Try to parse an APIError first
-                Serializer.moshi.adapter(APIError::class.java).let { errorAdapter ->
-                    errorAdapter.fromJson(text)?.let { parsedError ->
-                        handleError(
-                            ErrorResponse(
-                                code = parsedError.code,
-                                message = parsedError.message,
-                                statusCode = parsedError.statusCode,
-                                exceptionFields = parsedError.exceptionFields ?: emptyMap(),
-                                moreInfo = parsedError.moreInfo,
-                            ),
-                        )
-                    }
+                Serializer.moshi.adapter(VideoEvent::class.java).let { eventAdapter ->
+                    eventAdapter.fromJson(text)?.let { parsedEvent -> processEvent(parsedEvent) }
                 }
             } catch (e: Throwable) {
-                // If parsing an APIError fails, try to parse a VideoEvent
-                // This will also catch unmapped events, that's why we parse APIError first
-                try {
-                    Serializer.moshi.adapter(VideoEvent::class.java).let { eventAdapter ->
-                        eventAdapter.fromJson(text)?.let { parsedEvent ->
-                            if (parsedEvent is UnknownVideoEvent) {
-                                logger.w { "[onMessage] Received unknown VideoEvent type: ${parsedEvent.expectedType}" }
-                            } else {
-                                processEvent(parsedEvent)
-                            }
-                        }
-                    }
-                } catch (e: Throwable) {
-                    logger.w { "[onMessage] VideoEvent parsing error ${e.message}" }
+                if (e.cause is UnsupportedVideoEventException) {
+                    val ex = e.cause as UnsupportedVideoEventException
+                    logger.w { "[onMessage] Received unsupported VideoEvent type: ${ex.type}. Ignoring." }
+                } else {
+                    logger.w { "[onMessage] VideoEvent parsing error ${e.message}." }
+                    handleError(e)
                 }
             }
         }
     }
 
     private suspend fun processEvent(parsedEvent: VideoEvent) {
+        if (parsedEvent is ConnectionErrorEvent) {
+            handleError(
+                ErrorResponse(
+                    code = parsedEvent.error?.code ?: -1,
+                    message = parsedEvent.error?.message ?: "",
+                    statusCode = parsedEvent.error?.statusCode ?: -1,
+                    exceptionFields = parsedEvent.error?.exceptionFields ?: emptyMap(),
+                    moreInfo = parsedEvent.error?.moreInfo ?: "",
+                ),
+            )
+            return
+        }
+
         if (parsedEvent is ConnectedEvent) {
             _connectionId.value = parsedEvent.connectionId
             setConnectedStateAndContinue(parsedEvent)

diff --git a/stream-video-android-core/src/main/kotlin/org/openapitools/client/models/VideoEvent.kt b/stream-video-android-core/src/main/kotlin/org/openapitools/client/models/VideoEvent.kt
@@ -168,8 +168,4 @@ class VideoEventAdapter : JsonAdapter<VideoEvent>() {
     }
 }
 
-data class UnknownVideoEvent(
-    @Json(name = "type") val expectedType: String
-) : VideoEvent() {
-    override fun getEventType() = "unknown"
-}
+class UnsupportedVideoEventException(val type: String) : Exception()