kopia lustrzana https://github.com/vitorpamplona/amethyst
2656 wiersze
86 KiB
Kotlin
2656 wiersze
86 KiB
Kotlin
/**
|
|
* Copyright (c) 2024 Vitor Pamplona
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
|
* Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
package com.vitorpamplona.amethyst.model
|
|
|
|
import android.content.res.Resources
|
|
import android.util.Log
|
|
import androidx.compose.runtime.Immutable
|
|
import androidx.compose.runtime.Stable
|
|
import androidx.core.os.ConfigurationCompat
|
|
import androidx.lifecycle.LiveData
|
|
import androidx.lifecycle.asFlow
|
|
import androidx.lifecycle.asLiveData
|
|
import androidx.lifecycle.liveData
|
|
import androidx.lifecycle.switchMap
|
|
import com.vitorpamplona.amethyst.Amethyst
|
|
import com.vitorpamplona.amethyst.BuildConfig
|
|
import com.vitorpamplona.amethyst.service.FileHeader
|
|
import com.vitorpamplona.amethyst.service.Nip96MediaServers
|
|
import com.vitorpamplona.amethyst.service.NostrLnZapPaymentResponseDataSource
|
|
import com.vitorpamplona.amethyst.service.checkNotInMainThread
|
|
import com.vitorpamplona.amethyst.service.relays.Client
|
|
import com.vitorpamplona.amethyst.service.relays.Constants
|
|
import com.vitorpamplona.amethyst.service.relays.FeedType
|
|
import com.vitorpamplona.amethyst.service.relays.Relay
|
|
import com.vitorpamplona.amethyst.ui.components.BundledUpdate
|
|
import com.vitorpamplona.quartz.crypto.KeyPair
|
|
import com.vitorpamplona.quartz.encoders.ATag
|
|
import com.vitorpamplona.quartz.encoders.HexKey
|
|
import com.vitorpamplona.quartz.encoders.Nip47WalletConnect
|
|
import com.vitorpamplona.quartz.encoders.hexToByteArray
|
|
import com.vitorpamplona.quartz.encoders.toHexKey
|
|
import com.vitorpamplona.quartz.events.BookmarkListEvent
|
|
import com.vitorpamplona.quartz.events.ChannelCreateEvent
|
|
import com.vitorpamplona.quartz.events.ChannelMessageEvent
|
|
import com.vitorpamplona.quartz.events.ChannelMetadataEvent
|
|
import com.vitorpamplona.quartz.events.ChatMessageEvent
|
|
import com.vitorpamplona.quartz.events.ClassifiedsEvent
|
|
import com.vitorpamplona.quartz.events.Contact
|
|
import com.vitorpamplona.quartz.events.ContactListEvent
|
|
import com.vitorpamplona.quartz.events.DeletionEvent
|
|
import com.vitorpamplona.quartz.events.DraftEvent
|
|
import com.vitorpamplona.quartz.events.EmojiPackEvent
|
|
import com.vitorpamplona.quartz.events.EmojiPackSelectionEvent
|
|
import com.vitorpamplona.quartz.events.EmojiUrl
|
|
import com.vitorpamplona.quartz.events.Event
|
|
import com.vitorpamplona.quartz.events.FileHeaderEvent
|
|
import com.vitorpamplona.quartz.events.FileServersEvent
|
|
import com.vitorpamplona.quartz.events.FileStorageEvent
|
|
import com.vitorpamplona.quartz.events.FileStorageHeaderEvent
|
|
import com.vitorpamplona.quartz.events.GeneralListEvent
|
|
import com.vitorpamplona.quartz.events.GenericRepostEvent
|
|
import com.vitorpamplona.quartz.events.GiftWrapEvent
|
|
import com.vitorpamplona.quartz.events.GitReplyEvent
|
|
import com.vitorpamplona.quartz.events.HTTPAuthorizationEvent
|
|
import com.vitorpamplona.quartz.events.LiveActivitiesChatMessageEvent
|
|
import com.vitorpamplona.quartz.events.LnZapEvent
|
|
import com.vitorpamplona.quartz.events.LnZapPaymentRequestEvent
|
|
import com.vitorpamplona.quartz.events.LnZapPaymentResponseEvent
|
|
import com.vitorpamplona.quartz.events.LnZapRequestEvent
|
|
import com.vitorpamplona.quartz.events.MetadataEvent
|
|
import com.vitorpamplona.quartz.events.MuteListEvent
|
|
import com.vitorpamplona.quartz.events.NIP24Factory
|
|
import com.vitorpamplona.quartz.events.OtsEvent
|
|
import com.vitorpamplona.quartz.events.PeopleListEvent
|
|
import com.vitorpamplona.quartz.events.PollNoteEvent
|
|
import com.vitorpamplona.quartz.events.Price
|
|
import com.vitorpamplona.quartz.events.PrivateDmEvent
|
|
import com.vitorpamplona.quartz.events.ReactionEvent
|
|
import com.vitorpamplona.quartz.events.RelayAuthEvent
|
|
import com.vitorpamplona.quartz.events.ReportEvent
|
|
import com.vitorpamplona.quartz.events.RepostEvent
|
|
import com.vitorpamplona.quartz.events.Response
|
|
import com.vitorpamplona.quartz.events.SealedGossipEvent
|
|
import com.vitorpamplona.quartz.events.StatusEvent
|
|
import com.vitorpamplona.quartz.events.TextNoteEvent
|
|
import com.vitorpamplona.quartz.events.TextNoteModificationEvent
|
|
import com.vitorpamplona.quartz.events.WrappedEvent
|
|
import com.vitorpamplona.quartz.events.ZapSplitSetup
|
|
import com.vitorpamplona.quartz.signers.NostrSigner
|
|
import com.vitorpamplona.quartz.signers.NostrSignerExternal
|
|
import com.vitorpamplona.quartz.signers.NostrSignerInternal
|
|
import com.vitorpamplona.quartz.utils.DualCase
|
|
import kotlinx.collections.immutable.ImmutableSet
|
|
import kotlinx.collections.immutable.persistentSetOf
|
|
import kotlinx.collections.immutable.toImmutableSet
|
|
import kotlinx.collections.immutable.toPersistentSet
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.DelicateCoroutinesApi
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
|
import kotlinx.coroutines.GlobalScope
|
|
import kotlinx.coroutines.flow.MutableStateFlow
|
|
import kotlinx.coroutines.flow.SharingStarted
|
|
import kotlinx.coroutines.flow.StateFlow
|
|
import kotlinx.coroutines.flow.combineTransform
|
|
import kotlinx.coroutines.flow.flattenMerge
|
|
import kotlinx.coroutines.flow.stateIn
|
|
import kotlinx.coroutines.flow.transformLatest
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.coroutines.suspendCancellableCoroutine
|
|
import kotlinx.coroutines.withContext
|
|
import kotlinx.coroutines.withTimeoutOrNull
|
|
import java.math.BigDecimal
|
|
import java.net.Proxy
|
|
import java.util.Locale
|
|
import java.util.UUID
|
|
import kotlin.coroutines.resume
|
|
|
|
val DefaultChannels =
|
|
setOf(
|
|
// Anigma's Nostr
|
|
"25e5c82273a271cb1a840d0060391a0bf4965cafeb029d5ab55350b418953fbb",
|
|
// Amethyst's Group
|
|
"42224859763652914db53052103f0b744df79dfc4efef7e950fc0802fc3df3c5",
|
|
)
|
|
|
|
val DefaultReactions =
|
|
listOf(
|
|
"\uD83D\uDE80",
|
|
"\uD83E\uDEC2",
|
|
"\uD83D\uDC40",
|
|
"\uD83D\uDE02",
|
|
"\uD83C\uDF89",
|
|
"\uD83E\uDD14",
|
|
"\uD83D\uDE31",
|
|
)
|
|
|
|
val DefaultZapAmounts = listOf(500L, 1000L, 5000L)
|
|
|
|
fun getLanguagesSpokenByUser(): Set<String> {
|
|
val languageList = ConfigurationCompat.getLocales(Resources.getSystem().getConfiguration())
|
|
val codedList = mutableSetOf<String>()
|
|
for (i in 0 until languageList.size()) {
|
|
languageList.get(i)?.let { codedList.add(it.language) }
|
|
}
|
|
return codedList
|
|
}
|
|
|
|
val GLOBAL_FOLLOWS =
|
|
" Global " // This has spaces to avoid mixing with a potential NIP-51 list with the same name.
|
|
val KIND3_FOLLOWS =
|
|
" All Follows " // This has spaces to avoid mixing with a potential NIP-51 list with the same
|
|
// name.
|
|
|
|
@OptIn(DelicateCoroutinesApi::class)
|
|
@Stable
|
|
class Account(
|
|
val keyPair: KeyPair,
|
|
val signer: NostrSigner = NostrSignerInternal(keyPair),
|
|
var localRelays: Set<RelaySetupInfo> = Constants.defaultRelays.toSet(),
|
|
var dontTranslateFrom: Set<String> = getLanguagesSpokenByUser(),
|
|
var languagePreferences: Map<String, String> = mapOf(),
|
|
var translateTo: String = Locale.getDefault().language,
|
|
var zapAmountChoices: List<Long> = DefaultZapAmounts,
|
|
var reactionChoices: List<String> = DefaultReactions,
|
|
var defaultZapType: LnZapEvent.ZapType = LnZapEvent.ZapType.PUBLIC,
|
|
var defaultFileServer: Nip96MediaServers.ServerName = Nip96MediaServers.DEFAULT[0],
|
|
var defaultHomeFollowList: MutableStateFlow<String> = MutableStateFlow(KIND3_FOLLOWS),
|
|
var defaultStoriesFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
|
|
var defaultNotificationFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
|
|
var defaultDiscoveryFollowList: MutableStateFlow<String> = MutableStateFlow(GLOBAL_FOLLOWS),
|
|
var zapPaymentRequest: Nip47WalletConnect.Nip47URI? = null,
|
|
var hideDeleteRequestDialog: Boolean = false,
|
|
var hideBlockAlertDialog: Boolean = false,
|
|
var hideNIP24WarningDialog: Boolean = false,
|
|
var backupContactList: ContactListEvent? = null,
|
|
var proxy: Proxy? = null,
|
|
var proxyPort: Int = 9050,
|
|
var showSensitiveContent: Boolean? = null,
|
|
var warnAboutPostsWithReports: Boolean = true,
|
|
var filterSpamFromStrangers: Boolean = true,
|
|
var lastReadPerRoute: Map<String, Long> = mapOf<String, Long>(),
|
|
var hasDonatedInVersion: Set<String> = setOf<String>(),
|
|
var pendingAttestations: Map<HexKey, String> = mapOf<HexKey, String>(),
|
|
val scope: CoroutineScope = Amethyst.instance.applicationIOScope,
|
|
) {
|
|
var transientHiddenUsers: ImmutableSet<String> = persistentSetOf()
|
|
|
|
data class PaymentRequest(
|
|
val relayUrl: String,
|
|
val description: String,
|
|
)
|
|
|
|
var transientPaymentRequestDismissals: Set<PaymentRequest> = emptySet()
|
|
val transientPaymentRequests: MutableStateFlow<Set<PaymentRequest>> = MutableStateFlow(emptySet())
|
|
|
|
// Observers line up here.
|
|
val live: AccountLiveData = AccountLiveData(this)
|
|
val liveLanguages: AccountLiveData = AccountLiveData(this)
|
|
val saveable: AccountLiveData = AccountLiveData(this)
|
|
|
|
@Immutable
|
|
class LiveFollowLists(
|
|
val users: ImmutableSet<String> = persistentSetOf(),
|
|
val hashtags: ImmutableSet<String> = persistentSetOf(),
|
|
val geotags: ImmutableSet<String> = persistentSetOf(),
|
|
val communities: ImmutableSet<String> = persistentSetOf(),
|
|
)
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
val liveKind3Follows: StateFlow<LiveFollowLists> by lazy {
|
|
userProfile()
|
|
.live()
|
|
.follows
|
|
.asFlow()
|
|
.transformLatest {
|
|
emit(
|
|
LiveFollowLists(
|
|
userProfile().cachedFollowingKeySet().toImmutableSet(),
|
|
userProfile().cachedFollowingTagSet().toImmutableSet(),
|
|
userProfile().cachedFollowingGeohashSet().toImmutableSet(),
|
|
userProfile().cachedFollowingCommunitiesSet().toImmutableSet(),
|
|
),
|
|
)
|
|
}
|
|
.stateIn(scope, SharingStarted.Eagerly, LiveFollowLists())
|
|
}
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
private val liveHomeList: StateFlow<NoteState?> by lazy {
|
|
defaultHomeFollowList
|
|
.transformLatest {
|
|
if (it != GLOBAL_FOLLOWS && it != KIND3_FOLLOWS) {
|
|
LocalCache.checkGetOrCreateAddressableNote(it)?.flow()?.metadata?.stateFlow?.let {
|
|
emit(it)
|
|
}
|
|
}
|
|
}
|
|
.flattenMerge()
|
|
.stateIn(scope, SharingStarted.Eagerly, null)
|
|
}
|
|
|
|
val liveHomeFollowLists: StateFlow<LiveFollowLists?> by lazy {
|
|
combineTransform(defaultHomeFollowList, liveKind3Follows, liveHomeList) {
|
|
listName,
|
|
kind3Follows,
|
|
peopleListFollows,
|
|
->
|
|
if (listName == GLOBAL_FOLLOWS) {
|
|
emit(null)
|
|
} else if (listName == KIND3_FOLLOWS) {
|
|
emit(kind3Follows)
|
|
} else {
|
|
val result =
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
decryptLiveFollows(peopleListFollows) { continuation.resume(it) }
|
|
}
|
|
}
|
|
result?.let { emit(it) } ?: run { emit(LiveFollowLists()) }
|
|
}
|
|
}
|
|
.stateIn(scope, SharingStarted.Eagerly, LiveFollowLists())
|
|
}
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
private val liveNotificationList: StateFlow<NoteState?> by lazy {
|
|
defaultNotificationFollowList
|
|
.transformLatest {
|
|
if (it != GLOBAL_FOLLOWS && it != KIND3_FOLLOWS) {
|
|
LocalCache.checkGetOrCreateAddressableNote(it)?.flow()?.metadata?.stateFlow?.let {
|
|
emit(it)
|
|
}
|
|
}
|
|
}
|
|
.flattenMerge()
|
|
.stateIn(scope, SharingStarted.Eagerly, null)
|
|
}
|
|
|
|
val liveNotificationFollowLists: StateFlow<LiveFollowLists?> by lazy {
|
|
combineTransform(defaultNotificationFollowList, liveKind3Follows, liveNotificationList) {
|
|
listName,
|
|
kind3Follows,
|
|
peopleListFollows,
|
|
->
|
|
if (listName == GLOBAL_FOLLOWS) {
|
|
emit(null)
|
|
} else if (listName == KIND3_FOLLOWS) {
|
|
emit(kind3Follows)
|
|
} else {
|
|
val result =
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
decryptLiveFollows(peopleListFollows) { continuation.resume(it) }
|
|
}
|
|
}
|
|
result?.let { emit(it) } ?: run { emit(LiveFollowLists()) }
|
|
}
|
|
}
|
|
.stateIn(scope, SharingStarted.Eagerly, LiveFollowLists())
|
|
}
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
private val liveStoriesList: StateFlow<NoteState?> by lazy {
|
|
defaultStoriesFollowList
|
|
.transformLatest {
|
|
if (it != GLOBAL_FOLLOWS && it != KIND3_FOLLOWS) {
|
|
LocalCache.checkGetOrCreateAddressableNote(it)?.flow()?.metadata?.stateFlow?.let {
|
|
emit(it)
|
|
}
|
|
}
|
|
}
|
|
.flattenMerge()
|
|
.stateIn(scope, SharingStarted.Eagerly, null)
|
|
}
|
|
|
|
val liveStoriesFollowLists: StateFlow<LiveFollowLists?> by lazy {
|
|
combineTransform(defaultStoriesFollowList, liveKind3Follows, liveStoriesList) {
|
|
listName,
|
|
kind3Follows,
|
|
peopleListFollows,
|
|
->
|
|
if (listName == GLOBAL_FOLLOWS) {
|
|
emit(null)
|
|
} else if (listName == KIND3_FOLLOWS) {
|
|
emit(kind3Follows)
|
|
} else {
|
|
val result =
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
decryptLiveFollows(peopleListFollows) { continuation.resume(it) }
|
|
}
|
|
}
|
|
result?.let { emit(it) } ?: run { emit(LiveFollowLists()) }
|
|
}
|
|
}
|
|
.stateIn(scope, SharingStarted.Eagerly, LiveFollowLists())
|
|
}
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
private val liveDiscoveryList: StateFlow<NoteState?> by lazy {
|
|
defaultDiscoveryFollowList
|
|
.transformLatest {
|
|
if (it != GLOBAL_FOLLOWS && it != KIND3_FOLLOWS) {
|
|
LocalCache.checkGetOrCreateAddressableNote(it)?.flow()?.metadata?.stateFlow?.let {
|
|
emit(it)
|
|
}
|
|
}
|
|
}
|
|
.flattenMerge()
|
|
.stateIn(scope, SharingStarted.Eagerly, null)
|
|
}
|
|
|
|
val liveDiscoveryFollowLists: StateFlow<LiveFollowLists?> by lazy {
|
|
combineTransform(defaultDiscoveryFollowList, liveKind3Follows, liveDiscoveryList) {
|
|
listName,
|
|
kind3Follows,
|
|
peopleListFollows,
|
|
->
|
|
if (listName == GLOBAL_FOLLOWS) {
|
|
emit(null)
|
|
} else if (listName == KIND3_FOLLOWS) {
|
|
emit(kind3Follows)
|
|
} else {
|
|
val result =
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
decryptLiveFollows(peopleListFollows) { continuation.resume(it) }
|
|
}
|
|
}
|
|
result?.let { emit(it) } ?: run { emit(LiveFollowLists()) }
|
|
}
|
|
}
|
|
.stateIn(scope, SharingStarted.Eagerly, LiveFollowLists())
|
|
}
|
|
|
|
private fun decryptLiveFollows(
|
|
peopleListFollows: NoteState?,
|
|
onReady: (LiveFollowLists) -> Unit,
|
|
) {
|
|
val listEvent = (peopleListFollows?.note?.event as? GeneralListEvent)
|
|
listEvent?.privateTags(signer) { privateTagList ->
|
|
onReady(
|
|
LiveFollowLists(
|
|
users =
|
|
(listEvent.bookmarkedPeople() + listEvent.filterUsers(privateTagList)).toImmutableSet(),
|
|
hashtags =
|
|
(listEvent.hashtags() + listEvent.filterHashtags(privateTagList)).toImmutableSet(),
|
|
geotags =
|
|
(listEvent.geohashes() + listEvent.filterGeohashes(privateTagList)).toImmutableSet(),
|
|
communities =
|
|
(listEvent.taggedAddresses() + listEvent.filterAddresses(privateTagList))
|
|
.map { it.toTag() }
|
|
.toImmutableSet(),
|
|
),
|
|
)
|
|
}
|
|
}
|
|
|
|
@Immutable
|
|
data class LiveHiddenUsers(
|
|
val hiddenUsers: ImmutableSet<String>,
|
|
val spammers: ImmutableSet<String>,
|
|
val hiddenWords: ImmutableSet<String>,
|
|
val hiddenWordsCase: List<DualCase>,
|
|
val showSensitiveContent: Boolean?,
|
|
)
|
|
|
|
val flowHiddenUsers: StateFlow<LiveHiddenUsers> by lazy {
|
|
combineTransform(
|
|
live.asFlow(),
|
|
getBlockListNote().flow().metadata.stateFlow,
|
|
getMuteListNote().flow().metadata.stateFlow,
|
|
) { localLive, blockList, muteList ->
|
|
checkNotInMainThread()
|
|
|
|
val resultBlockList =
|
|
(blockList.note.event as? PeopleListEvent)?.let {
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
it.publicAndPrivateUsersAndWords(signer) { continuation.resume(it) }
|
|
}
|
|
}
|
|
}
|
|
?: PeopleListEvent.UsersAndWords()
|
|
|
|
val resultMuteList =
|
|
(muteList.note.event as? MuteListEvent)?.let {
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
it.publicAndPrivateUsersAndWords(signer) { continuation.resume(it) }
|
|
}
|
|
}
|
|
}
|
|
?: PeopleListEvent.UsersAndWords()
|
|
|
|
val hiddenWords = resultBlockList.words + resultMuteList.words
|
|
|
|
emit(
|
|
LiveHiddenUsers(
|
|
hiddenUsers = (resultBlockList.users + resultMuteList.users).toPersistentSet(),
|
|
hiddenWords = hiddenWords.toPersistentSet(),
|
|
hiddenWordsCase = hiddenWords.map { DualCase(it.lowercase(), it.uppercase()) },
|
|
spammers = localLive.account.transientHiddenUsers,
|
|
showSensitiveContent = localLive.account.showSensitiveContent,
|
|
),
|
|
)
|
|
}
|
|
.stateIn(
|
|
scope,
|
|
SharingStarted.Eagerly,
|
|
LiveHiddenUsers(
|
|
hiddenUsers = persistentSetOf(),
|
|
hiddenWords = persistentSetOf(),
|
|
hiddenWordsCase = emptyList(),
|
|
spammers = transientHiddenUsers,
|
|
showSensitiveContent = showSensitiveContent,
|
|
),
|
|
)
|
|
}
|
|
|
|
val liveHiddenUsers = flowHiddenUsers.asLiveData()
|
|
|
|
val decryptBookmarks: LiveData<BookmarkListEvent?> by lazy {
|
|
userProfile().live().innerBookmarks.switchMap { userState ->
|
|
liveData(Dispatchers.IO) {
|
|
if (userState.user.latestBookmarkList == null) {
|
|
emit(null)
|
|
} else {
|
|
emit(
|
|
withTimeoutOrNull(1000) {
|
|
suspendCancellableCoroutine { continuation ->
|
|
userState.user.latestBookmarkList?.privateTags(signer) {
|
|
continuation.resume(userState.user.latestBookmarkList)
|
|
}
|
|
}
|
|
},
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addPaymentRequestIfNew(paymentRequest: PaymentRequest) {
|
|
if (
|
|
!this.transientPaymentRequests.value.contains(paymentRequest) &&
|
|
!this.transientPaymentRequestDismissals.contains(paymentRequest)
|
|
) {
|
|
this.transientPaymentRequests.value = transientPaymentRequests.value + paymentRequest
|
|
}
|
|
}
|
|
|
|
fun dismissPaymentRequest(request: PaymentRequest) {
|
|
if (this.transientPaymentRequests.value.contains(request)) {
|
|
this.transientPaymentRequests.value = transientPaymentRequests.value - request
|
|
this.transientPaymentRequestDismissals = transientPaymentRequestDismissals + request
|
|
}
|
|
}
|
|
|
|
var userProfileCache: User? = null
|
|
|
|
fun updateOptOutOptions(
|
|
warnReports: Boolean,
|
|
filterSpam: Boolean,
|
|
) {
|
|
warnAboutPostsWithReports = warnReports
|
|
filterSpamFromStrangers = filterSpam
|
|
LocalCache.antiSpam.active = filterSpamFromStrangers
|
|
if (!filterSpamFromStrangers) {
|
|
transientHiddenUsers = persistentSetOf()
|
|
}
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun userProfile(): User {
|
|
return userProfileCache
|
|
?: run {
|
|
val myUser: User = LocalCache.getOrCreateUser(keyPair.pubKey.toHexKey())
|
|
userProfileCache = myUser
|
|
myUser
|
|
}
|
|
}
|
|
|
|
fun isWriteable(): Boolean {
|
|
return keyPair.privKey != null || signer is NostrSignerExternal
|
|
}
|
|
|
|
fun sendNewRelayList(relays: Map<String, ContactListEvent.ReadWrite>) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.updateRelayList(
|
|
earlierVersion = contactList,
|
|
relayUse = relays,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = listOf(),
|
|
followTags = listOf(),
|
|
followGeohashes = listOf(),
|
|
followCommunities = listOf(),
|
|
followEvents = DefaultChannels.toList(),
|
|
relayUse = relays,
|
|
signer = signer,
|
|
) {
|
|
// Keep this local to avoid erasing a good contact list.
|
|
// Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendNewUserMetadata(
|
|
name: String? = null,
|
|
picture: String? = null,
|
|
banner: String? = null,
|
|
website: String? = null,
|
|
about: String? = null,
|
|
nip05: String? = null,
|
|
lnAddress: String? = null,
|
|
lnURL: String? = null,
|
|
twitter: String? = null,
|
|
mastodon: String? = null,
|
|
github: String? = null,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
MetadataEvent.updateFromPast(
|
|
latest = userProfile().latestMetadata,
|
|
name = name,
|
|
picture = picture,
|
|
banner = banner,
|
|
website = website,
|
|
about = about,
|
|
nip05 = nip05,
|
|
lnAddress = lnAddress,
|
|
lnURL = lnURL,
|
|
twitter = twitter,
|
|
mastodon = mastodon,
|
|
github = github,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
fun reactionTo(
|
|
note: Note,
|
|
reaction: String,
|
|
): List<Note> {
|
|
return note.reactedBy(userProfile(), reaction)
|
|
}
|
|
|
|
fun hasBoosted(note: Note): Boolean {
|
|
return boostsTo(note).isNotEmpty()
|
|
}
|
|
|
|
fun boostsTo(note: Note): List<Note> {
|
|
return note.boostedBy(userProfile())
|
|
}
|
|
|
|
fun hasReacted(
|
|
note: Note,
|
|
reaction: String,
|
|
): Boolean {
|
|
return note.hasReacted(userProfile(), reaction)
|
|
}
|
|
|
|
suspend fun reactTo(
|
|
note: Note,
|
|
reaction: String,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
if (hasReacted(note, reaction)) {
|
|
// has already liked this note
|
|
return
|
|
}
|
|
|
|
if (note.event is ChatMessageEvent) {
|
|
val event = note.event as ChatMessageEvent
|
|
val users = event.recipientsPubKey().plus(event.pubKey).toSet().toList()
|
|
|
|
if (reaction.startsWith(":")) {
|
|
val emojiUrl = EmojiUrl.decode(reaction)
|
|
if (emojiUrl != null) {
|
|
note.event?.let {
|
|
NIP24Factory().createReactionWithinGroup(
|
|
emojiUrl = emojiUrl,
|
|
originalNote = it,
|
|
to = users,
|
|
signer = signer,
|
|
) {
|
|
broadcastPrivately(it)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
note.event?.let {
|
|
NIP24Factory().createReactionWithinGroup(
|
|
content = reaction,
|
|
originalNote = it,
|
|
to = users,
|
|
signer = signer,
|
|
) {
|
|
broadcastPrivately(it)
|
|
}
|
|
}
|
|
return
|
|
} else {
|
|
if (reaction.startsWith(":")) {
|
|
val emojiUrl = EmojiUrl.decode(reaction)
|
|
if (emojiUrl != null) {
|
|
note.event?.let {
|
|
ReactionEvent.create(emojiUrl, it, signer) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
note.event?.let {
|
|
ReactionEvent.create(reaction, it, signer) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun createZapRequestFor(
|
|
note: Note,
|
|
pollOption: Int?,
|
|
message: String = "",
|
|
zapType: LnZapEvent.ZapType,
|
|
toUser: User?,
|
|
onReady: (LnZapRequestEvent) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
note.event?.let { event ->
|
|
LnZapRequestEvent.create(
|
|
event,
|
|
userProfile().latestContactList?.relays()?.keys?.ifEmpty { null }
|
|
?: localRelays.map { it.url }.toSet(),
|
|
signer,
|
|
pollOption,
|
|
message,
|
|
zapType,
|
|
toUser?.pubkeyHex,
|
|
onReady = onReady,
|
|
)
|
|
}
|
|
}
|
|
|
|
fun hasWalletConnectSetup(): Boolean {
|
|
return zapPaymentRequest != null
|
|
}
|
|
|
|
fun isNIP47Author(pubkeyHex: String?): Boolean {
|
|
return (getNIP47Signer().pubKey == pubkeyHex)
|
|
}
|
|
|
|
fun getNIP47Signer(): NostrSigner {
|
|
return zapPaymentRequest?.secret?.hexToByteArray()?.let { NostrSignerInternal(KeyPair(it)) }
|
|
?: signer
|
|
}
|
|
|
|
fun decryptZapPaymentResponseEvent(
|
|
zapResponseEvent: LnZapPaymentResponseEvent,
|
|
onReady: (Response) -> Unit,
|
|
) {
|
|
val myNip47 = zapPaymentRequest ?: return
|
|
|
|
val signer =
|
|
myNip47.secret?.hexToByteArray()?.let { NostrSignerInternal(KeyPair(it)) } ?: signer
|
|
|
|
zapResponseEvent.response(signer, onReady)
|
|
}
|
|
|
|
suspend fun calculateIfNoteWasZappedByAccount(
|
|
zappedNote: Note?,
|
|
onWasZapped: () -> Unit,
|
|
) {
|
|
zappedNote?.isZappedBy(userProfile(), this, onWasZapped)
|
|
}
|
|
|
|
fun calculateZappedAmount(
|
|
zappedNote: Note?,
|
|
onReady: (BigDecimal) -> Unit,
|
|
) {
|
|
zappedNote?.zappedAmountWithNWCPayments(getNIP47Signer(), onReady)
|
|
}
|
|
|
|
fun sendZapPaymentRequestFor(
|
|
bolt11: String,
|
|
zappedNote: Note?,
|
|
onResponse: (Response?) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
zapPaymentRequest?.let { nip47 ->
|
|
val signer =
|
|
nip47.secret?.hexToByteArray()?.let { NostrSignerInternal(KeyPair(it)) } ?: signer
|
|
|
|
LnZapPaymentRequestEvent.create(bolt11, nip47.pubKeyHex, signer) { event ->
|
|
val wcListener =
|
|
NostrLnZapPaymentResponseDataSource(
|
|
fromServiceHex = nip47.pubKeyHex,
|
|
toUserHex = event.pubKey,
|
|
replyingToHex = event.id,
|
|
authSigner = signer,
|
|
)
|
|
wcListener.start()
|
|
|
|
LocalCache.consume(event, zappedNote) { it.response(signer) { onResponse(it) } }
|
|
|
|
Client.send(event, nip47.relayUri, wcListener.feedTypes) { wcListener.destroy() }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun createZapRequestFor(
|
|
userPubKeyHex: String,
|
|
message: String = "",
|
|
zapType: LnZapEvent.ZapType,
|
|
onReady: (LnZapRequestEvent) -> Unit,
|
|
) {
|
|
LnZapRequestEvent.create(
|
|
userPubKeyHex,
|
|
userProfile().latestContactList?.relays()?.keys?.ifEmpty { null }
|
|
?: localRelays.map { it.url }.toSet(),
|
|
signer,
|
|
message,
|
|
zapType,
|
|
onReady = onReady,
|
|
)
|
|
}
|
|
|
|
suspend fun report(
|
|
note: Note,
|
|
type: ReportEvent.ReportType,
|
|
content: String = "",
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
if (note.hasReacted(userProfile(), "⚠️")) {
|
|
// has already liked this note
|
|
return
|
|
}
|
|
|
|
note.event?.let {
|
|
ReactionEvent.createWarning(it, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
|
|
note.event?.let {
|
|
ReportEvent.create(it, type, signer, content) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun report(
|
|
user: User,
|
|
type: ReportEvent.ReportType,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
if (user.hasReport(userProfile(), type)) {
|
|
// has already reported this note
|
|
return
|
|
}
|
|
|
|
ReportEvent.create(user.pubkeyHex, type, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
|
|
suspend fun delete(note: Note) {
|
|
if (note.isDraft()) {
|
|
note.event?.let {
|
|
val drafts = LocalCache.getDrafts(it.id())
|
|
return delete(drafts)
|
|
}
|
|
} else {
|
|
return delete(listOf(note))
|
|
}
|
|
}
|
|
|
|
suspend fun delete(notes: List<Note>) {
|
|
if (!isWriteable()) return
|
|
|
|
val myNotes = notes.filter { it.author == userProfile() }.mapNotNull { it.event?.id() }
|
|
|
|
if (myNotes.isNotEmpty()) {
|
|
DeletionEvent.create(myNotes, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun createHTTPAuthorization(
|
|
url: String,
|
|
method: String,
|
|
body: ByteArray? = null,
|
|
onReady: (HTTPAuthorizationEvent) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
HTTPAuthorizationEvent.create(url, method, body, signer, onReady = onReady)
|
|
}
|
|
|
|
suspend fun boost(note: Note) {
|
|
if (!isWriteable()) return
|
|
|
|
if (note.hasBoostedInTheLast5Minutes(userProfile())) {
|
|
// has already bosted in the past 5mins
|
|
return
|
|
}
|
|
|
|
note.event?.let {
|
|
if (it.kind() == 1) {
|
|
RepostEvent.create(it, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
GenericRepostEvent.create(it, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun broadcast(note: Note) {
|
|
note.event?.let {
|
|
if (note.isDraft()) {
|
|
val drafts = LocalCache.getDrafts(it.id())
|
|
drafts.forEach { draftNote ->
|
|
broadcast(draftNote)
|
|
}
|
|
} else {
|
|
if (it is WrappedEvent && it.host != null) {
|
|
it.host?.let { hostEvent -> Client.send(hostEvent) }
|
|
} else {
|
|
Client.send(it)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun updateAttestations() {
|
|
Log.d("Pending Attestations", "Updating ${pendingAttestations.size} pending attestations")
|
|
|
|
pendingAttestations.toMap().forEach { pair ->
|
|
val newAttestation = OtsEvent.upgrade(pair.value, pair.key)
|
|
|
|
if (pair.value != newAttestation) {
|
|
OtsEvent.create(pair.key, newAttestation, signer) {
|
|
LocalCache.justConsume(it, null)
|
|
Client.send(it)
|
|
|
|
pendingAttestations = pendingAttestations - pair.key
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun hasPendingAttestations(note: Note): Boolean {
|
|
val id = note.event?.id() ?: note.idHex
|
|
return pendingAttestations.get(id) != null
|
|
}
|
|
|
|
fun timestamp(note: Note) {
|
|
if (!isWriteable()) return
|
|
if (note.isDraft()) return
|
|
|
|
val id = note.event?.id() ?: note.idHex
|
|
|
|
pendingAttestations = pendingAttestations + Pair(id, OtsEvent.stamp(id))
|
|
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun follow(user: User) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null) {
|
|
ContactListEvent.followUser(contactList, user.pubkeyHex, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = listOf(Contact(user.pubkeyHex, null)),
|
|
followTags = emptyList(),
|
|
followGeohashes = emptyList(),
|
|
followCommunities = emptyList(),
|
|
followEvents = DefaultChannels.toList(),
|
|
relayUse =
|
|
Constants.defaultRelays.associate {
|
|
it.url to ContactListEvent.ReadWrite(it.read, it.write)
|
|
},
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun follow(channel: Channel) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null) {
|
|
ContactListEvent.followEvent(contactList, channel.idHex, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = emptyList(),
|
|
followTags = emptyList(),
|
|
followGeohashes = emptyList(),
|
|
followCommunities = emptyList(),
|
|
followEvents = DefaultChannels.toList().plus(channel.idHex),
|
|
relayUse =
|
|
Constants.defaultRelays.associate {
|
|
it.url to ContactListEvent.ReadWrite(it.read, it.write)
|
|
},
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun follow(community: AddressableNote) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null) {
|
|
ContactListEvent.followAddressableEvent(contactList, community.address, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
val relays =
|
|
Constants.defaultRelays.associate {
|
|
it.url to ContactListEvent.ReadWrite(it.read, it.write)
|
|
}
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = emptyList(),
|
|
followTags = emptyList(),
|
|
followGeohashes = emptyList(),
|
|
followCommunities = listOf(community.address),
|
|
followEvents = DefaultChannels.toList(),
|
|
relayUse = relays,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun followHashtag(tag: String) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null) {
|
|
ContactListEvent.followHashtag(
|
|
contactList,
|
|
tag,
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = emptyList(),
|
|
followTags = listOf(tag),
|
|
followGeohashes = emptyList(),
|
|
followCommunities = emptyList(),
|
|
followEvents = DefaultChannels.toList(),
|
|
relayUse =
|
|
Constants.defaultRelays.associate {
|
|
it.url to ContactListEvent.ReadWrite(it.read, it.write)
|
|
},
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun followGeohash(geohash: String) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null) {
|
|
ContactListEvent.followGeohash(
|
|
contactList,
|
|
geohash,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
} else {
|
|
ContactListEvent.createFromScratch(
|
|
followUsers = emptyList(),
|
|
followTags = emptyList(),
|
|
followGeohashes = listOf(geohash),
|
|
followCommunities = emptyList(),
|
|
followEvents = DefaultChannels.toList(),
|
|
relayUse =
|
|
Constants.defaultRelays.associate {
|
|
it.url to ContactListEvent.ReadWrite(it.read, it.write)
|
|
},
|
|
signer = signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
fun onNewEventCreated(event: Event) {
|
|
Client.send(event)
|
|
LocalCache.justConsume(event, null)
|
|
}
|
|
|
|
fun unfollow(user: User) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.unfollowUser(
|
|
contactList,
|
|
user.pubkeyHex,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
suspend fun unfollowHashtag(tag: String) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.unfollowHashtag(
|
|
contactList,
|
|
tag,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
suspend fun unfollowGeohash(geohash: String) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.unfollowGeohash(
|
|
contactList,
|
|
geohash,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
suspend fun unfollow(channel: Channel) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.unfollowEvent(
|
|
contactList,
|
|
channel.idHex,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
suspend fun unfollow(community: AddressableNote) {
|
|
if (!isWriteable()) return
|
|
|
|
val contactList = userProfile().latestContactList
|
|
|
|
if (contactList != null && contactList.tags.isNotEmpty()) {
|
|
ContactListEvent.unfollowAddressableEvent(
|
|
contactList,
|
|
community.address,
|
|
signer,
|
|
onReady = this::onNewEventCreated,
|
|
)
|
|
}
|
|
}
|
|
|
|
fun createNip95(
|
|
byteArray: ByteArray,
|
|
headerInfo: FileHeader,
|
|
alt: String?,
|
|
sensitiveContent: Boolean,
|
|
onReady: (Pair<FileStorageEvent, FileStorageHeaderEvent>) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
FileStorageEvent.create(
|
|
mimeType = headerInfo.mimeType ?: "",
|
|
data = byteArray,
|
|
signer = signer,
|
|
) { data ->
|
|
FileStorageHeaderEvent.create(
|
|
data,
|
|
mimeType = headerInfo.mimeType,
|
|
hash = headerInfo.hash,
|
|
size = headerInfo.size.toString(),
|
|
dimensions = headerInfo.dim,
|
|
blurhash = headerInfo.blurHash,
|
|
alt = alt,
|
|
sensitiveContent = sensitiveContent,
|
|
signer = signer,
|
|
) { signedEvent ->
|
|
onReady(
|
|
Pair(data, signedEvent),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun consumeAndSendNip95(
|
|
data: FileStorageEvent,
|
|
signedEvent: FileStorageHeaderEvent,
|
|
relayList: List<Relay>? = null,
|
|
): Note? {
|
|
if (!isWriteable()) return null
|
|
|
|
Client.send(data, relayList = relayList)
|
|
LocalCache.consume(data, null)
|
|
|
|
Client.send(signedEvent, relayList = relayList)
|
|
LocalCache.consume(signedEvent, null)
|
|
|
|
return LocalCache.getNoteIfExists(signedEvent.id)
|
|
}
|
|
|
|
fun consumeNip95(
|
|
data: FileStorageEvent,
|
|
signedEvent: FileStorageHeaderEvent,
|
|
): Note? {
|
|
LocalCache.consume(data, null)
|
|
LocalCache.consume(signedEvent, null)
|
|
|
|
return LocalCache.getNoteIfExists(signedEvent.id)
|
|
}
|
|
|
|
fun sendNip95(
|
|
data: FileStorageEvent,
|
|
signedEvent: FileStorageHeaderEvent,
|
|
relayList: List<Relay>? = null,
|
|
) {
|
|
Client.send(data, relayList = relayList)
|
|
Client.send(signedEvent, relayList = relayList)
|
|
}
|
|
|
|
fun sendHeader(
|
|
signedEvent: FileHeaderEvent,
|
|
relayList: List<Relay>? = null,
|
|
onReady: (Note) -> Unit,
|
|
) {
|
|
Client.send(signedEvent, relayList = relayList)
|
|
LocalCache.consume(signedEvent, null)
|
|
|
|
LocalCache.getNoteIfExists(signedEvent.id)?.let { onReady(it) }
|
|
}
|
|
|
|
fun createHeader(
|
|
imageUrl: String,
|
|
magnetUri: String?,
|
|
headerInfo: FileHeader,
|
|
alt: String?,
|
|
sensitiveContent: Boolean,
|
|
originalHash: String? = null,
|
|
onReady: (FileHeaderEvent) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
FileHeaderEvent.create(
|
|
url = imageUrl,
|
|
magnetUri = magnetUri,
|
|
mimeType = headerInfo.mimeType,
|
|
hash = headerInfo.hash,
|
|
size = headerInfo.size.toString(),
|
|
dimensions = headerInfo.dim,
|
|
blurhash = headerInfo.blurHash,
|
|
alt = alt,
|
|
originalHash = originalHash,
|
|
sensitiveContent = sensitiveContent,
|
|
signer = signer,
|
|
) { event ->
|
|
onReady(event)
|
|
}
|
|
}
|
|
|
|
fun sendHeader(
|
|
imageUrl: String,
|
|
magnetUri: String?,
|
|
headerInfo: FileHeader,
|
|
alt: String?,
|
|
sensitiveContent: Boolean,
|
|
originalHash: String? = null,
|
|
relayList: List<Relay>? = null,
|
|
onReady: (Note) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
FileHeaderEvent.create(
|
|
url = imageUrl,
|
|
magnetUri = magnetUri,
|
|
mimeType = headerInfo.mimeType,
|
|
hash = headerInfo.hash,
|
|
size = headerInfo.size.toString(),
|
|
dimensions = headerInfo.dim,
|
|
blurhash = headerInfo.blurHash,
|
|
alt = alt,
|
|
originalHash = originalHash,
|
|
sensitiveContent = sensitiveContent,
|
|
signer = signer,
|
|
) { event ->
|
|
sendHeader(event, relayList = relayList, onReady)
|
|
}
|
|
}
|
|
|
|
fun sendClassifieds(
|
|
title: String,
|
|
price: Price,
|
|
condition: ClassifiedsEvent.CONDITION,
|
|
location: String,
|
|
category: String,
|
|
message: String,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
directMentions: Set<HexKey>,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
relayList: List<Relay>? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<Event>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = replyTo?.filter { it.address() == null }?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
val addresses = replyTo?.mapNotNull { it.address() }
|
|
|
|
ClassifiedsEvent.create(
|
|
dTag = UUID.randomUUID().toString(),
|
|
title = title,
|
|
price = price,
|
|
condition = condition,
|
|
summary = message,
|
|
image = null,
|
|
location = location,
|
|
category = category,
|
|
message = message,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
addresses = addresses,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
directMentions = directMentions,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
signer = signer,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent, relayList = relayList)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it, relayList = relayList)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
replyTo?.forEach { it.event?.let { Client.send(it, relayList = relayList) } }
|
|
addresses?.forEach {
|
|
LocalCache.getAddressableNoteIfExists(it.toTag())?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendGitReply(
|
|
message: String,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
repository: ATag?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
replyingTo: String?,
|
|
root: String?,
|
|
directMentions: Set<HexKey>,
|
|
forkedFrom: Event?,
|
|
relayList: List<Relay>? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = replyTo?.filter { it.address() == null }?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
val addresses = listOfNotNull(repository) + (replyTo?.mapNotNull { it.address() } ?: emptyList())
|
|
|
|
GitReplyEvent.create(
|
|
msg = message,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
addresses = addresses,
|
|
extraTags = null,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
replyingTo = replyingTo,
|
|
root = root,
|
|
directMentions = directMentions,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
forkedFrom = forkedFrom,
|
|
signer = signer,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent, relayList = relayList)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it, relayList = relayList)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
// broadcast replied notes
|
|
replyingTo?.let {
|
|
LocalCache.getNoteIfExists(replyingTo)?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
replyTo?.forEach { it.event?.let { Client.send(it, relayList = relayList) } }
|
|
addresses?.forEach {
|
|
LocalCache.getAddressableNoteIfExists(it.toTag())?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendPost(
|
|
message: String,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
tags: List<String>? = null,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
replyingTo: String?,
|
|
root: String?,
|
|
directMentions: Set<HexKey>,
|
|
forkedFrom: Event?,
|
|
relayList: List<Relay>? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = replyTo?.filter { it.address() == null }?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
val addresses = replyTo?.mapNotNull { it.address() }
|
|
|
|
TextNoteEvent.create(
|
|
msg = message,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
addresses = addresses,
|
|
extraTags = tags,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
replyingTo = replyingTo,
|
|
root = root,
|
|
directMentions = directMentions,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
forkedFrom = forkedFrom,
|
|
signer = signer,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent, relayList = relayList)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it, relayList = relayList)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
// broadcast replied notes
|
|
replyingTo?.let {
|
|
LocalCache.getNoteIfExists(replyingTo)?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
replyTo?.forEach { it.event?.let { Client.send(it, relayList = relayList) } }
|
|
addresses?.forEach {
|
|
LocalCache.getAddressableNoteIfExists(it.toTag())?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendEdit(
|
|
message: String,
|
|
originalNote: Note,
|
|
notify: HexKey?,
|
|
summary: String? = null,
|
|
relayList: List<Relay>? = null,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val idHex = originalNote.event?.id() ?: return
|
|
|
|
TextNoteModificationEvent.create(
|
|
content = message,
|
|
eventId = idHex,
|
|
notify = notify,
|
|
summary = summary,
|
|
signer = signer,
|
|
) {
|
|
LocalCache.justConsume(it, null)
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
|
|
fun sendPoll(
|
|
message: String,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
pollOptions: Map<Int, String>,
|
|
valueMaximum: Int?,
|
|
valueMinimum: Int?,
|
|
consensusThreshold: Int?,
|
|
closedAt: Int?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
relayList: List<Relay>? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = replyTo?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
val addresses = replyTo?.mapNotNull { it.address() }
|
|
|
|
PollNoteEvent.create(
|
|
msg = message,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
addresses = addresses,
|
|
signer = signer,
|
|
pollOptions = pollOptions,
|
|
valueMaximum = valueMaximum,
|
|
valueMinimum = valueMinimum,
|
|
consensusThreshold = consensusThreshold,
|
|
closedAt = closedAt,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent, relayList = relayList)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it, relayList = relayList)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
// Rebroadcast replies and tags to the current relay set
|
|
replyTo?.forEach { it.event?.let { Client.send(it, relayList = relayList) } }
|
|
addresses?.forEach {
|
|
LocalCache.getAddressableNoteIfExists(it.toTag())?.event?.let {
|
|
Client.send(it, relayList = relayList)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendChannelMessage(
|
|
message: String,
|
|
toChannel: String,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = replyTo?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
|
|
ChannelMessageEvent.create(
|
|
message = message,
|
|
channel = toChannel,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
signer = signer,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendLiveMessage(
|
|
message: String,
|
|
toChannel: ATag,
|
|
replyTo: List<Note>?,
|
|
mentions: List<User>?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
// val repliesToHex = listOfNotNull(replyingTo?.idHex).ifEmpty { null }
|
|
val repliesToHex = replyTo?.map { it.idHex }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
|
|
LiveActivitiesChatMessageEvent.create(
|
|
message = message,
|
|
activity = toChannel,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
signer = signer,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendPrivateMessage(
|
|
message: String,
|
|
toUser: User,
|
|
replyingTo: Note? = null,
|
|
mentions: List<User>?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
sendPrivateMessage(
|
|
message,
|
|
toUser.pubkeyHex,
|
|
replyingTo,
|
|
mentions,
|
|
zapReceiver,
|
|
wantsToMarkAsSensitive,
|
|
zapRaiserAmount,
|
|
geohash,
|
|
nip94attachments,
|
|
draftTag,
|
|
)
|
|
}
|
|
|
|
fun sendPrivateMessage(
|
|
message: String,
|
|
toUser: HexKey,
|
|
replyingTo: Note? = null,
|
|
mentions: List<User>?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String?,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = listOfNotNull(replyingTo?.idHex).ifEmpty { null }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
|
|
PrivateDmEvent.create(
|
|
recipientPubKey = toUser,
|
|
publishedRecipientPubKey = toUser,
|
|
msg = message,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
signer = signer,
|
|
advertiseNip18 = false,
|
|
isDraft = draftTag != null,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it, signer) { draftEvent ->
|
|
Client.send(draftEvent)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.id())
|
|
}
|
|
} else {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendNIP24PrivateMessage(
|
|
message: String,
|
|
toUsers: List<HexKey>,
|
|
subject: String? = null,
|
|
replyingTo: Note? = null,
|
|
mentions: List<User>?,
|
|
zapReceiver: List<ZapSplitSetup>? = null,
|
|
wantsToMarkAsSensitive: Boolean,
|
|
zapRaiserAmount: Long? = null,
|
|
geohash: String? = null,
|
|
nip94attachments: List<FileHeaderEvent>? = null,
|
|
draftTag: String? = null,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val repliesToHex = listOfNotNull(replyingTo?.idHex).ifEmpty { null }
|
|
val mentionsHex = mentions?.map { it.pubkeyHex }
|
|
|
|
NIP24Factory().createMsgNIP24(
|
|
msg = message,
|
|
to = toUsers,
|
|
subject = subject,
|
|
replyTos = repliesToHex,
|
|
mentions = mentionsHex,
|
|
zapReceiver = zapReceiver,
|
|
markAsSensitive = wantsToMarkAsSensitive,
|
|
zapRaiserAmount = zapRaiserAmount,
|
|
geohash = geohash,
|
|
nip94attachments = nip94attachments,
|
|
draftTag = draftTag,
|
|
signer = signer,
|
|
) {
|
|
if (draftTag != null) {
|
|
DraftEvent.create(draftTag, it.msg, signer) { draftEvent ->
|
|
Client.send(draftEvent)
|
|
LocalCache.justConsume(draftEvent, null)
|
|
LocalCache.justConsume(it.msg, null)
|
|
LocalCache.addDraft(draftTag, draftEvent.id(), it.msg.id())
|
|
}
|
|
} else {
|
|
broadcastPrivately(it)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun broadcastPrivately(signedEvents: NIP24Factory.Result) {
|
|
val mine = signedEvents.wraps.filter { (it.recipientPubKey() == signer.pubKey) }
|
|
|
|
mine.forEach { giftWrap ->
|
|
giftWrap.cachedGift(signer) { gift ->
|
|
if (gift is SealedGossipEvent) {
|
|
gift.cachedGossip(signer) { gossip -> LocalCache.justConsume(gossip, null) }
|
|
} else {
|
|
LocalCache.justConsume(gift, null)
|
|
}
|
|
}
|
|
|
|
LocalCache.consume(giftWrap, null)
|
|
}
|
|
|
|
val id = mine.firstOrNull()?.id
|
|
val mineNote = if (id == null) null else LocalCache.getNoteIfExists(id)
|
|
|
|
signedEvents.wraps.forEach {
|
|
// Creates an alias
|
|
if (mineNote != null && it.recipientPubKey() != keyPair.pubKey.toHexKey()) {
|
|
LocalCache.getOrAddAliasNote(it.id, mineNote)
|
|
}
|
|
|
|
Client.send(it)
|
|
}
|
|
}
|
|
|
|
fun sendCreateNewChannel(
|
|
name: String,
|
|
about: String,
|
|
picture: String,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
ChannelCreateEvent.create(
|
|
name = name,
|
|
about = about,
|
|
picture = picture,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
LocalCache.getChannelIfExists(it.id)?.let { follow(it) }
|
|
}
|
|
}
|
|
|
|
fun updateStatus(
|
|
oldStatus: AddressableNote,
|
|
newStatus: String,
|
|
) {
|
|
if (!isWriteable()) return
|
|
val oldEvent = oldStatus.event as? StatusEvent ?: return
|
|
|
|
StatusEvent.update(oldEvent, newStatus, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
|
|
fun createStatus(newStatus: String) {
|
|
if (!isWriteable()) return
|
|
|
|
StatusEvent.create(newStatus, "general", expiration = null, signer) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
|
|
fun deleteStatus(oldStatus: AddressableNote) {
|
|
if (!isWriteable()) return
|
|
val oldEvent = oldStatus.event as? StatusEvent ?: return
|
|
|
|
StatusEvent.clear(oldEvent, signer) { event ->
|
|
Client.send(event)
|
|
LocalCache.justConsume(event, null)
|
|
|
|
DeletionEvent.create(listOf(event.id), signer) { event2 ->
|
|
Client.send(event2)
|
|
LocalCache.justConsume(event2, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun removeEmojiPack(
|
|
usersEmojiList: Note,
|
|
emojiList: Note,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val noteEvent = usersEmojiList.event
|
|
if (noteEvent !is EmojiPackSelectionEvent) return
|
|
val emojiListEvent = emojiList.event
|
|
if (emojiListEvent !is EmojiPackEvent) return
|
|
|
|
EmojiPackSelectionEvent.create(
|
|
noteEvent.taggedAddresses().filter { it != emojiListEvent.address() },
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
|
|
fun addEmojiPack(
|
|
usersEmojiList: Note,
|
|
emojiList: Note,
|
|
) {
|
|
if (!isWriteable()) return
|
|
val emojiListEvent = emojiList.event
|
|
if (emojiListEvent !is EmojiPackEvent) return
|
|
|
|
if (usersEmojiList.event == null) {
|
|
EmojiPackSelectionEvent.create(
|
|
listOf(emojiListEvent.address()),
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
} else {
|
|
val noteEvent = usersEmojiList.event
|
|
if (noteEvent !is EmojiPackSelectionEvent) return
|
|
|
|
if (noteEvent.taggedAddresses().any { it == emojiListEvent.address() }) {
|
|
return
|
|
}
|
|
|
|
EmojiPackSelectionEvent.create(
|
|
noteEvent.taggedAddresses().plus(emojiListEvent.address()),
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addBookmark(
|
|
note: Note,
|
|
isPrivate: Boolean,
|
|
) {
|
|
if (!isWriteable()) return
|
|
if (note.isDraft()) return
|
|
|
|
if (note is AddressableNote) {
|
|
BookmarkListEvent.addReplaceable(
|
|
userProfile().latestBookmarkList,
|
|
note.address,
|
|
isPrivate,
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
} else {
|
|
BookmarkListEvent.addEvent(
|
|
userProfile().latestBookmarkList,
|
|
note.idHex,
|
|
isPrivate,
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun removeBookmark(
|
|
note: Note,
|
|
isPrivate: Boolean,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
val bookmarks = userProfile().latestBookmarkList ?: return
|
|
|
|
if (note is AddressableNote) {
|
|
BookmarkListEvent.removeReplaceable(
|
|
bookmarks,
|
|
note.address,
|
|
isPrivate,
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
} else {
|
|
BookmarkListEvent.removeEvent(
|
|
bookmarks,
|
|
note.idHex,
|
|
isPrivate,
|
|
signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun createAuthEvent(
|
|
relay: Relay,
|
|
challenge: String,
|
|
onReady: (RelayAuthEvent) -> Unit,
|
|
) {
|
|
return createAuthEvent(relay.url, challenge, onReady = onReady)
|
|
}
|
|
|
|
fun createAuthEvent(
|
|
relayUrl: String,
|
|
challenge: String,
|
|
onReady: (RelayAuthEvent) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
RelayAuthEvent.create(relayUrl, challenge, signer, onReady = onReady)
|
|
}
|
|
|
|
fun isInPrivateBookmarks(
|
|
note: Note,
|
|
onReady: (Boolean) -> Unit,
|
|
) {
|
|
if (!isWriteable()) {
|
|
onReady(false)
|
|
false
|
|
}
|
|
if (userProfile().latestBookmarkList == null) {
|
|
onReady(false)
|
|
false
|
|
}
|
|
|
|
if (note is AddressableNote) {
|
|
userProfile().latestBookmarkList?.privateTaggedAddresses(signer) {
|
|
onReady(it.contains(note.address))
|
|
}
|
|
} else {
|
|
userProfile().latestBookmarkList?.privateTaggedEvents(signer) {
|
|
onReady(it.contains(note.idHex))
|
|
}
|
|
}
|
|
}
|
|
|
|
fun isInPublicBookmarks(note: Note): Boolean {
|
|
if (!isWriteable()) return false
|
|
|
|
if (note is AddressableNote) {
|
|
return userProfile().latestBookmarkList?.taggedAddresses()?.contains(note.address) == true
|
|
} else {
|
|
return userProfile().latestBookmarkList?.taggedEvents()?.contains(note.idHex) == true
|
|
}
|
|
}
|
|
|
|
fun getBlockListNote(): AddressableNote {
|
|
val aTag =
|
|
ATag(
|
|
PeopleListEvent.KIND,
|
|
userProfile().pubkeyHex,
|
|
PeopleListEvent.BLOCK_LIST_D_TAG,
|
|
null,
|
|
)
|
|
return LocalCache.getOrCreateAddressableNote(aTag)
|
|
}
|
|
|
|
fun getMuteListNote(): AddressableNote {
|
|
val aTag =
|
|
ATag(
|
|
MuteListEvent.KIND,
|
|
userProfile().pubkeyHex,
|
|
"",
|
|
null,
|
|
)
|
|
return LocalCache.getOrCreateAddressableNote(aTag)
|
|
}
|
|
|
|
fun getFileServersNote(): AddressableNote {
|
|
val aTag =
|
|
ATag(
|
|
FileServersEvent.KIND,
|
|
userProfile().pubkeyHex,
|
|
"",
|
|
null,
|
|
)
|
|
return LocalCache.getOrCreateAddressableNote(aTag)
|
|
}
|
|
|
|
fun getBlockList(): PeopleListEvent? {
|
|
return getBlockListNote().event as? PeopleListEvent
|
|
}
|
|
|
|
fun getMuteList(): MuteListEvent? {
|
|
return getMuteListNote().event as? MuteListEvent
|
|
}
|
|
|
|
fun getFileServersList(): FileServersEvent? {
|
|
return getFileServersNote().event as? FileServersEvent
|
|
}
|
|
|
|
fun hideWord(word: String) {
|
|
val muteList = getMuteList()
|
|
|
|
if (muteList != null) {
|
|
MuteListEvent.addWord(
|
|
earlierVersion = muteList,
|
|
word = word,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
} else {
|
|
MuteListEvent.createListWithWord(
|
|
word = word,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun showWord(word: String) {
|
|
val blockList = getBlockList()
|
|
|
|
if (blockList != null) {
|
|
PeopleListEvent.removeWord(
|
|
earlierVersion = blockList,
|
|
word = word,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
|
|
val muteList = getMuteList()
|
|
|
|
if (muteList != null) {
|
|
MuteListEvent.removeWord(
|
|
earlierVersion = muteList,
|
|
word = word,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun hideUser(pubkeyHex: String) {
|
|
val muteList = getMuteList()
|
|
|
|
if (muteList != null) {
|
|
MuteListEvent.addUser(
|
|
earlierVersion = muteList,
|
|
pubKeyHex = pubkeyHex,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
} else {
|
|
MuteListEvent.createListWithUser(
|
|
pubKeyHex = pubkeyHex,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun showUser(pubkeyHex: String) {
|
|
val blockList = getBlockList()
|
|
|
|
if (blockList != null) {
|
|
PeopleListEvent.removeUser(
|
|
earlierVersion = blockList,
|
|
pubKeyHex = pubkeyHex,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
|
|
val muteList = getMuteList()
|
|
|
|
if (muteList != null) {
|
|
MuteListEvent.removeUser(
|
|
earlierVersion = muteList,
|
|
pubKeyHex = pubkeyHex,
|
|
isPrivate = true,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.consume(it, null)
|
|
}
|
|
}
|
|
|
|
transientHiddenUsers = (transientHiddenUsers - pubkeyHex).toImmutableSet()
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultZapType(zapType: LnZapEvent.ZapType) {
|
|
defaultZapType = zapType
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultFileServer(server: Nip96MediaServers.ServerName) {
|
|
defaultFileServer = server
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultHomeFollowList(name: String) {
|
|
defaultHomeFollowList.tryEmit(name)
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultStoriesFollowList(name: String) {
|
|
defaultStoriesFollowList.tryEmit(name)
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultNotificationFollowList(name: String) {
|
|
defaultNotificationFollowList.tryEmit(name)
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeDefaultDiscoveryFollowList(name: String) {
|
|
defaultDiscoveryFollowList.tryEmit(name)
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeZapAmounts(newAmounts: List<Long>) {
|
|
zapAmountChoices = newAmounts
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeReactionTypes(newTypes: List<String>) {
|
|
reactionChoices = newTypes
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun changeZapPaymentRequest(newServer: Nip47WalletConnect.Nip47URI?) {
|
|
zapPaymentRequest = newServer
|
|
live.invalidateData()
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun selectedChatsFollowList(): Set<String> {
|
|
val contactList = userProfile().latestContactList
|
|
return contactList?.taggedEvents()?.toSet() ?: DefaultChannels
|
|
}
|
|
|
|
fun sendChangeChannel(
|
|
name: String,
|
|
about: String,
|
|
picture: String,
|
|
channel: Channel,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
ChannelMetadataEvent.create(
|
|
name,
|
|
about,
|
|
picture,
|
|
originalChannelIdHex = channel.idHex,
|
|
signer = signer,
|
|
) {
|
|
Client.send(it)
|
|
LocalCache.justConsume(it, null)
|
|
|
|
follow(channel)
|
|
}
|
|
}
|
|
|
|
fun unwrap(
|
|
event: GiftWrapEvent,
|
|
onReady: (Event) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
return event.cachedGift(signer, onReady)
|
|
}
|
|
|
|
fun unseal(
|
|
event: SealedGossipEvent,
|
|
onReady: (Event) -> Unit,
|
|
) {
|
|
if (!isWriteable()) return
|
|
|
|
return event.cachedGossip(signer, onReady)
|
|
}
|
|
|
|
fun cachedDecryptContent(note: Note): String? {
|
|
val event = note.event
|
|
|
|
return if (event is PrivateDmEvent && isWriteable()) {
|
|
event.cachedContentFor(signer)
|
|
} else if (event is LnZapRequestEvent && event.isPrivateZap() && isWriteable()) {
|
|
event.cachedPrivateZap()?.content
|
|
} else {
|
|
event?.content()
|
|
}
|
|
}
|
|
|
|
fun decryptContent(
|
|
note: Note,
|
|
onReady: (String) -> Unit,
|
|
) {
|
|
val event = note.event
|
|
if (event is PrivateDmEvent && isWriteable()) {
|
|
event.plainContent(signer, onReady)
|
|
} else if (event is LnZapRequestEvent) {
|
|
decryptZapContentAuthor(note) { onReady(it.content) }
|
|
} else {
|
|
event?.content()?.let { onReady(it) }
|
|
}
|
|
}
|
|
|
|
fun decryptZapContentAuthor(
|
|
note: Note,
|
|
onReady: (Event) -> Unit,
|
|
) {
|
|
val event = note.event
|
|
if (event is LnZapRequestEvent) {
|
|
if (event.isPrivateZap()) {
|
|
if (isWriteable()) {
|
|
event.decryptPrivateZap(signer) { onReady(it) }
|
|
}
|
|
} else {
|
|
onReady(event)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addDontTranslateFrom(languageCode: String) {
|
|
dontTranslateFrom = dontTranslateFrom.plus(languageCode)
|
|
liveLanguages.invalidateData()
|
|
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun updateTranslateTo(languageCode: String) {
|
|
translateTo = languageCode
|
|
liveLanguages.invalidateData()
|
|
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun prefer(
|
|
source: String,
|
|
target: String,
|
|
preference: String,
|
|
) {
|
|
languagePreferences = languagePreferences + Pair("$source,$target", preference)
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun preferenceBetween(
|
|
source: String,
|
|
target: String,
|
|
): String? {
|
|
return languagePreferences.get("$source,$target")
|
|
}
|
|
|
|
private fun updateContactListTo(newContactList: ContactListEvent?) {
|
|
if (newContactList == null || newContactList.tags.isEmpty()) return
|
|
|
|
// Events might be different objects, we have to compare their ids.
|
|
if (backupContactList?.id != newContactList.id) {
|
|
backupContactList = newContactList
|
|
saveable.invalidateData()
|
|
}
|
|
}
|
|
|
|
// Takes a User's relay list and adds the types of feeds they are active for.
|
|
fun activeRelays(): Array<Relay>? {
|
|
var usersRelayList =
|
|
userProfile().latestContactList?.relays()?.map {
|
|
val localFeedTypes =
|
|
localRelays.firstOrNull { localRelay -> localRelay.url == it.key }?.feedTypes
|
|
?: Constants.defaultRelays
|
|
.filter { defaultRelay -> defaultRelay.url == it.key }
|
|
.firstOrNull()
|
|
?.feedTypes
|
|
?: FeedType.values().toSet()
|
|
|
|
Relay(it.key, it.value.read, it.value.write, localFeedTypes)
|
|
}
|
|
?: return null
|
|
|
|
// Ugly, but forces nostr.band as the only search-supporting relay today.
|
|
// TODO: Remove when search becomes more available.
|
|
val searchRelays =
|
|
usersRelayList.filter { it.url.removeSuffix("/") in Constants.forcedRelaysForSearchSet }
|
|
val hasSearchRelay = usersRelayList.any { it.activeTypes.contains(FeedType.SEARCH) }
|
|
if (!hasSearchRelay && searchRelays.isEmpty()) {
|
|
usersRelayList =
|
|
usersRelayList +
|
|
Constants.forcedRelayForSearch.map {
|
|
Relay(
|
|
it.url,
|
|
it.read,
|
|
it.write,
|
|
it.feedTypes,
|
|
)
|
|
}
|
|
}
|
|
|
|
return usersRelayList.toTypedArray()
|
|
}
|
|
|
|
fun convertLocalRelays(): Array<Relay> {
|
|
return localRelays.map { Relay(it.url, it.read, it.write, it.feedTypes) }.toTypedArray()
|
|
}
|
|
|
|
fun activeGlobalRelays(): Array<String> {
|
|
return (activeRelays() ?: convertLocalRelays())
|
|
.filter { it.activeTypes.contains(FeedType.GLOBAL) }
|
|
.map { it.url }
|
|
.toTypedArray()
|
|
}
|
|
|
|
fun activeWriteRelays(): List<Relay> {
|
|
return (activeRelays() ?: convertLocalRelays()).filter { it.write }
|
|
}
|
|
|
|
fun isAllHidden(users: Set<HexKey>): Boolean {
|
|
return users.all { isHidden(it) }
|
|
}
|
|
|
|
fun isHidden(user: User) = isHidden(user.pubkeyHex)
|
|
|
|
fun isHidden(userHex: String): Boolean {
|
|
return flowHiddenUsers.value.hiddenUsers.contains(userHex) ||
|
|
flowHiddenUsers.value.spammers.contains(userHex)
|
|
}
|
|
|
|
fun followingKeySet(): Set<HexKey> {
|
|
return userProfile().cachedFollowingKeySet()
|
|
}
|
|
|
|
fun followingTagSet(): Set<HexKey> {
|
|
return userProfile().cachedFollowingTagSet()
|
|
}
|
|
|
|
fun isAcceptable(user: User): Boolean {
|
|
if (userProfile().pubkeyHex == user.pubkeyHex) {
|
|
return true
|
|
}
|
|
|
|
if (user.pubkeyHex in followingKeySet()) {
|
|
return true
|
|
}
|
|
|
|
if (!warnAboutPostsWithReports) {
|
|
return !isHidden(user) && // if user hasn't hided this author
|
|
user.reportsBy(userProfile()).isEmpty() // if user has not reported this post
|
|
}
|
|
return !isHidden(user) && // if user hasn't hided this author
|
|
user.reportsBy(userProfile()).isEmpty() && // if user has not reported this post
|
|
user.countReportAuthorsBy(followingKeySet()) < 5
|
|
}
|
|
|
|
private fun isAcceptableDirect(note: Note): Boolean {
|
|
if (!warnAboutPostsWithReports) {
|
|
return !note.hasReportsBy(userProfile())
|
|
}
|
|
return !note.hasReportsBy(userProfile()) && // if user has not reported this post
|
|
note.countReportAuthorsBy(followingKeySet()) < 5 // if it has 5 reports by reliable users
|
|
}
|
|
|
|
fun isFollowing(user: User): Boolean {
|
|
return user.pubkeyHex in followingKeySet()
|
|
}
|
|
|
|
fun isFollowing(user: HexKey): Boolean {
|
|
return user in followingKeySet()
|
|
}
|
|
|
|
fun isAcceptable(note: Note): Boolean {
|
|
return note.author?.let { isAcceptable(it) } ?: true && // if user hasn't hided this author
|
|
isAcceptableDirect(note) &&
|
|
(
|
|
(note.event !is RepostEvent && note.event !is GenericRepostEvent) ||
|
|
(
|
|
note.replyTo?.firstOrNull { isAcceptableDirect(it) } !=
|
|
null
|
|
)
|
|
) // is not a reaction about a blocked post
|
|
}
|
|
|
|
fun getRelevantReports(note: Note): Set<Note> {
|
|
val followsPlusMe = userProfile().latestContactList?.verifiedFollowKeySetAndMe ?: emptySet()
|
|
|
|
val innerReports =
|
|
if (note.event is RepostEvent || note.event is GenericRepostEvent) {
|
|
note.replyTo?.map { getRelevantReports(it) }?.flatten() ?: emptyList()
|
|
} else {
|
|
emptyList()
|
|
}
|
|
|
|
return (
|
|
note.reportsBy(followsPlusMe) +
|
|
(note.author?.reportsBy(followsPlusMe) ?: emptyList()) +
|
|
innerReports
|
|
)
|
|
.toSet()
|
|
}
|
|
|
|
fun saveRelayList(value: List<RelaySetupInfo>) {
|
|
try {
|
|
localRelays = value.toSet()
|
|
return sendNewRelayList(
|
|
value.associate { it.url to ContactListEvent.ReadWrite(it.read, it.write) },
|
|
)
|
|
} finally {
|
|
saveable.invalidateData()
|
|
}
|
|
}
|
|
|
|
fun setHideDeleteRequestDialog() {
|
|
hideDeleteRequestDialog = true
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun setHideNIP24WarningDialog() {
|
|
hideNIP24WarningDialog = true
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun setHideBlockAlertDialog() {
|
|
hideBlockAlertDialog = true
|
|
saveable.invalidateData()
|
|
}
|
|
|
|
fun updateShowSensitiveContent(show: Boolean?) {
|
|
showSensitiveContent = show
|
|
saveable.invalidateData()
|
|
live.invalidateData()
|
|
}
|
|
|
|
fun markAsRead(
|
|
route: String,
|
|
timestampInSecs: Long,
|
|
): Boolean {
|
|
val lastTime = lastReadPerRoute[route]
|
|
return if (lastTime == null || timestampInSecs > lastTime) {
|
|
lastReadPerRoute = lastReadPerRoute + Pair(route, timestampInSecs)
|
|
saveable.invalidateData()
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
fun loadLastRead(route: String): Long {
|
|
return lastReadPerRoute[route] ?: 0
|
|
}
|
|
|
|
fun hasDonatedInThisVersion(): Boolean {
|
|
return hasDonatedInVersion.contains(BuildConfig.VERSION_NAME)
|
|
}
|
|
|
|
fun markDonatedInThisVersion() {
|
|
hasDonatedInVersion = hasDonatedInVersion + BuildConfig.VERSION_NAME
|
|
saveable.invalidateData()
|
|
live.invalidateData()
|
|
}
|
|
|
|
suspend fun registerObservers() =
|
|
withContext(Dispatchers.Main) {
|
|
// saves contact list for the next time.
|
|
userProfile().live().follows.observeForever {
|
|
GlobalScope.launch(Dispatchers.IO) { updateContactListTo(userProfile().latestContactList) }
|
|
}
|
|
|
|
// imports transient blocks due to spam.
|
|
LocalCache.antiSpam.liveSpam.observeForever {
|
|
GlobalScope.launch(Dispatchers.IO) {
|
|
it.cache.spamMessages.snapshot().values.forEach {
|
|
if (it.pubkeyHex !in transientHiddenUsers && it.duplicatedMessages.size >= 5) {
|
|
if (it.pubkeyHex != userProfile().pubkeyHex && it.pubkeyHex !in followingKeySet()) {
|
|
transientHiddenUsers = (transientHiddenUsers + it.pubkeyHex).toImmutableSet()
|
|
live.invalidateData()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
init {
|
|
Log.d("Init", "Account")
|
|
backupContactList?.let {
|
|
println("Loading saved contacts ${it.toJson()}")
|
|
|
|
if (userProfile().latestContactList == null) {
|
|
GlobalScope.launch(Dispatchers.IO) { LocalCache.consume(it) }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class AccountLiveData(private val account: Account) :
|
|
LiveData<AccountState>(AccountState(account)) {
|
|
// Refreshes observers in batches.
|
|
private val bundler = BundledUpdate(300, Dispatchers.Default)
|
|
|
|
fun invalidateData() {
|
|
bundler.invalidate {
|
|
if (hasActiveObservers()) {
|
|
refresh()
|
|
}
|
|
}
|
|
}
|
|
|
|
fun refresh() {
|
|
postValue(AccountState(account))
|
|
}
|
|
}
|
|
|
|
@Immutable class AccountState(val account: Account)
|