mirror of
https://github.com/permissionlesstech/bitchat-android.git
synced 2026-08-15 06:56:30 +00:00
239 lines
11 KiB
Kotlin
239 lines
11 KiB
Kotlin
package com.bitchat.android.services
|
|
|
|
import android.content.Context
|
|
import android.util.Log
|
|
import com.bitchat.android.favorites.FavoriteControlMessage
|
|
import com.bitchat.android.mesh.MeshService
|
|
import com.bitchat.android.model.ReadReceipt
|
|
import com.bitchat.android.nostr.NostrTransport
|
|
|
|
/**
|
|
* Routes messages between local mesh transports and Nostr, matching iOS behavior.
|
|
*/
|
|
class MessageRouter private constructor(
|
|
private val context: Context,
|
|
private var mesh: MeshService,
|
|
private val nostr: NostrTransport
|
|
) {
|
|
enum class RouteResult {
|
|
MESH,
|
|
NOSTR,
|
|
QUEUED,
|
|
DROPPED
|
|
}
|
|
|
|
companion object {
|
|
private const val TAG = "MessageRouter"
|
|
@Volatile private var INSTANCE: MessageRouter? = null
|
|
fun tryGetInstance(): MessageRouter? = INSTANCE
|
|
fun getInstance(context: Context, mesh: MeshService): MessageRouter {
|
|
val instance = INSTANCE ?: synchronized(this) {
|
|
INSTANCE ?: run {
|
|
val nostr = NostrTransport.getInstance(context)
|
|
MessageRouter(context.applicationContext, mesh, nostr).also { instance ->
|
|
// Register for favorites changes to flush outbox
|
|
try {
|
|
com.bitchat.android.favorites.FavoritesPersistenceService.shared.addListener(instance.favoriteListener)
|
|
} catch (_: Exception) {}
|
|
INSTANCE = instance
|
|
}
|
|
}
|
|
}
|
|
// Always update mesh reference and sync peer ID
|
|
instance.mesh = mesh
|
|
instance.nostr.senderPeerID = mesh.myPeerID
|
|
return instance
|
|
}
|
|
}
|
|
|
|
// Outbox: peerID -> queued (content, nickname, messageID)
|
|
private val outbox = mutableMapOf<String, MutableList<Triple<String, String, String>>>()
|
|
|
|
// Listener for favorites changes to flush outbox when npub mapping appears/changes
|
|
private val favoriteListener = object: com.bitchat.android.favorites.FavoritesChangeListener {
|
|
|
|
override fun onFavoriteChanged(noiseKeyHex: String) {
|
|
flushOutboxFor(noiseKeyHex)
|
|
ContactIdentityResolver.peerIdForNoiseKeyHex(noiseKeyHex)?.let { flushOutboxFor(it) }
|
|
}
|
|
override fun onAllCleared() {
|
|
}
|
|
}
|
|
|
|
fun sendPrivate(content: String, toPeerID: String, recipientNickname: String, messageID: String): RouteResult {
|
|
val resolution = ContactDirectory.resolve(toPeerID)
|
|
val conversationID = resolution.conversationID
|
|
val meshTarget = resolution.meshPeerID ?: toPeerID.takeIf { ContactIdentityResolver.isMeshPeerId(it) }
|
|
val nostrTarget = resolution.noiseKeyHex ?: toPeerID
|
|
|
|
if (com.bitchat.android.nostr.GeohashAliasRegistry.contains(toPeerID)) {
|
|
Log.d(TAG, "Routing PM via Nostr (geohash) to alias ${toPeerID.take(12)}… id=${messageID.take(8)}…")
|
|
val recipientHex = com.bitchat.android.nostr.GeohashAliasRegistry.get(toPeerID)
|
|
if (recipientHex != null) {
|
|
val sourceGeohash = com.bitchat.android.nostr.GeohashConversationRegistry.get(toPeerID)
|
|
nostr.sendPrivateMessageGeohash(content, recipientHex, messageID, sourceGeohash)
|
|
return RouteResult.NOSTR
|
|
}
|
|
return RouteResult.DROPPED
|
|
}
|
|
|
|
val hasMesh = meshTarget?.let { isConnected(mesh, it) } == true
|
|
if (meshTarget != null && isReady(mesh, meshTarget)) {
|
|
Log.d(TAG, "Routing PM via mesh to ${meshTarget} msg_id=${messageID.take(8)}…")
|
|
mesh.sendPrivateMessage(content, meshTarget, recipientNickname, messageID)
|
|
return RouteResult.MESH
|
|
} else if (canSendViaNostr(nostrTarget)) {
|
|
Log.d(TAG, "Routing PM via Nostr to ${conversationID.take(32)}… msg_id=${messageID.take(8)}…")
|
|
nostr.sendPrivateMessage(content, nostrTarget, recipientNickname, messageID)
|
|
return RouteResult.NOSTR
|
|
} else {
|
|
Log.d(TAG, "Queued PM for ${conversationID} (no mesh, no Nostr mapping) msg_id=${messageID.take(8)}…")
|
|
val q = outbox.getOrPut(conversationID) { mutableListOf() }
|
|
q.add(Triple(content, recipientNickname, messageID))
|
|
resolution.noisePublicKey?.let { recipientNoiseKey ->
|
|
try {
|
|
com.bitchat.android.services.bridge.MeshBridgeService.depositCourierDrop(
|
|
content = content,
|
|
messageId = messageID,
|
|
recipientNoiseKey = recipientNoiseKey
|
|
)
|
|
} catch (e: Exception) {
|
|
Log.w(TAG, "Courier deposit failed: ${e.message}")
|
|
}
|
|
}
|
|
Log.d(TAG, "Initiating noise handshake after queueing PM for ${conversationID.take(16)}…")
|
|
if (hasMesh) meshTarget?.let { mesh.initiateNoiseHandshake(it) }
|
|
return RouteResult.QUEUED
|
|
}
|
|
}
|
|
|
|
fun sendReadReceipt(receipt: ReadReceipt, toPeerID: String) {
|
|
val resolution = ContactDirectory.resolve(toPeerID)
|
|
val meshTarget = resolution.meshPeerID ?: toPeerID.takeIf { ContactIdentityResolver.isMeshPeerId(it) }
|
|
val nostrTarget = resolution.noiseKeyHex ?: toPeerID
|
|
if (meshTarget != null && isReady(mesh, meshTarget)) {
|
|
Log.d(TAG, "Routing READ via mesh to ${meshTarget.take(8)}… id=${receipt.originalMessageID.take(8)}…")
|
|
mesh.sendReadReceipt(receipt.originalMessageID, meshTarget, mesh.getPeerNicknames()[meshTarget] ?: mesh.myPeerID)
|
|
} else {
|
|
Log.d(TAG, "Routing READ via Nostr to ${toPeerID.take(8)}… id=${receipt.originalMessageID.take(8)}…")
|
|
nostr.sendReadReceipt(receipt, nostrTarget)
|
|
}
|
|
}
|
|
|
|
fun sendDeliveryAck(messageID: String, toPeerID: String) {
|
|
// Mesh delivery ACKs are sent by the receiver automatically.
|
|
// Only route via Nostr when mesh path isn't available or when this is a geohash alias
|
|
if (com.bitchat.android.nostr.GeohashAliasRegistry.contains(toPeerID)) {
|
|
val recipientHex = com.bitchat.android.nostr.GeohashAliasRegistry.get(toPeerID)
|
|
if (recipientHex != null) {
|
|
nostr.sendDeliveryAckGeohash(messageID, recipientHex, try { com.bitchat.android.nostr.NostrIdentityBridge.getCurrentNostrIdentity(context)!! } catch (_: Exception) { return })
|
|
return
|
|
}
|
|
}
|
|
val resolution = ContactDirectory.resolve(toPeerID)
|
|
val meshTarget = resolution.meshPeerID ?: toPeerID.takeIf { ContactIdentityResolver.isMeshPeerId(it) }
|
|
if (!(meshTarget != null && (mesh.getPeerInfo(meshTarget)?.isConnected == true) && mesh.hasEstablishedSession(meshTarget))) {
|
|
nostr.sendDeliveryAck(messageID, resolution.noiseKeyHex ?: toPeerID)
|
|
}
|
|
}
|
|
|
|
fun sendFavoriteNotification(toPeerID: String, isFavorite: Boolean) {
|
|
val resolution = ContactDirectory.resolve(toPeerID)
|
|
val meshTarget = resolution.meshPeerID ?: toPeerID.takeIf { ContactIdentityResolver.isMeshPeerId(it) }
|
|
if (meshTarget != null && mesh.getPeerInfo(meshTarget)?.isConnected == true && mesh.hasEstablishedSession(meshTarget)) {
|
|
val myNpub = try { com.bitchat.android.nostr.NostrIdentityBridge.getCurrentNostrIdentity(context)?.npub } catch (_: Exception) { null }
|
|
val content = FavoriteControlMessage.encode(isFavorite, myNpub)
|
|
val nickname = mesh.getPeerNicknames()[meshTarget] ?: meshTarget
|
|
mesh.sendPrivateMessage(content, meshTarget, nickname, null)
|
|
} else {
|
|
nostr.sendFavoriteNotification(resolution.noiseKeyHex ?: toPeerID, isFavorite)
|
|
}
|
|
}
|
|
|
|
// Flush any queued messages for a specific peerID
|
|
fun flushOutboxFor(peerID: String) {
|
|
val conversationID = ContactDirectory.canonicalConversationId(peerID)
|
|
val queued = outbox[conversationID] ?: outbox[peerID] ?: return
|
|
if (queued.isEmpty()) return
|
|
Log.d(TAG, "Flushing outbox for ${conversationID.take(16)}… count=${queued.size}")
|
|
val iterator = queued.iterator()
|
|
while (iterator.hasNext()) {
|
|
val (content, nickname, messageID) = iterator.next()
|
|
val resolution = ContactDirectory.resolve(conversationID)
|
|
val meshTarget = resolution.meshPeerID
|
|
val nostrTarget = resolution.noiseKeyHex ?: conversationID
|
|
if (meshTarget != null && isReady(mesh, meshTarget)) {
|
|
mesh.sendPrivateMessage(content, meshTarget, nickname, messageID)
|
|
iterator.remove()
|
|
} else if (canSendViaNostr(nostrTarget)) {
|
|
nostr.sendPrivateMessage(content, nostrTarget, nickname, messageID)
|
|
iterator.remove()
|
|
}
|
|
}
|
|
if (queued.isEmpty()) {
|
|
outbox.remove(conversationID)
|
|
outbox.remove(peerID)
|
|
}
|
|
}
|
|
|
|
// Flush everything (rarely used)
|
|
fun flushAllOutbox() {
|
|
outbox.keys.toList().forEach { flushOutboxFor(it) }
|
|
}
|
|
|
|
private fun canSendViaNostr(peerID: String): Boolean {
|
|
return try {
|
|
val resolution = ContactDirectory.resolve(peerID)
|
|
if (resolution.isMutualFavorite && resolution.nostrPubkey != null) return true
|
|
val target = resolution.noiseKeyHex ?: peerID
|
|
if (ContactIdentityResolver.isNoiseKeyHex(target)) {
|
|
val noiseKey = ContactIdentityResolver.bytesFromHex(target) ?: return false
|
|
val fav = com.bitchat.android.favorites.FavoritesPersistenceService.shared.getFavoriteStatus(noiseKey)
|
|
fav?.isMutual == true && fav.peerNostrPublicKey != null
|
|
} else if (ContactIdentityResolver.isMeshPeerId(target)) {
|
|
val fav = com.bitchat.android.favorites.FavoritesPersistenceService.shared.getFavoriteStatus(target)
|
|
fav?.isMutual == true && fav.peerNostrPublicKey != null
|
|
} else {
|
|
false
|
|
}
|
|
} catch (_: Exception) { false }
|
|
}
|
|
|
|
private fun isConnected(service: MeshService, peerID: String): Boolean {
|
|
return try {
|
|
service.getPeerInfo(peerID)?.isConnected == true
|
|
} catch (_: Exception) {
|
|
false
|
|
}
|
|
}
|
|
|
|
private fun isReady(service: MeshService, peerID: String): Boolean {
|
|
return try {
|
|
service.getPeerInfo(peerID)?.isConnected == true &&
|
|
service.hasEstablishedSession(peerID)
|
|
} catch (_: Exception) {
|
|
false
|
|
}
|
|
}
|
|
|
|
// Called when mesh peer list changes; attempt to flush any matching outbox entries
|
|
fun onPeersUpdated(peers: List<String>) {
|
|
peers.forEach { pid ->
|
|
flushOutboxFor(pid)
|
|
val noiseHex = try {
|
|
mesh.getPeerInfo(pid)?.noisePublicKey?.let { ContactIdentityResolver.noiseKeyHex(it) }
|
|
} catch (_: Exception) { null }
|
|
noiseHex?.let { flushOutboxFor(it) }
|
|
}
|
|
}
|
|
|
|
// Called when a Noise session becomes established; flush both the mesh peerID and its noiseHex alias
|
|
fun onSessionEstablished(peerID: String) {
|
|
flushOutboxFor(peerID)
|
|
val noiseHex = try {
|
|
mesh.getPeerInfo(peerID)?.noisePublicKey?.let { ContactIdentityResolver.noiseKeyHex(it) }
|
|
} catch (_: Exception) { null }
|
|
noiseHex?.let { flushOutboxFor(it) }
|
|
}
|
|
}
|