refactor

composeApp/src/androidMain/kotlin/su/reya/coop/screens/HomeScreen.kt

@@ -155,7 +155,7 @@ fun HomeScreen() {
         onPauseOrDispose { }
     }
 
-    LaunchedEffect(Unit) {
+    LaunchedEffect(authState.signerRequired) {
         chatViewModel.refreshChatRooms()
     }
 

shared/src/commonMain/kotlin/su/reya/coop/Room.kt

@@ -41,8 +41,7 @@ data class Room(
     }
 
     companion object {
-        fun new(rumor: UnsignedEvent, userPubkey: PublicKey): Room {
-            val id = rumor.roomId()
+        fun new(rumor: UnsignedEvent, userPubkey: PublicKey, id: Long = rumor.roomId()): Room {
             val createdAt = rumor.createdAt()
             val subject = rumor.tags().toVec().find { it.kind() == "subject" }?.content()
 

shared/src/commonMain/kotlin/su/reya/coop/nostr/Messaging.kt

@@ -164,38 +164,35 @@ class MessageManager(private val nostr: Nostr) {
         try {
             val userPubkey =
                 signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
-
+            
             val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
             val kTag = SingleLetterTag.lowercase(Alphabet.K)
 
             // Get all DM events
             val filter = Filter().kind(kind).customTags(kTag, listOf("14", "dm"))
-            val events = client?.database()?.query(filter)
+            val events = client?.database()?.query(filter)?.toVec() ?: return null
 
             // Collect rooms
             val roomsMap: MutableMap<Long, Room> = mutableMapOf()
 
             events
-                ?.toVec()
-                ?.map { UnsignedEvent.fromJson(it.content()) }
-                ?.filter { it.tags().publicKeys().isNotEmpty() }
-                ?.forEach { event ->
-                    val newRoom = Room.new(rumor = event, userPubkey = userPubkey)
-                    val existingRoom = roomsMap[newRoom.id]
+                .map { UnsignedEvent.fromJson(it.content()) }
+                .filter { it.tags().publicKeys().isNotEmpty() }
+                .forEach { rumor ->
+                    val id = rumor.roomId()
+                    val isFromMe = rumor.author() == userPubkey
+                    val existing = roomsMap[id]
+                    val createdAt = rumor.createdAt()
 
-                    // Check if the room already exists
-                    if (existingRoom == null || newRoom.createdAt.asSecs() > existingRoom.createdAt.asSecs()) {
-                        val rTag = SingleLetterTag.lowercase(Alphabet.R)
-                        val filter = Filter().kind(kind).pubkey(userPubkey)
-                            .customTag(rTag, newRoom.id.toString())
-
-                        // Determine if it's an ongoing room
-                        val isOngoing =
-                            client?.database()?.query(filter)?.toVec()?.isNotEmpty() ?: false
-
-                        // Append room to map
-                        roomsMap[newRoom.id] =
-                            if (isOngoing) newRoom.copy(kind = RoomKind.Ongoing) else newRoom
+                    // If the room is new or the current rumor is newer than the existing one
+                    if (existing == null || createdAt.asSecs() > existing.createdAt.asSecs()) {
+                        // A room is "Ongoing" if it was already marked as such or if the current rumor is from the user
+                        val isOngoing = (existing?.kind == RoomKind.Ongoing) || isFromMe
+                        val room = Room.new(rumor = rumor, userPubkey = userPubkey, id = id)
+                        roomsMap[id] = if (isOngoing) room.copy(kind = RoomKind.Ongoing) else room
+                    } else if (isFromMe && existing.kind != RoomKind.Ongoing) {
+                        // If it's an older rumor but sent by the user, mark the room as Ongoing
+                        roomsMap[id] = existing.copy(kind = RoomKind.Ongoing)
                     }
                 }
 

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatViewModel.kt

@@ -24,7 +24,7 @@ import su.reya.coop.repository.MediaRepository
 import su.reya.coop.roomId
 
 data class ChatState(
-    val rooms: Set<Room> = emptySet(),
+    val rooms: Map<Long, Room> = emptyMap(),
     val isSyncing: Boolean = false,
     val isPartialProcessedGiftWrap: Boolean = false,
 )
@@ -48,8 +48,8 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
     private val _sentReports = MutableSharedFlow<Map<EventId, List<RelayUrl>>>()
     val sentReport = _sentReports.asSharedFlow()
 
-    val chatRooms = state.map { it.rooms }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptySet())
+    val chatRooms = state.map { it.rooms.values.sortedByDescending { it.createdAt.asSecs() } }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
 
     val isSyncing = state.map { it.isSyncing }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
@@ -69,8 +69,8 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
                         _state.update { it.copy(isPartialProcessedGiftWrap = true) }
                     }
 
-                    // Refresh UI every 10 messages OR when sync is fully done
-                    if (syncState.processedCount % 10 == 0 || !syncState.isSyncing) {
+                    // Refresh UI every 100 messages OR when sync is fully done
+                    if (syncState.processedCount % 100 == 0 || !syncState.isSyncing) {
                         refreshChatRooms()
                     }
                 }
@@ -80,16 +80,12 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
             launch {
                 nostr.newEvents.collect { event ->
                     val roomId = event.roomId()
-                    val existingRoom = _state.value.rooms.firstOrNull { it.id == roomId }
+                    val existingRoom = _state.value.rooms[roomId]
 
                     if (existingRoom == null) {
                         val currentUser = nostr.signer.getPublicKeyAsync() ?: return@collect
                         val newRoom = Room.new(event, currentUser)
-                        _state.update {
-                            it.copy(
-                                rooms = (it.rooms + newRoom).sortedDescending().toSet()
-                            )
-                        }
+                        _state.update { it.copy(rooms = it.rooms + (newRoom.id to newRoom)) }
                     } else {
                         updateRoomList(roomId, event)
                     }
@@ -97,9 +93,6 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
                     _newEvents.emit(event)
                 }
             }
-
-            // Initial load of rooms
-            refreshChatRooms()
         }
     }
 
@@ -120,7 +113,7 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
 
             // Check if the room already exists
             val id = rumor.roomId()
-            val existingRoom = _state.value.rooms.firstOrNull { it.id == id }
+            val existingRoom = _state.value.rooms[id]
 
             // If the room already exists, return its ID
             if (existingRoom != null) {
@@ -131,7 +124,7 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
             val room = Room.new(rumor, currentUser)
 
             // Update the chat rooms state
-            _state.update { it.copy(rooms = (it.rooms + room).sortedDescending().toSet()) }
+            _state.update { it.copy(rooms = it.rooms + (room.id to room)) }
 
             return room.id
         } catch (e: Exception) {
@@ -140,20 +133,16 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
     }
 
     fun getChatRoom(id: Long): Room? {
-        return _state.value.rooms.firstOrNull { it.id == id }
+        return _state.value.rooms[id]
     }
 
     suspend fun refreshChatRooms() {
         try {
             val rooms = nostr.messages.getChatRooms() ?: emptySet()
             _state.update { currentState ->
-                val merged = currentState.rooms.associateBy { it.id }.toMutableMap()
-                // Add or update rooms from the database
-                rooms.forEach { room ->
-                    merged[room.id] = room
-                }
-                // Return as a sorted set to maintain UI consistency
-                currentState.copy(rooms = merged.values.sortedDescending().toSet())
+                val newMap = currentState.rooms.toMutableMap()
+                rooms.forEach { room -> newMap[room.id] = room }
+                currentState.copy(rooms = newMap)
             }
         } catch (e: Exception) {
             showError("Error: ${e.message}")
@@ -235,24 +224,19 @@ class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
 
     private fun updateRoomList(roomId: Long, newMessage: UnsignedEvent) {
         _state.update { currentState ->
-            val updatedRooms = currentState.rooms.map { room ->
-                if (room.id == roomId) {
-                    room.copy(
-                        lastMessage = newMessage.content(),
-                        createdAt = newMessage.createdAt()
-                    )
-                } else {
-                    room
-                }
-            }.sortedDescending().toSet()
-            currentState.copy(rooms = updatedRooms)
+            val room = currentState.rooms[roomId] ?: return@update currentState
+            val updatedRoom = room.copy(
+                lastMessage = newMessage.content(),
+                createdAt = newMessage.createdAt()
+            )
+            currentState.copy(rooms = currentState.rooms + (roomId to updatedRoom))
         }
     }
 
     fun resetInternalState() {
         _state.update {
             it.copy(
-                rooms = emptySet(),
+                rooms = emptyMap(),
                 isPartialProcessedGiftWrap = false,
             )
         }

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt

@@ -71,7 +71,7 @@ class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
     private val profiles = mutableMapOf<PublicKey, MutableStateFlow<Profile?>>()
     private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
     private val seenPublicKeys = mutableSetOf<PublicKey>()
-    
+
     val isRelayListEmpty = appState.map { it.isRelayListEmpty }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
 
@@ -158,12 +158,14 @@ class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
         viewModelScope.launch {
             // Wait until the client is ready
             nostr.waitUntilInitialized()
+            val cache = nostr.profiles.getAllCacheMetadata()
 
-            nostr.profiles.getAllCacheMetadata().forEach { (pubkey, metadata) ->
-                // Update the metadata state
-                updateMetadata(pubkey, Profile(pubkey, metadata))
-                // Update seenPublicKeys to avoid duplicate requests
-                seenPublicKeys.add(pubkey)
+            profilesMutex.withLock {
+                cache.forEach { (pubkey, metadata) ->
+                    val profile = Profile(pubkey, metadata)
+                    profiles.getOrPut(pubkey) { MutableStateFlow(null) }.value = profile
+                    seenPublicKeys.add(pubkey)
+                }
             }
         }
     }
@@ -196,11 +198,9 @@ class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
         }
     }
 
-    private fun updateMetadata(pubkey: PublicKey, profile: Profile) {
-        viewModelScope.launch {
-            profilesMutex.withLock {
-                profiles.getOrPut(pubkey) { MutableStateFlow(null) }.value = profile
-            }
+    private suspend fun updateMetadata(pubkey: PublicKey, profile: Profile) {
+        profilesMutex.withLock {
+            profiles.getOrPut(pubkey) { MutableStateFlow(null) }.value = profile
         }
     }