bitchat/bitchat/ViewModels/ChatViewModelBootstrapper.swift
jack a2bafd7b3b Stop presence and the bridge cell once location access is revoked
Revoking location access mid-session left kind-20001 presence going to
the last region, province and city cells until relaunch, and kept the
mesh bridge's rendezvous on the last neighborhood cell. Both read
LocationStateManager.availableChannels, which outlived the permission,
and neither checked the permission itself.

- GeohashPresenceService checks the permission before each heartbeat
  and again after the decorrelation delay. The loop keeps running, so
  presence resumes once access comes back.
- The bridge's locationCell goes through BridgeService.ownLocationCell,
  which returns nil without authorization, so the rendezvous closes and
  no presence or message copy goes to the old cell.
- LocationStateManager forgets the last fix (channels and place names)
  when access is revoked, before the new permission state publishes. A
  fix CoreLocation delivers after the revocation is ignored and not
  geocoded, and a place-name lookup that lands late is dropped.

NearbyNotesCounter and GeoChannelCoordinator keep their own permission
checks. Three tests asserted that the channel list survives revocation;
they now assert it is cleared.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 19:31:14 -08:00

697 lines
31 KiB
Swift

import BitFoundation
import BitLogger
import Combine
import Foundation
struct ChatViewModelServiceBundle {
let commandProcessor: CommandProcessor
let messageRouter: MessageRouter
let privateChatManager: PrivateChatManager
let unifiedPeerService: UnifiedPeerService
let autocompleteService: AutocompleteService
let deduplicationService: MessageDeduplicationService
let publicMessagePipeline: PublicMessagePipeline
@MainActor
init(
keychain: KeychainManagerProtocol,
idBridge: NostrIdentityBridge,
identityManager: SecureIdentityStateManagerProtocol,
meshService: Transport,
outboxStore: MessageOutboxStore? = nil,
sfMetrics: StoreAndForwardMetrics? = nil
) {
let commandProcessor = CommandProcessor(identityManager: identityManager)
let privateChatManager = PrivateChatManager(meshService: meshService)
let unifiedPeerService = UnifiedPeerService(
meshService: meshService,
idBridge: idBridge,
identityManager: identityManager
)
let nostrTransport = NostrTransport(keychain: keychain, idBridge: idBridge)
nostrTransport.senderPeerID = meshService.myPeerID
let messageRouter = MessageRouter(
transports: [meshService, nostrTransport],
outboxStore: outboxStore,
metrics: sfMetrics
)
self.commandProcessor = commandProcessor
self.messageRouter = messageRouter
self.privateChatManager = privateChatManager
self.unifiedPeerService = unifiedPeerService
self.autocompleteService = AutocompleteService()
// Persist processed gift-wrap event IDs: NIP-59 randomizes their
// timestamps, so the 24h-lookback DM subscriptions redeliver the same
// events on every launch and only a cross-launch record stops the
// reprocessing (re-sent DELIVERED bursts, phantom-ack noise).
self.deduplicationService = MessageDeduplicationService(nostrEventStore: NostrProcessedEventStore())
self.publicMessagePipeline = PublicMessagePipeline()
}
}
@MainActor
final class ChatViewModelBootstrapper {
private unowned let viewModel: ChatViewModel
init(viewModel: ChatViewModel) {
self.viewModel = viewModel
}
static func loadPersistedReadReceipts(userDefaults: UserDefaults = .standard) -> Set<String> {
guard let data = userDefaults.data(forKey: "sentReadReceipts"),
let receipts = try? JSONDecoder().decode([String].self, from: data) else {
return []
}
return Set(receipts)
}
func configure() {
wireServiceGraph()
bindFeatureObjectChanges()
loadPersistedViewState()
configureTransport()
startRuntimeServices()
bindPeerService()
configureNoiseCallbacks()
bindTransferProgress()
configureGeoChannels()
configureGateway()
configureBridge()
configureBridgeCourier()
bindTeleportState()
requestNotifications()
registerObservers()
}
}
private extension ChatViewModelBootstrapper {
func wireServiceGraph() {
viewModel.privateChatManager.conversationStore = viewModel.conversations
viewModel.privateChatManager.messageRouter = viewModel.messageRouter
viewModel.privateChatManager.unifiedPeerService = viewModel.unifiedPeerService
viewModel.unifiedPeerService.messageRouter = viewModel.messageRouter
// Surface silent outbox drops (attempt cap, TTL expiry, overflow
// eviction) as a visible failure. The store's no-downgrade rule does
// not cover `.failed` over confirmed receipts, so guard here: a drop
// of an already-delivered/read message (e.g. a stale retained copy)
// must not downgrade its status.
viewModel.messageRouter.onMessageDropped = { [weak viewModel] messageID, peerID in
guard let viewModel else { return }
switch viewModel.conversations.deliveryStatus(forMessageID: messageID) {
case .delivered, .read:
// Field proof of the no-downgrade guard: the drop arrived
// after a confirmed receipt, so the `.failed` write is
// deliberately skipped.
SecureLogger.warning(
"📤 Router dropped message \(messageID.prefix(8))… for \(peerID.id.prefix(8))… → .failed skipped (already delivered/read)",
category: .session
)
default:
SecureLogger.warning(
"📤 Router dropped message \(messageID.prefix(8))… for \(peerID.id.prefix(8))… → marked failed",
category: .session
)
viewModel.conversations.setDeliveryStatus(
.failed(reason: String(localized: "content.delivery.reason.not_delivered", comment: "Failure reason shown when the router gave up delivering a message")),
forMessageID: messageID
)
}
}
// A message with no reachable transport that was handed to a courier
// shows a distinct "carried" state instead of sitting in "sending"
// forever. Never downgrade a confirmed receipt: the courier copy can
// race direct delivery when the peer reappears.
viewModel.messageRouter.onMessageCarried = { [weak viewModel] messageID, peerID in
guard let viewModel else { return }
switch viewModel.conversations.deliveryStatus(forMessageID: messageID) {
case .delivered, .read:
break
default:
SecureLogger.debug(
"📦 Message \(messageID.prefix(8))… for \(peerID.id.prefix(8))… handed to courier → marked carried",
category: .session
)
viewModel.conversations.setDeliveryStatus(.carried, forMessageID: messageID)
}
}
viewModel.commandProcessor.contextProvider = viewModel
viewModel.commandProcessor.meshService = viewModel.meshService
viewModel.participantTracker.configure(context: viewModel)
}
func bindFeatureObjectChanges() {
viewModel.privateChatManager.objectWillChange
.sink { [weak viewModel] _ in
viewModel?.objectWillChange.send()
}
.store(in: &viewModel.cancellables)
// Private message state flows through the single-writer
// `ConversationStore` intents and its `changes` subject; selection
// is owned by the store too (`PrivateChatManager.selectedPeer` is a
// read-only mirror), so no selection bridge is needed here.
viewModel.participantTracker.objectWillChange
.sink { [weak viewModel] _ in
viewModel?.objectWillChange.send()
}
.store(in: &viewModel.cancellables)
// Teleport markers describe people present now, so they follow the
// roster (pruned against it as it is when this runs, not the
// delivered snapshot). Nicknames don't: they name the authors of
// messages on screen, including replayed history from people no
// longer present, so they stay for the channel (cleared on switch,
// bounded by the store's capacity).
viewModel.participantTracker.$visiblePeople
.receive(on: DispatchQueue.main)
.sink { [weak viewModel] _ in
MainActor.assumeIsolated {
guard let viewModel else { return }
let visible = Set(viewModel.participantTracker.visiblePeople.map(\.id))
viewModel.locationPresenceStore.retainTeleportedGeo(keeping: visible)
}
}
.store(in: &viewModel.cancellables)
}
func loadPersistedViewState() {
viewModel.loadNickname()
viewModel.loadVerifiedFingerprints()
}
func configureTransport() {
viewModel.meshService.delegate = viewModel
viewModel.meshService.eventDelegate = viewModel
DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiStartupInitialDelaySeconds) { [weak viewModel] in
guard let viewModel else { return }
_ = viewModel.getMyFingerprint()
}
viewModel.meshService.setNickname(viewModel.nickname)
}
func startRuntimeServices() {
viewModel.meshService.startServices()
viewModel.publicMessagePipeline.delegate = viewModel.publicConversationCoordinator
loadArchivedEchoes()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak viewModel] in
guard let viewModel,
let radio = viewModel.meshService as? BluetoothStateReporting else { return }
viewModel.updateBluetoothState(radio.getCurrentBluetoothState())
}
viewModel.nostrRelayManager = NostrRelayManager.shared
viewModel.messageRouter.flushAllOutbox()
Task { @MainActor [weak viewModel] in
guard let viewModel else { return }
try? await Task.sleep(
nanoseconds: UInt64(TransportConfig.uiStartupPhaseDurationSeconds * 1_000_000_000)
)
viewModel.isStartupPhase = false
}
}
/// Surfaces the carried store-and-forward window (up to 6h of public
/// mesh messages, persisted across restarts) as dimmed "heard here
/// earlier" rows, so the mesh timeline opens with the place's memory
/// instead of a void. The archive restore runs async on the sync queue
/// right after transport start, so give it a beat before asking.
private func loadArchivedEchoes() {
DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiArchivedEchoLoadDelaySeconds) { [weak viewModel] in
guard let viewModel,
let archive = viewModel.meshService as? MeshPublicArchiving else { return }
archive.collectArchivedPublicMessages { [weak viewModel] allArchived in
guard let viewModel else { return }
// A previous /clear dismissed everything heard up to its
// watermark; only newer archive entries come back. Blocking a
// peer purges their carried messages from the archive at
// block time (when the fingerprint↔peerID mapping is known);
// the filter here is defense-in-depth for entries that slip
// past the purge (e.g. re-synced from a nearby peer), and it
// only resolves connected peers or favorites.
let clearedThrough = MeshEchoSettings.clearedThrough ?? .distantPast
let archived = allArchived.filter {
$0.timestamp > clearedThrough && !viewModel.isPeerBlocked($0.senderPeerID)
}
guard !archived.isEmpty else { return }
// Seed only an untouched timeline: with live rows already
// present (or after /clear) splicing history back in would
// be wrong.
guard viewModel.conversations.conversationsByID[.mesh]?.messages.isEmpty != false else { return }
for item in archived {
let echo = BitchatMessage(
id: BitchatMessage.archivedEchoIDPrefix + item.packetIdHex,
sender: item.senderNickname,
content: item.content,
timestamp: item.timestamp,
isRelay: false,
senderPeerID: item.senderPeerID
)
viewModel.publicConversationCoordinator.registerArchivedEcho(
senderPeerID: item.senderPeerID,
timestamp: item.timestamp,
content: item.content
)
_ = viewModel.appendPublicMessage(echo, to: .mesh)
}
if let firstTimestamp = archived.map(\.timestamp).min() {
// Echo-prefixed ID so the divider joins the tinted,
// dimmed echo block in the timeline.
let divider = BitchatMessage(
id: BitchatMessage.archivedEchoIDPrefix + "divider",
sender: "system",
content: String(localized: "content.echoes.divider", comment: "System line shown above dimmed archived messages replayed on the mesh timeline at launch"),
timestamp: firstTimestamp.addingTimeInterval(-1),
isRelay: false
)
_ = viewModel.appendPublicMessage(divider, to: .mesh)
}
}
}
}
func bindPeerService() {
viewModel.unifiedPeerService.$peers
.receive(on: DispatchQueue.main)
.sink { [weak viewModel] peers in
Task { @MainActor [weak viewModel] in
guard let viewModel else { return }
viewModel.allPeers = peers
var uniquePeers: [PeerID: BitchatPeer] = [:]
for peer in peers {
if uniquePeers[peer.peerID] == nil {
uniquePeers[peer.peerID] = peer
} else {
SecureLogger.warning(
"⚠️ Duplicate peer ID detected: \(peer.peerID) (\(peer.displayName))",
category: .session
)
}
}
viewModel.peerIndex = uniquePeers
if viewModel.hasTrackedPrivateChatSelection {
viewModel.updatePrivateChatPeerIfNeeded()
}
}
}
.store(in: &viewModel.cancellables)
}
func configureNoiseCallbacks() {
viewModel.setupNoiseCallbacks()
}
func bindTransferProgress() {
TransferProgressManager.shared.publisher
.receive(on: DispatchQueue.main)
.sink { [weak viewModel] event in
Task { @MainActor [weak viewModel] in
viewModel?.handleTransferEvent(event)
}
}
.store(in: &viewModel.cancellables)
}
func configureGeoChannels() {
viewModel.geoChannelCoordinator = GeoChannelCoordinator(
locationManager: viewModel.locationManager,
context: viewModel
)
}
/// Wires the gateway-mode policy layer (`GatewayService`) to the mesh
/// transport, the relay manager, and the inbound Nostr pipeline. All
/// dependencies are closures so the service stays unit-testable with
/// fakes.
func configureGateway() {
// Gateway mode bridges BLE mesh <-> Nostr; a mock transport (tests)
// has no carrier packets to bridge.
guard let bleService = viewModel.meshService as? MeshBridgingTransport else { return }
let gateway = GatewayService.shared
gateway.publishToRelays = { event, geohash in
let relays = GeoRelayDirectory.shared.closestRelays(
toGeohash: geohash,
count: TransportConfig.nostrGeoRelayCount
)
// Symmetric with the local send path (GeohashSubscriptionManager
// .sendGeohash): with no known geo relay, refuse rather than
// publish to default relays no geo subscriber reads — that would
// be silent dead traffic, not delivery.
guard !relays.isEmpty else {
SecureLogger.warning("🌐 Gateway: no geo relays for #\(geohash); not publishing carried event", category: .session)
return
}
NostrRelayManager.shared.sendEvent(event, to: relays)
}
gateway.broadcastToMesh = { [weak bleService] payload in
bleService?.broadcastNostrCarrier(payload)
}
gateway.sendToGatewayPeer = { [weak bleService] payload, peer in
bleService?.sendNostrCarrier(payload, to: peer) ?? false
}
gateway.availableGatewayPeers = { [weak bleService] in
bleService?.reachableGatewayPeers() ?? []
}
gateway.relaysConnected = { NostrRelayManager.shared.isConnected }
gateway.currentGeohash = { [weak viewModel] in viewModel?.currentGeohash }
// Carried events enter the same pipeline as relay-received events so
// blocking, rate limits, dedup, and rendering behave identically.
gateway.injectInbound = { [weak viewModel] event in
viewModel?.handleNostrEvent(event)
}
// The capability bit is advertised ONLY while the toggle is on; a
// change forces a re-announce so peers learn promptly.
gateway.onEnabledChanged = { [weak bleService] enabled in
bleService?.setLocalCapability(.gateway, enabled: enabled)
}
bleService.onNostrCarrierPacket = { payload, from, directedToUs in
// One decode, two policy engines: geohash-channel carriers go to
// the gateway, mesh-bridge carriers to the bridge.
guard let carrier = NostrCarrierPacket.decode(payload) else {
SecureLogger.debug("🌐 Gateway: dropping undecodable carrier from \(from.id.prefix(8))…", category: .session)
return
}
switch carrier.direction {
case .toGateway, .fromGateway:
GatewayService.shared.handleMeshCarrier(payload, from: from, directedToUs: directedToUs)
case .toBridge, .fromBridge:
BridgeService.shared.handleMeshCarrier(carrier, from: from, directedToUs: directedToUs)
}
}
// Uplinks deposited while relays were unreachable flush on reconnect.
// The publisher re-emits `true` on every relay state recompute, so
// dedupe: field logs showed presence published 5x in one second.
NostrRelayManager.shared.$isConnected
.removeDuplicates()
.receive(on: DispatchQueue.main)
.sink { connected in
if connected {
GatewayService.shared.flushQueuedUplinks()
BridgeService.shared.flushQueuedUplinks()
BridgeService.shared.publishPresence()
}
}
.store(in: &viewModel.cancellables)
// Apply the persisted toggle at launch.
if gateway.isEnabled {
bleService.setLocalCapability(.gateway, enabled: true)
}
}
/// Wires the mesh-bridge policy layer (`BridgeService`) to the mesh
/// transport, the relay manager, location, and the public timeline. Same
/// closure-injection style as `configureGateway`.
func configureBridge() {
guard let bleService = viewModel.meshService as? MeshBridgingTransport else { return }
let bridge = BridgeService.shared
let idBridge = viewModel.idBridge
bridge.publishToRelays = { event, cell in
let relays = GeoRelayDirectory.shared.closestRelays(
toGeohash: cell,
count: TransportConfig.nostrGeoRelayCount
)
guard !relays.isEmpty else {
SecureLogger.warning("🌉 Bridge: no geo relays for cell \(cell); not publishing", category: .session)
return
}
NostrRelayManager.shared.sendEvent(event, to: relays)
}
bridge.openSubscription = { cells in
guard let cell = cells.first else { return }
let relays = GeoRelayDirectory.shared.closestRelays(
toGeohash: cell,
count: TransportConfig.nostrGeoRelayCount
)
NostrRelayManager.shared.subscribe(
filter: .bridgeRendezvous(cells, since: Date().addingTimeInterval(-BridgeService.Limits.maxEventAgeSeconds)),
id: Self.bridgeSubscriptionID,
relayUrls: relays.isEmpty ? nil : relays,
handler: { event in
BridgeService.shared.handleRendezvousEvent(event)
}
)
}
bridge.closeSubscription = {
NostrRelayManager.shared.unsubscribe(id: Self.bridgeSubscriptionID)
}
bridge.relaysConnected = { NostrRelayManager.shared.isConnected }
bridge.locationCell = { [weak viewModel] in
guard let location = viewModel?.locationManager else { return nil }
return BridgeService.ownLocationCell(
from: location.availableChannels,
permission: location.permissionState
)
}
bridge.requestLocationFix = { [weak viewModel] in
viewModel?.locationManager.refreshChannels()
}
bridge.meshAdvertisedCell = { [weak bleService] in
bleService?.advertisedBridgeGeohash()
}
bridge.sendToBridgePeer = { [weak bleService] payload, peer in
bleService?.sendNostrCarrier(payload, to: peer) ?? false
}
bridge.availableBridgePeers = { [weak bleService] in
bleService?.reachableBridgePeers() ?? []
}
bridge.broadcastToMesh = { [weak bleService] payload in
bleService?.broadcastNostrCarrier(payload)
}
bridge.injectInbound = { [weak viewModel] inbound in
viewModel?.handlePublicMessage(BitchatMessage(
id: inbound.messageID,
sender: inbound.senderNickname,
content: inbound.content,
timestamp: inbound.timestamp,
isRelay: false,
senderPeerID: PeerID(bridge: inbound.senderPubkey),
isBridged: true
))
}
bridge.removeInjectedInbound = { [weak viewModel] messageID in
viewModel?.removeBridgeInjectedPublicMessage(withID: messageID)
}
bridge.isInjectedInboundPresent = { [weak viewModel] messageID in
viewModel?.bridgeInjectedPublicMessageIsPresent(withID: messageID) ?? false
}
bridge.isMessageSeenLocally = { [weak viewModel] messageID in
viewModel?.publicConversationContainsMessage(withID: messageID, in: .mesh) ?? false
}
bridge.deriveIdentity = { cell in
try idBridge.deriveIdentity(forBridgeRendezvous: cell)
}
bridge.myNickname = { [weak viewModel] in viewModel?.nickname ?? "" }
// The `.bridge` capability + cell TLV advertise serving duty: "send
// me deposits, and this is the island's cell". One switch: bridging
// with a known cell is serving (deposits queue through connectivity
// gaps, so the advertisement doesn't flap with the relays).
let updateAdvertisement: @MainActor () -> Void = { [weak bleService] in
let advertise = BridgeService.shared.isEnabled
&& BridgeService.shared.activeCell != nil
bleService?.setLocalBridgeGeohash(advertise ? BridgeService.shared.activeCell : nil)
bleService?.setLocalCapability(.bridge, enabled: advertise)
}
bridge.onEnabledChanged = { [weak viewModel] enabled in
updateAdvertisement()
// One switch collapses further: the bridge toggle also drives
// the geohash-channel gateway — bridging with internet means
// sharing it with the mesh around you, full stop.
GatewayService.shared.setEnabled(enabled)
// Flipping the switch is the user-initiated moment to ask for
// location if it was never asked; otherwise the bridge sits
// cell-less with only a settings caption explaining why.
if enabled, viewModel?.locationManager.permissionState == .notDetermined {
viewModel?.locationManager.enableLocationChannels()
}
}
bridge.onActiveCellChanged = { _ in updateAdvertisement() }
// Align a persisted split state (e.g. gateway enabled back when it
// had its own toggle) to the single switch at launch.
if GatewayService.shared.isEnabled != bridge.isEnabled {
GatewayService.shared.setEnabled(bridge.isEnabled)
}
// Location fixes (or losing them) move the rendezvous cell.
viewModel.locationManager.$availableChannels
.receive(on: DispatchQueue.main)
.sink { _ in BridgeService.shared.refreshRendezvous() }
.store(in: &viewModel.cancellables)
// The authorization callback lands asynchronously after launch; the
// bootstrap-time location request races it and silently no-ops, so
// re-enter when the permission state resolves (field bug: bridge
// stayed cell-less for a whole session).
viewModel.locationManager.$permissionState
.removeDuplicates()
.receive(on: DispatchQueue.main)
.sink { _ in BridgeService.shared.refreshRendezvous() }
.store(in: &viewModel.cancellables)
// Apply the persisted toggle at launch.
if bridge.isEnabled {
bridge.refreshRendezvous()
updateAdvertisement()
}
}
/// Wires courier-over-bridge (`BridgeCourierService`) to the relay
/// manager, the mesh transport's sealing/opening primitives, the courier
/// store, and the message router's deposit path.
func configureBridgeCourier() {
guard let bleService = viewModel.meshService as? MeshBridgingTransport else { return }
let courier = BridgeCourierService.shared
courier.bridgeEnabled = { BridgeService.shared.isEnabled }
// A geo/custom relay does not make a global courier drop durable.
// Require an actually connected default (DM) relay so `sendEvent`
// writes to at least one intended relay instead of only entering its
// process-local pending queue.
courier.relaysConnected = { NostrRelayManager.shared.isDMRelayConnected }
courier.publishEvent = { event, completion in
// Default (DM) relays: drops need the standing global relay set,
// not geo relays — sender and recipient share no cell.
// This confirmed path never falls back to the volatile relay
// queue; bridge dedup is committed only after NIP-20 OK.
NostrRelayManager.shared.sendEventImmediately(event, completion: completion)
}
courier.openSubscription = { tagsHex in
NostrRelayManager.shared.unsubscribe(id: Self.courierDropSubscriptionID)
NostrRelayManager.shared.subscribe(
filter: .courierDrops(
recipientTagsHex: tagsHex,
since: Date().addingTimeInterval(-CourierEnvelope.maxLifetimeSeconds)
),
id: Self.courierDropSubscriptionID,
handler: { event in
BridgeCourierService.shared.handleDropEvent(event)
}
)
}
courier.closeSubscription = {
NostrRelayManager.shared.unsubscribe(id: Self.courierDropSubscriptionID)
}
courier.myNoiseKey = { [weak bleService] in
bleService?.myNoiseStaticPublicKey()
}
courier.localVerifiedPeers = { [weak bleService] in
bleService?.verifiedPeersWithNoiseKeys() ?? []
}
courier.sealEnvelope = { [weak bleService] content, messageID, recipientKey in
bleService?.sealBridgeCourierEnvelope(content, messageID: messageID, recipientNoiseKey: recipientKey)
}
courier.openEnvelope = { [weak bleService] envelope in
bleService?.openBridgedCourierEnvelope(envelope) ?? false
}
courier.deliverToPeer = { [weak bleService] envelope, peerID in
bleService?.deliverBridgedEnvelope(envelope, to: peerID) ?? false
}
courier.heldEnvelopes = { cooldown in
CourierStore.shared.envelopesForBridgePublish(cooldown: cooldown)
}
courier.markHeldEnvelopePublished = { envelope in
CourierStore.shared.markBridgePublished(envelope)
}
viewModel.messageRouter.bridgeCourierDeposit = { content, messageID, recipientKey, completion in
BridgeCourierService.shared.depositDrop(
content: content,
messageID: messageID,
recipientNoiseKey: recipientKey,
completion: completion
)
}
// The completion flows back only after a default relay accepts the
// event, so a rejected or unacknowledged write never becomes carried.
viewModel.messageRouter.startBridgeDepositSweep()
bleService.onVerifiedPeerAnnounce = { _ in
Task { @MainActor in
BridgeCourierService.shared.refreshAfterVerifiedAnnounce()
}
}
// Relay connectivity gates everything; refresh (re)opens or closes.
// Deduped: refresh() resubscribes, and the raw publisher re-emits on
// every relay state recompute (6x in 300ms in field logs).
NostrRelayManager.shared.$isDMRelayConnected
.removeDuplicates()
.receive(on: DispatchQueue.main)
.sink { _ in BridgeCourierService.shared.refresh() }
.store(in: &viewModel.cancellables)
// Toggle changes re-evaluate the watch set.
BridgeService.shared.$isEnabled
.dropFirst()
.receive(on: DispatchQueue.main)
.sink { _ in BridgeCourierService.shared.refresh() }
.store(in: &viewModel.cancellables)
courier.refresh()
}
private static let bridgeSubscriptionID = "bridge-rendezvous"
private static let courierDropSubscriptionID = "bridge-courier-drops"
func bindTeleportState() {
viewModel.locationManager.$teleported
.receive(on: DispatchQueue.main)
.sink { [weak viewModel] isTeleported in
guard let viewModel else { return }
Task { @MainActor [weak viewModel] in
guard let viewModel,
case .location(let channel) = viewModel.activeChannel,
let identity = try? viewModel.idBridge.deriveIdentity(forGeohash: channel.geohash)
else {
return
}
let key = identity.publicKeyHex.lowercased()
let hasRegional = !viewModel.locationManager.availableChannels.isEmpty
let inRegional = viewModel.locationManager.availableChannels.contains {
$0.geohash == channel.geohash
}
if isTeleported && hasRegional && !inRegional {
viewModel.locationPresenceStore.markTeleported(key)
} else {
viewModel.locationPresenceStore.clearTeleported(key)
}
}
}
.store(in: &viewModel.cancellables)
}
func requestNotifications() {
NotificationService.shared.requestAuthorization()
}
func registerObservers() {
NotificationCenter.default.addObserver(
viewModel,
selector: #selector(ChatViewModel.handleFavoriteStatusChanged(_:)),
name: .favoriteStatusChanged,
object: nil
)
NotificationCenter.default.addObserver(
viewModel,
selector: #selector(ChatViewModel.handlePeerStatusUpdate(_:)),
name: Notification.Name("peerStatusUpdated"),
object: nil
)
}
}