Отправка гиф

client-mobile/chats/data/remote/signalr/ChatHubClient.kt

@@ -7,24 +7,36 @@ import com.microsoft.signalr.HubConnectionBuilder
 import com.microsoft.signalr.HubConnectionState
 import chats.data.remote.dto.ChatDto
 import chats.data.remote.dto.MessageDto
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 import javax.inject.Singleton
 
+import kotlinx.coroutines.delay
+
+enum class ConnectionStatus { CONNECTED, CONNECTING, DISCONNECTED }
+
 @Singleton
 class ChatHubClient @Inject constructor() {
     private var hubConnection: HubConnection? = null
     private val _events = MutableSharedFlow<ChatEvent>(extraBufferCapacity = 64)
     val events: SharedFlow<ChatEvent> = _events.asSharedFlow()
+    
+    private val _status = MutableStateFlow(ConnectionStatus.DISCONNECTED)
+    val status: StateFlow<ConnectionStatus> = _status.asStateFlow()
+
     private val scope = CoroutineScope(Dispatchers.IO)
+    private var lastBaseUrl: String? = null
+    private var lastToken: String? = null
 
     fun connect(baseUrl: String, accessToken: String) {
         if (hubConnection?.connectionState == HubConnectionState.CONNECTED) return
+        
+        lastBaseUrl = baseUrl
+        lastToken = accessToken
+        _status.value = ConnectionStatus.CONNECTING
 
         hubConnection = HubConnectionBuilder.create("${baseUrl}/chatHub")
             .withAccessTokenProvider(Single.just(accessToken))
@@ -33,16 +45,22 @@ class ChatHubClient @Inject constructor() {
         setupHandlers()
 
         hubConnection?.onClosed { exception ->
-            Log.e("ChatHubClient", "Connection closed", exception)
-            // Optional: Reconnect logic
+            Log.e("ChatHubClient", "Connection closed. Reconnecting...", exception)
+            _status.value = ConnectionStatus.DISCONNECTED
+            scope.launch {
+                delay(5000)
+                connect(baseUrl, accessToken)
+            }
         }
 
         scope.launch {
             try {
                 hubConnection?.start()?.blockingAwait()
+                _status.value = ConnectionStatus.CONNECTED
                 Log.d("ChatHubClient", "SignalR Connected")
             } catch (e: Exception) {
                 Log.e("ChatHubClient", "SignalR Connection Error", e)
+                _status.value = ConnectionStatus.DISCONNECTED
             }
         }
     }
@@ -94,5 +112,6 @@ class ChatHubClient @Inject constructor() {
 
     fun disconnect() {
         hubConnection?.stop()
+        _status.value = ConnectionStatus.DISCONNECTED
     }
 }

client-mobile/chats/data/repository/ChatRepositoryImpl.kt

@@ -32,8 +32,17 @@ class ChatRepositoryImpl @Inject constructor(
         return api.getMessages(chatId).map { it.toDomain(baseUrl) }
     }
 
-    override suspend fun sendMessage(chatId: String, content: String): Message {
-        val request = SendMessageRequest(content = content, type = "text")
+    override suspend fun sendMessage(
+        chatId: String, 
+        content: String?, 
+        type: String,
+        attachments: List<chats.data.remote.api.AttachmentRequest>?
+    ): Message {
+        val request = SendMessageRequest(
+            content = content, 
+            type = type,
+            attachments = attachments
+        )
         val baseUrl = serverConfig.getBaseUrl().removeSuffix("/api/")
         return api.sendMessage(chatId, request).toDomain(baseUrl)
     }
@@ -91,6 +100,7 @@ fun ChatDto.toDomain(currentUserId: String, baseUrl: String): Chat {
 
 fun MessageDto.toDomain(baseUrl: String): Message {
     val domainMediaType = when (type) {
+        "gif" -> MediaType.GIF
         "image", "photo" -> MediaType.IMAGE
         "video" -> MediaType.VIDEO
         "audio", "voice" -> MediaType.AUDIO