Nostr geohash (#276)

* first nostr build * add test file * internet access * fix relay manager * fix serialization * demo service - remove later * fix nostr * event dedupe * dedupe * ui wip * can send messages * subscription works * works * favs * works * delete chat on change * fix mentions * remove autojoin channels * styling * adjust colors * ui changes * live updates working * use local timestamp * message history in background * robust * fixes * nicknames refresh optimization * nostr service * refactor nostr * style * geohash works * centralize colors * refactoring * disable DMs for now: click on peer nickname doesnt open chat list in geohash mode * use local time * less logging * robustness * scroll nickname * adjust some text
2026-07-25 00:45:22 +00:00 · 2025-08-22 19:09:18 +02:00
parent 848cffee07
commit 7243d841a3
35 changed files with 7859 additions and 171 deletions
@@ -10,6 +10,8 @@ import com.bitchat.android.mesh.BluetoothMeshDelegate
 import com.bitchat.android.mesh.BluetoothMeshService
 import com.bitchat.android.model.BitchatMessage
 import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.nostr.NostrGeohashService
+
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.delay
 import java.util.*
@@ -46,7 +48,6 @@ class ChatViewModel(
    val privateChatManager = PrivateChatManager(state, messageManager, dataManager, noiseSessionDelegate)
    private val commandProcessor = CommandProcessor(state, messageManager, channelManager, privateChatManager)
    private val notificationManager = NotificationManager(application.applicationContext)
-    
    // Delegate handler for mesh callbacks
    private val meshDelegateHandler = MeshDelegateHandler(
        state = state,
@@ -60,6 +61,16 @@ class ChatViewModel(
        getMeshService = { meshService }
    )
    
+    // Nostr and Geohash service - initialize singleton
+    private val nostrGeohashService = NostrGeohashService.initialize(
+        application = application,
+        state = state,
+        messageManager = messageManager,
+        privateChatManager = privateChatManager,
+        meshDelegateHandler = meshDelegateHandler,
+        coroutineScope = viewModelScope
+    )
+    
    // Expose state through LiveData (maintaining the same interface)
    val messages: LiveData<List<BitchatMessage>> = state.messages
    val connectedPeers: LiveData<List<String>> = state.connectedPeers
@@ -88,6 +99,11 @@ class ChatViewModel(
    val peerNicknames: LiveData<Map<String, String>> = state.peerNicknames
    val peerRSSI: LiveData<Map<String, Int>> = state.peerRSSI
    val showAppInfo: LiveData<Boolean> = state.showAppInfo
+    val selectedLocationChannel: LiveData<com.bitchat.android.geohash.ChannelID?> = state.selectedLocationChannel
+    val isTeleported: LiveData<Boolean> = state.isTeleported
+    val geohashPeople: LiveData<List<GeoPerson>> = state.geohashPeople
+    val teleportedGeo: LiveData<Set<String>> = state.teleportedGeo
+    val geohashParticipantCounts: LiveData<Map<String, Int>> = state.geohashParticipantCounts
    
    init {
        // Note: Mesh service delegate is now set by MainActivity
@@ -125,6 +141,15 @@ class ChatViewModel(
        // Initialize session state monitoring
        initializeSessionStateMonitoring()
        
+        // Initialize location channel state
+        nostrGeohashService.initializeLocationChannelState()
+        
+        // Initialize favorites persistence service
+        com.bitchat.android.favorites.FavoritesPersistenceService.initialize(getApplication())
+        
+        // Initialize Nostr integration
+        nostrGeohashService.initializeNostrIntegration()
+        
        // Note: Mesh service is now started by MainActivity
        
        // Show welcome message if no peers after delay
@@ -195,21 +220,15 @@ class ChatViewModel(
        
        // Check for commands
        if (content.startsWith("/")) {
-            commandProcessor.processCommand(content, meshService, meshService.myPeerID) { messageContent, mentions, channel ->
+            commandProcessor.processCommand(content, meshService, meshService.myPeerID, { messageContent, mentions, channel ->
                meshService.sendMessage(messageContent, mentions, channel)
-            }
+            }, this)
            return
        }
        
        val mentions = messageManager.parseMentions(content, meshService.getPeerNicknames().values.toSet(), state.getNicknameValue())
-        val channels = messageManager.parseChannels(content)
-        
-        // Auto-join mentioned channels
-        channels.forEach { channel ->
-            if (!state.getJoinedChannelsValue().contains(channel)) {
-                joinChannel(channel)
-            }
-        }
+        // REMOVED: Auto-join mentioned channels feature that was incorrectly parsing hashtags from @mentions
+        // This was causing messages like "test @jack#1234 test" to auto-join channel "#1234"
        
        val selectedPeer = state.getSelectedPrivateChatPeerValue()
        val currentChannelValue = state.getCurrentChannelValue()
@@ -227,46 +246,55 @@ class ChatViewModel(
                meshService.sendPrivateMessage(messageContent, peerID, recipientNicknameParam, messageId)
            }
        } else {
-            // Send public/channel message
-            val message = BitchatMessage(
-                sender = state.getNicknameValue() ?: meshService.myPeerID,
-                content = content,
-                timestamp = Date(),
-                isRelay = false,
-                senderPeerID = meshService.myPeerID,
-                mentions = if (mentions.isNotEmpty()) mentions else null,
-                channel = currentChannelValue
-            )
-            
-            if (currentChannelValue != null) {
-                channelManager.addChannelMessage(currentChannelValue, message, meshService.myPeerID)
-                
-                // Check if encrypted channel
-                if (channelManager.hasChannelKey(currentChannelValue)) {
-                    channelManager.sendEncryptedChannelMessage(
-                        content, 
-                        mentions, 
-                        currentChannelValue, 
-                        state.getNicknameValue(),
-                        meshService.myPeerID,
-                        onEncryptedPayload = { encryptedData ->
-                            // This would need proper mesh service integration
-                            meshService.sendMessage(content, mentions, currentChannelValue)
-                        },
-                        onFallback = {
-                            meshService.sendMessage(content, mentions, currentChannelValue)
-                        }
-                    )
-                } else {
-                    meshService.sendMessage(content, mentions, currentChannelValue)
-                }
+            // Check if we're in a location channel
+            val selectedLocationChannel = state.selectedLocationChannel.value
+            if (selectedLocationChannel is com.bitchat.android.geohash.ChannelID.Location) {
+                // Send to geohash channel via Nostr ephemeral event
+                nostrGeohashService.sendGeohashMessage(content, selectedLocationChannel.channel, meshService.myPeerID, state.getNicknameValue())
            } else {
-                messageManager.addMessage(message)
-                meshService.sendMessage(content, mentions, null)
+                // Send public/channel message via mesh
+                val message = BitchatMessage(
+                    sender = state.getNicknameValue() ?: meshService.myPeerID,
+                    content = content,
+                    timestamp = Date(),
+                    isRelay = false,
+                    senderPeerID = meshService.myPeerID,
+                    mentions = if (mentions.isNotEmpty()) mentions else null,
+                    channel = currentChannelValue
+                )
+                
+                if (currentChannelValue != null) {
+                    channelManager.addChannelMessage(currentChannelValue, message, meshService.myPeerID)
+                    
+                    // Check if encrypted channel
+                    if (channelManager.hasChannelKey(currentChannelValue)) {
+                        channelManager.sendEncryptedChannelMessage(
+                            content, 
+                            mentions, 
+                            currentChannelValue, 
+                            state.getNicknameValue(),
+                            meshService.myPeerID,
+                            onEncryptedPayload = { encryptedData ->
+                                // This would need proper mesh service integration
+                                meshService.sendMessage(content, mentions, currentChannelValue)
+                            },
+                            onFallback = {
+                                meshService.sendMessage(content, mentions, currentChannelValue)
+                            }
+                        )
+                    } else {
+                        meshService.sendMessage(content, mentions, currentChannelValue)
+                    }
+                } else {
+                    messageManager.addMessage(message)
+                    meshService.sendMessage(content, mentions, null)
+                }
            }
        }
    }
    
+
+    
    // MARK: - Utility Functions
    
    fun getPeerIDForNickname(nickname: String): String? {
@@ -323,6 +351,22 @@ class ChatViewModel(
        state.setPeerRSSI(rssiValues)
    }
    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
    // MARK: - Debug and Troubleshooting
    
    fun getDebugStatus(): String {
@@ -360,7 +404,7 @@ class ChatViewModel(
    // MARK: - Mention Autocomplete
    
    fun updateMentionSuggestions(input: String) {
-        commandProcessor.updateMentionSuggestions(input, meshService)
+        commandProcessor.updateMentionSuggestions(input, meshService, this)
    }
    
    fun selectMentionSuggestion(nickname: String, currentText: String): String {
@@ -423,6 +467,9 @@ class ChatViewModel(
        // Clear all notifications
        notificationManager.clearAllNotifications()
        
+        // Clear geohash message history
+        nostrGeohashService.clearGeohashMessageHistory()
+        
        // Reset nickname
        val newNickname = "anon${Random.nextInt(1000, 9999)}"
        state.setNickname(newNickname)
@@ -471,6 +518,79 @@ class ChatViewModel(
        }
    }
    
+
+    
+
+    
+
+    
+
+    
+    /**
+     * Get participant count for a specific geohash (5-minute activity window)
+     */
+    fun geohashParticipantCount(geohash: String): Int {
+        return nostrGeohashService.geohashParticipantCount(geohash)
+    }
+    
+    /**
+     * Begin sampling multiple geohashes for participant activity
+     */
+    fun beginGeohashSampling(geohashes: List<String>) {
+        nostrGeohashService.beginGeohashSampling(geohashes)
+    }
+    
+    /**
+     * End geohash sampling
+     */
+    fun endGeohashSampling() {
+        nostrGeohashService.endGeohashSampling()
+    }
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    /**
+     * Check if a geohash person is teleported (iOS-compatible)
+     */
+    fun isPersonTeleported(pubkeyHex: String): Boolean {
+        return nostrGeohashService.isPersonTeleported(pubkeyHex)
+    }
+    
+    /**
+     * Start geohash DM with pubkey hex (iOS-compatible)
+     */
+    fun startGeohashDM(pubkeyHex: String) {
+        nostrGeohashService.startGeohashDM(pubkeyHex) { convKey ->
+            startPrivateChat(convKey)
+        }
+    }
+    
+
+    
+
+    
+    fun selectLocationChannel(channel: com.bitchat.android.geohash.ChannelID) {
+        nostrGeohashService.selectLocationChannel(channel)
+    }
+    
+
+    
+
+    
+
+    
+
+    
    // MARK: - Navigation Management
    
    fun showAppInfo() {
@@ -525,4 +645,24 @@ class ChatViewModel(
            else -> false
        }
    }
+    
+    // MARK: - iOS-Compatible Color System
+    
+    /**
+     * Get consistent color for a mesh peer by ID (iOS-compatible)
+     */
+    fun colorForMeshPeer(peerID: String, isDark: Boolean): androidx.compose.ui.graphics.Color {
+        // Try to get stable Noise key, fallback to peer ID
+        val seed = "noise:${peerID.lowercase()}"
+        return colorForPeerSeed(seed, isDark).copy()
+    }
+    
+    /**
+     * Get consistent color for a Nostr pubkey (iOS-compatible)
+     */
+    fun colorForNostrPubkey(pubkeyHex: String, isDark: Boolean): androidx.compose.ui.graphics.Color {
+        return nostrGeohashService.colorForNostrPubkey(pubkeyHex, isDark)
+    }
+    
+
 }