Чат, вложения

2026-04-14 21:53:44 +03:00
parent 118f8b8971
commit 58fdf1aca1
22 changed files with 799 additions and 125 deletions
@@ -16,6 +16,8 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import java.io.File
 import javax.inject.Inject
+import core.utils.copyUriToFile
+import core.utils.ImageUtils

 import chats.data.remote.api.KlipyGifDto

@@ -34,7 +36,10 @@ data class ChatDetailState(
    val recentGifs: List<KlipyGifDto> = emptyList(),
    val gifCategories: List<chats.data.remote.api.GifCategoryDto> = emptyList(),
    val isGifsLoading: Boolean = false,
-    val initialScrollIndex: Int? = null
+    val initialScrollIndex: Int? = null,
+    val pendingAttachments: List<File> = emptyList(),
+    val isUploading: Boolean = false,
+    val isCompressionEnabled: Boolean = true
 )

@HiltViewModel
@@ -42,7 +47,8 @@ class ChatDetailViewModel @Inject constructor(
    private val repository: ChatRepository,
    private val signalrClient: ChatHubClient,
    private val serverConfig: ServerConfig,
-    private val tokenManager: TokenManager
+    private val tokenManager: TokenManager,
+    @dagger.hilt.android.qualifiers.ApplicationContext private val context: android.content.Context
 ) : ViewModel() {

    private val _state = MutableStateFlow(ChatDetailState())
@@ -52,14 +58,26 @@ class ChatDetailViewModel @Inject constructor(
    private var typingTimerJob: Job? = null
    private var lastTypingSentTime: Long = 0

+    private val prefs = context.getSharedPreferences("chat_settings", android.content.Context.MODE_PRIVATE)
+
    init {
        val config = serverConfig.getServerConfig()
+        val savedCompression = prefs.getBoolean("compression_enabled", true)
        _state.update { it.copy(
            canCall = config.features.calls,
-            maxFileSize = config.limits.maxFileSize
+            maxFileSize = config.limits.maxFileSize,
+            isCompressionEnabled = savedCompression
        ) }
    }

+    fun toggleCompression() {
+        _state.update { currentState ->
+            val newValue = !currentState.isCompressionEnabled
+            prefs.edit().putBoolean("compression_enabled", newValue).apply()
+            currentState.copy(isCompressionEnabled = newValue)
+        }
+    }
+
    fun getCurrentUserId(): String {
        return tokenManager.getUserId() ?: ""
    }
@@ -181,18 +199,27 @@ class ChatDetailViewModel @Inject constructor(
    }
    fun sendMessage(text: String) {
        val chatId = currentChatId ?: return
-        if (text.isBlank()) return
+        val pending = _state.value.pendingAttachments
+        if (text.isBlank() && pending.isEmpty()) return

        val tempId = "temp_${System.currentTimeMillis()}"
        val userId = getCurrentUserId()
        
+        // Determine mediaType based on attachments
+        val mediaType = when {
+            pending.isEmpty() -> chats.domain.model.MediaType.TEXT
+            pending.any { it.extension.lowercase() in listOf("jpg", "jpeg", "png", "webp", "gif") } -> chats.domain.model.MediaType.IMAGE
+            pending.any { it.extension.lowercase() in listOf("mp4", "mov", "webm") } -> chats.domain.model.MediaType.VIDEO
+            else -> chats.domain.model.MediaType.TEXT
+        }
+
        val tempMessage = Message(
            id = tempId,
            chatId = chatId,
            senderId = userId,
-            content = text,
+            content = if (text.isBlank()) null else text,
            createdAt = java.util.Date().toString(),
-            mediaType = chats.domain.model.MediaType.TEXT,
+            mediaType = mediaType,
            media = emptyList(),
            senderName = "Вы",
            senderAvatar = null,
@@ -207,12 +234,40 @@ class ChatDetailViewModel @Inject constructor(

        viewModelScope.launch {
            try {
-                val sentMessage = repository.sendMessage(chatId, text)
+                // Upload attachments if any
+                val attachmentRequests = if (_state.value.pendingAttachments.isNotEmpty()) {
+                    _state.update { it.copy(isUploading = true) }
+                    val requests = _state.value.pendingAttachments.map { file ->
+                        val url = repository.uploadMedia(file)
+                        chats.data.remote.api.AttachmentRequest(
+                            type = when {
+                                file.extension.lowercase() in listOf("jpg", "jpeg", "png", "webp", "gif", "heic", "heif") -> "image"
+                                file.extension.lowercase() in listOf("mp4", "mov", "3gp", "mkv", "webm") -> "video"
+                                file.extension.lowercase() in listOf("mp3", "m4a", "wav", "aac", "ogg") -> "audio"
+                                else -> "file"
+                            },
+                            url = url,
+                            fileName = file.name,
+                            fileSize = file.length()
+                        )
+                    }
+                    _state.update { it.copy(isUploading = false, pendingAttachments = emptyList()) }
+                    requests
+                } else {
+                    null
+                }
+
+                val sentMessage = repository.sendMessage(
+                    chatId = chatId, 
+                    content = text,
+                    type = if (attachmentRequests != null) "media" else "text",
+                    attachments = attachmentRequests
+                )
                repository.deleteLocalMessage(tempId)
                repository.saveMessage(sentMessage)
            } catch (e: Exception) {
                repository.deleteLocalMessage(tempId)
-                _state.update { it.copy(error = e.localizedMessage) }
+                _state.update { it.copy(error = e.localizedMessage, isUploading = false) }
            }
        }
    }
@@ -227,6 +282,77 @@ class ChatDetailViewModel @Inject constructor(
        }
    }

+    fun sendVoiceMessage(file: File) {
+        val chatId = currentChatId ?: return
+        val tempId = "temp_voice_${System.currentTimeMillis()}"
+        val userId = getCurrentUserId()
+
+        val tempMessage = Message(
+            id = tempId,
+            chatId = chatId,
+            senderId = userId,
+            content = null,
+            createdAt = java.util.Date().toString(),
+            mediaType = chats.domain.model.MediaType.AUDIO,
+            media = emptyList(),
+            senderName = "Вы",
+            reactions = emptyMap(),
+            isRead = false,
+            sequenceId = 0
+        )
+
+        viewModelScope.launch {
+            repository.saveMessage(tempMessage)
+        }
+
+        viewModelScope.launch {
+            try {
+                // 1. Upload the audio file
+                val url = repository.uploadMedia(file)
+                
+                // 2. Send the message with the attachment
+                val attachment = chats.data.remote.api.AttachmentRequest(
+                    type = "voice",
+                    url = url,
+                    fileName = file.name,
+                    fileSize = file.length()
+                )
+                
+                val sentMessage = repository.sendMessage(
+                    chatId = chatId,
+                    content = null,
+                    type = "audio",
+                    attachments = listOf(attachment)
+                )
+
+                repository.deleteLocalMessage(tempId)
+                repository.saveMessage(sentMessage)
+            } catch (e: Exception) {
+                repository.deleteLocalMessage(tempId)
+                _state.update { it.copy(error = "Ошибка отправки голосового: ${e.localizedMessage}") }
+            }
+        }
+    }
+
+    fun addPendingAttachment(uri: android.net.Uri, context: android.content.Context) {
+        viewModelScope.launch {
+            val mimeType = context.contentResolver.getType(uri) ?: ""
+            val file = if (_state.value.isCompressionEnabled && mimeType.startsWith("image")) {
+                ImageUtils.compressImage(context, uri)
+            } else {
+                copyUriToFile(context, uri)
+            }
+            
+            file?.let { f ->
+                _state.update { it.copy(pendingAttachments = it.pendingAttachments + f) }
+            }
+        }
+    }
+
+    fun removePendingAttachment(file: File) {
+        _state.update { it.copy(pendingAttachments = it.pendingAttachments - file) }
+    }
+
    fun uploadMedia(file: File) {
        if (file.length() > _state.value.maxFileSize) {
            _state.update { it.copy(error = "File too large") }