241755c8c4
This is a minor refactor on the way wallet invoice URLs are handled, in order to better fit the interface, enforce the design pattern, and avoid side-effects in a particular function that handles opening URLs. This design pattern was introduced to prevent issues on the previous pattern, where URL handling was done with side-effects inside multiple levels of nested logic and separate function calls, which would make debugging very difficult, and cause the app to fail silently. Closes: https://github.com/damus-io/damus/issues/3023 Signed-off-by: Daniel D’Aquino <daniel@daquino.me>
1225 lines
49 KiB
Swift
1225 lines
49 KiB
Swift
//
|
|
// ContentView.swift
|
|
// damus
|
|
//
|
|
// Created by William Casarin on 2022-04-01.
|
|
//
|
|
|
|
import SwiftUI
|
|
import AVKit
|
|
import MediaPlayer
|
|
import EmojiPicker
|
|
|
|
struct ZapSheet {
|
|
let target: ZapTarget
|
|
let lnurl: String
|
|
}
|
|
|
|
struct SelectWallet {
|
|
let invoice: String
|
|
}
|
|
|
|
enum Sheets: Identifiable {
|
|
case post(PostAction)
|
|
case report(ReportTarget)
|
|
case event(NostrEvent)
|
|
case profile_action(Pubkey)
|
|
case zap(ZapSheet)
|
|
case select_wallet(SelectWallet)
|
|
case filter
|
|
case user_status
|
|
case onboardingSuggestions
|
|
case purple(DamusPurpleURL)
|
|
case purple_onboarding
|
|
case error(ErrorView.UserPresentableError)
|
|
|
|
static func zap(target: ZapTarget, lnurl: String) -> Sheets {
|
|
return .zap(ZapSheet(target: target, lnurl: lnurl))
|
|
}
|
|
|
|
static func select_wallet(invoice: String) -> Sheets {
|
|
return .select_wallet(SelectWallet(invoice: invoice))
|
|
}
|
|
|
|
var id: String {
|
|
switch self {
|
|
case .report: return "report"
|
|
case .user_status: return "user_status"
|
|
case .post(let action): return "post-" + (action.ev?.id.hex() ?? "")
|
|
case .event(let ev): return "event-" + ev.id.hex()
|
|
case .profile_action(let pubkey): return "profile-action-" + pubkey.npub
|
|
case .zap(let sheet): return "zap-" + hex_encode(sheet.target.id)
|
|
case .select_wallet: return "select-wallet"
|
|
case .filter: return "filter"
|
|
case .onboardingSuggestions: return "onboarding-suggestions"
|
|
case .purple(let purple_url): return "purple" + purple_url.url_string()
|
|
case .purple_onboarding: return "purple_onboarding"
|
|
case .error(_): return "error"
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An item to be presented full screen in a mechanism that is more robust for timeline views.
|
|
///
|
|
/// ## Implementation notes
|
|
///
|
|
/// This is part of the `present(full_screen_item: FullScreenItem)` interface that allows views in a timeline to show something full-screen without the lazy stack issues
|
|
/// Full screen cover modifiers are not suitable in those cases because device orientation changes or programmatic scroll commands will cause the view to be unloaded along with the cover,
|
|
/// causing the user to lose the full screen view randomly.
|
|
///
|
|
/// The `ContentView` is responsible for handling these objects
|
|
///
|
|
/// New items can be added as needed.
|
|
///
|
|
enum FullScreenItem: Identifiable, Equatable {
|
|
/// A full screen media carousel for images and videos.
|
|
case full_screen_carousel(urls: [MediaUrl], selectedIndex: Binding<Int>)
|
|
|
|
var id: String {
|
|
switch self {
|
|
case .full_screen_carousel(let urls, _): return "full_screen_carousel:\(urls.map(\.url))"
|
|
}
|
|
}
|
|
|
|
static func == (lhs: FullScreenItem, rhs: FullScreenItem) -> Bool {
|
|
return lhs.id == rhs.id
|
|
}
|
|
|
|
/// The view to display the item
|
|
func view(damus_state: DamusState) -> some View {
|
|
switch self {
|
|
case .full_screen_carousel(let urls, let selectedIndex):
|
|
return FullScreenCarouselView<AnyView>(video_coordinator: damus_state.video, urls: urls, settings: damus_state.settings, selectedIndex: selectedIndex)
|
|
}
|
|
}
|
|
}
|
|
|
|
func present_sheet(_ sheet: Sheets) {
|
|
notify(.present_sheet(sheet))
|
|
}
|
|
|
|
var tabHeight: CGFloat = 0.0
|
|
|
|
struct ContentView: View {
|
|
let keypair: Keypair
|
|
let appDelegate: AppDelegate?
|
|
|
|
var pubkey: Pubkey {
|
|
return keypair.pubkey
|
|
}
|
|
|
|
var privkey: Privkey? {
|
|
return keypair.privkey
|
|
}
|
|
|
|
@Environment(\.scenePhase) var scenePhase
|
|
|
|
@State var active_sheet: Sheets? = nil
|
|
@State var active_full_screen_item: FullScreenItem? = nil
|
|
@State var damus_state: DamusState!
|
|
@State var menu_subtitle: String? = nil
|
|
@SceneStorage("ContentView.selected_timeline") var selected_timeline: Timeline = .home {
|
|
willSet {
|
|
self.menu_subtitle = nil
|
|
}
|
|
}
|
|
@State var muting: MuteItem? = nil
|
|
@State var confirm_mute: Bool = false
|
|
@State var hide_bar: Bool = false
|
|
@State var user_muted_confirm: Bool = false
|
|
@State var confirm_overwrite_mutelist: Bool = false
|
|
@State private var isSideBarOpened = false
|
|
@State var headerOffset: CGFloat = 0.0
|
|
var home: HomeModel = HomeModel()
|
|
@StateObject var navigationCoordinator: NavigationCoordinator = NavigationCoordinator()
|
|
@AppStorage("has_seen_suggested_users") private var hasSeenOnboardingSuggestions = false
|
|
let sub_id = UUID().description
|
|
|
|
// connect retry timer
|
|
let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
|
|
|
|
func navIsAtRoot() -> Bool {
|
|
return navigationCoordinator.isAtRoot()
|
|
}
|
|
|
|
func popToRoot() {
|
|
navigationCoordinator.popToRoot()
|
|
isSideBarOpened = false
|
|
}
|
|
|
|
var timelineNavItem: some View {
|
|
VStack {
|
|
Text(timeline_name(selected_timeline))
|
|
.bold()
|
|
if let menu_subtitle {
|
|
Text(menu_subtitle)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
}
|
|
|
|
func MainContent(damus: DamusState) -> some View {
|
|
VStack {
|
|
switch selected_timeline {
|
|
case .search:
|
|
if #available(iOS 16.0, *) {
|
|
SearchHomeView(damus_state: damus_state!, model: SearchHomeModel(damus_state: damus_state!))
|
|
.scrollDismissesKeyboard(.immediately)
|
|
} else {
|
|
// Fallback on earlier versions
|
|
SearchHomeView(damus_state: damus_state!, model: SearchHomeModel(damus_state: damus_state!))
|
|
}
|
|
|
|
case .home:
|
|
PostingTimelineView(damus_state: damus_state!, home: home, isSideBarOpened: $isSideBarOpened, active_sheet: $active_sheet, headerOffset: $headerOffset)
|
|
|
|
case .notifications:
|
|
NotificationsView(state: damus, notifications: home.notifications, subtitle: $menu_subtitle)
|
|
|
|
case .dms:
|
|
DirectMessagesView(damus_state: damus_state!, model: damus_state!.dms, settings: damus_state!.settings)
|
|
}
|
|
}
|
|
.background(DamusColors.adaptableWhite)
|
|
.edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
|
|
.navigationBarTitle(timeline_name(selected_timeline), displayMode: .inline)
|
|
.toolbar(selected_timeline != .home ? .visible : .hidden)
|
|
.toolbar {
|
|
ToolbarItem(placement: .principal) {
|
|
VStack {
|
|
timelineNavItem
|
|
.opacity(isSideBarOpened ? 0 : 1)
|
|
.animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func MaybeReportView(target: ReportTarget) -> some View {
|
|
Group {
|
|
if let keypair = damus_state.keypair.to_full() {
|
|
ReportView(postbox: damus_state.nostrNetwork.postbox, target: target, keypair: keypair)
|
|
} else {
|
|
EmptyView()
|
|
}
|
|
}
|
|
}
|
|
|
|
func open_event(ev: NostrEvent) {
|
|
let thread = ThreadModel(event: ev, damus_state: damus_state!)
|
|
navigationCoordinator.push(route: Route.Thread(thread: thread))
|
|
}
|
|
|
|
func open_wallet(nwc: WalletConnectURL) {
|
|
self.damus_state!.wallet.new(nwc)
|
|
navigationCoordinator.push(route: Route.Wallet(wallet: damus_state!.wallet))
|
|
}
|
|
|
|
func open_script(_ script: [UInt8]) {
|
|
print("pushing script nav")
|
|
let model = ScriptModel(data: script, state: .not_loaded)
|
|
navigationCoordinator.push(route: Route.Script(script: model))
|
|
}
|
|
|
|
func open_search(filt: NostrFilter) {
|
|
let search = SearchModel(state: damus_state!, search: filt)
|
|
navigationCoordinator.push(route: Route.Search(search: search))
|
|
}
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 0) {
|
|
if let damus = self.damus_state {
|
|
NavigationStack(path: $navigationCoordinator.path) {
|
|
TabView { // Prevents navbar appearance change on scroll
|
|
MainContent(damus: damus)
|
|
.toolbar() {
|
|
ToolbarItem(placement: .navigationBarLeading) {
|
|
TopbarSideMenuButton(damus_state: damus, isSideBarOpened: $isSideBarOpened)
|
|
}
|
|
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
HStack(alignment: .center) {
|
|
SignalView(state: damus_state!, signal: home.signal)
|
|
|
|
// maybe expand this to other timelines in the future
|
|
if selected_timeline == .search {
|
|
|
|
Button(action: {
|
|
present_sheet(.filter)
|
|
}, label: {
|
|
Image("filter")
|
|
.foregroundColor(.gray)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.background(DamusColors.adaptableWhite)
|
|
.edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
|
|
.tabViewStyle(.page(indexDisplayMode: .never))
|
|
.overlay(
|
|
SideMenuView(damus_state: damus_state!, isSidebarVisible: $isSideBarOpened.animation(), selected: $selected_timeline)
|
|
)
|
|
.navigationDestination(for: Route.self) { route in
|
|
route.view(navigationCoordinator: navigationCoordinator, damusState: damus_state!)
|
|
}
|
|
.onReceive(handle_notify(.switched_timeline)) { _ in
|
|
navigationCoordinator.popToRoot()
|
|
}
|
|
}
|
|
.navigationViewStyle(.stack)
|
|
.damus_full_screen_cover($active_full_screen_item, damus_state: damus, content: { item in
|
|
return item.view(damus_state: damus)
|
|
})
|
|
.overlay(alignment: .bottom) {
|
|
if !hide_bar {
|
|
if !isSideBarOpened {
|
|
TabBar(nstatus: home.notification_status, navIsAtRoot: navIsAtRoot(), selected: $selected_timeline, headerOffset: $headerOffset, settings: damus.settings, action: switch_timeline)
|
|
.padding([.bottom], 8)
|
|
.background(selected_timeline != .home || (selected_timeline == .home && !self.navIsAtRoot()) ? DamusColors.adaptableWhite : DamusColors.adaptableWhite.opacity(abs(1.25 - (abs(headerOffset/100.0)))))
|
|
.anchorPreference(key: HeaderBoundsKey.self, value: .bounds){$0}
|
|
.overlayPreferenceValue(HeaderBoundsKey.self) { value in
|
|
GeometryReader{ proxy in
|
|
if let anchor = value{
|
|
Color.clear
|
|
.onAppear {
|
|
tabHeight = proxy[anchor].height
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.ignoresSafeArea(.keyboard)
|
|
.edgesIgnoringSafeArea(hide_bar ? [.bottom] : [])
|
|
.onAppear() {
|
|
self.connect()
|
|
try? AVAudioSession.sharedInstance().setCategory(AVAudioSession.Category.playback, mode: .default, options: .mixWithOthers)
|
|
setup_notifications()
|
|
if !hasSeenOnboardingSuggestions || damus_state!.settings.always_show_onboarding_suggestions {
|
|
active_sheet = .onboardingSuggestions
|
|
hasSeenOnboardingSuggestions = true
|
|
}
|
|
self.appDelegate?.state = damus_state
|
|
Task { // We probably don't need this to be a detached task. According to https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/#Defining-and-Calling-Asynchronous-Functions, awaits are only suspension points that do not block the thread.
|
|
await self.listenAndHandleLocalNotifications()
|
|
}
|
|
}
|
|
.sheet(item: $active_sheet) { item in
|
|
switch item {
|
|
case .report(let target):
|
|
MaybeReportView(target: target)
|
|
case .post(let action):
|
|
PostView(action: action, damus_state: damus_state!)
|
|
case .user_status:
|
|
UserStatusSheet(damus_state: damus_state!, postbox: damus_state!.nostrNetwork.postbox, keypair: damus_state!.keypair, status: damus_state!.profiles.profile_data(damus_state!.pubkey).status)
|
|
.presentationDragIndicator(.visible)
|
|
case .event:
|
|
EventDetailView()
|
|
case .profile_action(let pubkey):
|
|
ProfileActionSheetView(damus_state: damus_state!, pubkey: pubkey)
|
|
case .zap(let zapsheet):
|
|
CustomizeZapView(state: damus_state!, target: zapsheet.target, lnurl: zapsheet.lnurl)
|
|
case .select_wallet(let select):
|
|
SelectWalletView(default_wallet: damus_state!.settings.default_wallet, active_sheet: $active_sheet, our_pubkey: damus_state!.pubkey, invoice: select.invoice)
|
|
case .filter:
|
|
let timeline = selected_timeline
|
|
RelayFilterView(state: damus_state!, timeline: timeline)
|
|
.presentationDetents([.height(550)])
|
|
.presentationDragIndicator(.visible)
|
|
case .onboardingSuggestions:
|
|
OnboardingSuggestionsView(model: SuggestedUsersViewModel(damus_state: damus_state!))
|
|
case .purple(let purple_url):
|
|
DamusPurpleURLSheetView(damus_state: damus_state!, purple_url: purple_url)
|
|
case .purple_onboarding:
|
|
DamusPurpleNewUserOnboardingView(damus_state: damus_state)
|
|
case .error(let error):
|
|
ErrorView(damus_state: damus_state!, error: error)
|
|
}
|
|
}
|
|
.onOpenURL { url in
|
|
Task {
|
|
let open_action = await DamusURLHandler.handle_opening_url_and_compute_view_action(damus_state: self.damus_state, url: url)
|
|
self.execute_open_action(open_action)
|
|
}
|
|
}
|
|
.onReceive(handle_notify(.compose)) { action in
|
|
self.active_sheet = .post(action)
|
|
}
|
|
.onReceive(handle_notify(.display_tabbar)) { display in
|
|
let show = display
|
|
self.hide_bar = !show
|
|
}
|
|
.onReceive(timer) { n in
|
|
self.damus_state?.nostrNetwork.postbox.try_flushing_events()
|
|
self.damus_state!.profiles.profile_data(self.damus_state!.pubkey).status.try_expire()
|
|
}
|
|
.onReceive(handle_notify(.report)) { target in
|
|
self.active_sheet = .report(target)
|
|
}
|
|
.onReceive(handle_notify(.mute)) { mute_item in
|
|
self.muting = mute_item
|
|
self.confirm_mute = true
|
|
}
|
|
.onReceive(handle_notify(.attached_wallet)) { nwc in
|
|
// update the lightning address on our profile when we attach a
|
|
// wallet with an associated
|
|
guard let ds = self.damus_state,
|
|
let lud16 = nwc.lud16,
|
|
let keypair = ds.keypair.to_full(),
|
|
let profile_txn = ds.profiles.lookup(id: ds.pubkey),
|
|
let profile = profile_txn.unsafeUnownedValue,
|
|
lud16 != profile.lud16 else {
|
|
return
|
|
}
|
|
|
|
// clear zapper cache for old lud16
|
|
if profile.lud16 != nil {
|
|
// TODO: should this be somewhere else, where we process profile events!?
|
|
invalidate_zapper_cache(pubkey: keypair.pubkey, profiles: ds.profiles, lnurl: ds.lnurls)
|
|
}
|
|
|
|
let prof = Profile(name: profile.name, display_name: profile.display_name, about: profile.about, picture: profile.picture, banner: profile.banner, website: profile.website, lud06: profile.lud06, lud16: lud16, nip05: profile.nip05, damus_donation: profile.damus_donation, reactions: profile.reactions)
|
|
|
|
guard let ev = make_metadata_event(keypair: keypair, metadata: prof) else { return }
|
|
ds.nostrNetwork.postbox.send(ev)
|
|
}
|
|
.onReceive(handle_notify(.broadcast)) { ev in
|
|
guard let ds = self.damus_state else { return }
|
|
|
|
ds.nostrNetwork.postbox.send(ev)
|
|
}
|
|
.onReceive(handle_notify(.unfollow)) { target in
|
|
guard let state = self.damus_state else { return }
|
|
_ = handle_unfollow(state: state, unfollow: target.follow_ref)
|
|
}
|
|
.onReceive(handle_notify(.unfollowed)) { unfollow in
|
|
home.resubscribe(.unfollowing(unfollow))
|
|
}
|
|
.onReceive(handle_notify(.follow)) { target in
|
|
guard let state = self.damus_state else { return }
|
|
handle_follow_notif(state: state, target: target)
|
|
}
|
|
.onReceive(handle_notify(.followed)) { _ in
|
|
home.resubscribe(.following)
|
|
}
|
|
.onReceive(handle_notify(.post)) { post in
|
|
guard let state = self.damus_state,
|
|
let keypair = state.keypair.to_full() else {
|
|
return
|
|
}
|
|
|
|
if !handle_post_notification(keypair: keypair, postbox: state.nostrNetwork.postbox, events: state.events, post: post) {
|
|
self.active_sheet = nil
|
|
}
|
|
}
|
|
.onReceive(handle_notify(.new_mutes)) { _ in
|
|
home.filter_events()
|
|
}
|
|
.onReceive(handle_notify(.mute_thread)) { _ in
|
|
home.filter_events()
|
|
}
|
|
.onReceive(handle_notify(.unmute_thread)) { _ in
|
|
home.filter_events()
|
|
}
|
|
.onReceive(handle_notify(.present_sheet)) { sheet in
|
|
self.active_sheet = sheet
|
|
}
|
|
.onReceive(handle_notify(.present_full_screen_item)) { item in
|
|
self.active_full_screen_item = item
|
|
}
|
|
.onReceive(handle_notify(.zapping)) { zap_ev in
|
|
guard !zap_ev.is_custom else {
|
|
return
|
|
}
|
|
|
|
switch zap_ev.type {
|
|
case .failed:
|
|
break
|
|
case .got_zap_invoice(let inv):
|
|
if damus_state!.settings.show_wallet_selector {
|
|
present_sheet(.select_wallet(invoice: inv))
|
|
} else {
|
|
let wallet = damus_state!.settings.default_wallet.model
|
|
do {
|
|
try open_with_wallet(wallet: wallet, invoice: inv)
|
|
}
|
|
catch {
|
|
present_sheet(.select_wallet(invoice: inv))
|
|
}
|
|
}
|
|
case .sent_from_nwc:
|
|
break
|
|
}
|
|
}
|
|
.onReceive(handle_notify(.disconnect_relays)) { () in
|
|
damus_state.nostrNetwork.pool.disconnect()
|
|
}
|
|
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { obj in
|
|
print("txn: 📙 DAMUS ACTIVE NOTIFY")
|
|
if damus_state.ndb.reopen() {
|
|
print("txn: NOSTRDB REOPENED")
|
|
} else {
|
|
print("txn: NOSTRDB FAILED TO REOPEN closed:\(damus_state.ndb.is_closed)")
|
|
}
|
|
if damus_state.purple.checkout_ids_in_progress.count > 0 {
|
|
// For extra assurance, run this after one second, to avoid race conditions if the app is also handling a damus purple welcome url.
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
|
|
Task {
|
|
let freshly_completed_checkout_ids = try? await damus_state.purple.check_status_of_checkouts_in_progress()
|
|
let there_is_a_completed_checkout: Bool = (freshly_completed_checkout_ids?.count ?? 0) > 0
|
|
let account_info = try await damus_state.purple.fetch_account(pubkey: self.keypair.pubkey)
|
|
if there_is_a_completed_checkout == true && account_info?.active == true {
|
|
if damus_state.purple.onboarding_status.user_has_never_seen_the_onboarding_before() {
|
|
// Show welcome sheet
|
|
self.active_sheet = .purple_onboarding
|
|
}
|
|
else {
|
|
self.active_sheet = .purple(DamusPurpleURL.init(is_staging: damus_state.purple.environment == .staging, variant: .landing))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Task {
|
|
await damus_state.purple.check_and_send_app_notifications_if_needed(handler: home.handle_damus_app_notification)
|
|
}
|
|
}
|
|
.onChange(of: scenePhase) { (phase: ScenePhase) in
|
|
guard let damus_state else { return }
|
|
switch phase {
|
|
case .background:
|
|
print("txn: 📙 DAMUS BACKGROUNDED")
|
|
Task { @MainActor in
|
|
damus_state.ndb.close()
|
|
}
|
|
break
|
|
case .inactive:
|
|
print("txn: 📙 DAMUS INACTIVE")
|
|
break
|
|
case .active:
|
|
print("txn: 📙 DAMUS ACTIVE")
|
|
damus_state.nostrNetwork.pool.ping()
|
|
@unknown default:
|
|
break
|
|
}
|
|
}
|
|
.onReceive(handle_notify(.onlyzaps_mode)) { hide in
|
|
home.filter_events()
|
|
|
|
guard let ds = damus_state,
|
|
let profile_txn = ds.profiles.lookup(id: ds.pubkey),
|
|
let profile = profile_txn.unsafeUnownedValue,
|
|
let keypair = ds.keypair.to_full()
|
|
else {
|
|
return
|
|
}
|
|
|
|
let prof = Profile(name: profile.name, display_name: profile.display_name, about: profile.about, picture: profile.picture, banner: profile.banner, website: profile.website, lud06: profile.lud06, lud16: profile.lud16, nip05: profile.nip05, damus_donation: profile.damus_donation, reactions: !hide)
|
|
|
|
guard let profile_ev = make_metadata_event(keypair: keypair, metadata: prof) else { return }
|
|
ds.nostrNetwork.postbox.send(profile_ev)
|
|
}
|
|
.alert(NSLocalizedString("User muted", comment: "Alert message to indicate the user has been muted"), isPresented: $user_muted_confirm, actions: {
|
|
Button(NSLocalizedString("Thanks!", comment: "Button to close out of alert that informs that the action to muted a user was successful.")) {
|
|
user_muted_confirm = false
|
|
}
|
|
}, message: {
|
|
if case let .user(pubkey, _) = self.muting {
|
|
let profile_txn = damus_state!.profiles.lookup(id: pubkey)
|
|
let profile = profile_txn?.unsafeUnownedValue
|
|
let name = Profile.displayName(profile: profile, pubkey: pubkey).username.truncate(maxLength: 50)
|
|
Text("\(name) has been muted", comment: "Alert message that informs a user was muted.")
|
|
} else {
|
|
Text("User has been muted", comment: "Alert message that informs a user was muted.")
|
|
}
|
|
})
|
|
.alert(NSLocalizedString("Create new mutelist", comment: "Title of alert prompting the user to create a new mutelist."), isPresented: $confirm_overwrite_mutelist, actions: {
|
|
Button(NSLocalizedString("Cancel", comment: "Button to cancel out of alert that creates a new mutelist.")) {
|
|
confirm_overwrite_mutelist = false
|
|
confirm_mute = false
|
|
}
|
|
|
|
Button(NSLocalizedString("Yes, Overwrite", comment: "Text of button that confirms to overwrite the existing mutelist.")) {
|
|
guard let ds = damus_state,
|
|
let keypair = ds.keypair.to_full(),
|
|
let muting,
|
|
let mutelist = create_or_update_mutelist(keypair: keypair, mprev: nil, to_add: muting)
|
|
else {
|
|
return
|
|
}
|
|
|
|
ds.mutelist_manager.set_mutelist(mutelist)
|
|
ds.nostrNetwork.postbox.send(mutelist)
|
|
|
|
confirm_overwrite_mutelist = false
|
|
confirm_mute = false
|
|
user_muted_confirm = true
|
|
}
|
|
}, message: {
|
|
Text("No mute list found, create a new one? This will overwrite any previous mute lists.", comment: "Alert message prompt that asks if the user wants to create a new mute list, overwriting previous mute lists.")
|
|
})
|
|
.alert(NSLocalizedString("Mute/Block User", comment: "Title of alert for muting/blocking a user."), isPresented: $confirm_mute, actions: {
|
|
Button(NSLocalizedString("Cancel", comment: "Alert button to cancel out of alert for muting a user."), role: .cancel) {
|
|
confirm_mute = false
|
|
}
|
|
Button(NSLocalizedString("Mute", comment: "Alert button to mute a user."), role: .destructive) {
|
|
guard let ds = damus_state else {
|
|
return
|
|
}
|
|
|
|
if ds.mutelist_manager.event == nil {
|
|
confirm_overwrite_mutelist = true
|
|
} else {
|
|
guard let keypair = ds.keypair.to_full(),
|
|
let muting
|
|
else {
|
|
return
|
|
}
|
|
|
|
guard let ev = create_or_update_mutelist(keypair: keypair, mprev: ds.mutelist_manager.event, to_add: muting) else {
|
|
return
|
|
}
|
|
|
|
ds.mutelist_manager.set_mutelist(ev)
|
|
ds.nostrNetwork.postbox.send(ev)
|
|
}
|
|
}
|
|
}, message: {
|
|
if case let .user(pubkey, _) = muting {
|
|
let profile_txn = damus_state?.profiles.lookup(id: pubkey)
|
|
let profile = profile_txn?.unsafeUnownedValue
|
|
let name = Profile.displayName(profile: profile, pubkey: pubkey).username.truncate(maxLength: 50)
|
|
Text("Mute \(name)?", comment: "Alert message prompt to ask if a user should be muted.")
|
|
} else {
|
|
Text("Could not find user to mute...", comment: "Alert message to indicate that the muted user could not be found.")
|
|
}
|
|
})
|
|
}
|
|
|
|
func switch_timeline(_ timeline: Timeline) {
|
|
self.isSideBarOpened = false
|
|
let navWasAtRoot = self.navIsAtRoot()
|
|
self.popToRoot()
|
|
|
|
notify(.switched_timeline(timeline))
|
|
|
|
if timeline == self.selected_timeline && navWasAtRoot {
|
|
notify(.scroll_to_top)
|
|
return
|
|
}
|
|
|
|
self.selected_timeline = timeline
|
|
}
|
|
|
|
/// Listens to requests to open a push/local user notification
|
|
///
|
|
/// This function never returns, it just keeps streaming
|
|
func listenAndHandleLocalNotifications() async {
|
|
for await notification in await QueueableNotify<LossyLocalNotification>.shared.stream {
|
|
self.handleNotification(notification: notification)
|
|
}
|
|
}
|
|
|
|
func handleNotification(notification: LossyLocalNotification) {
|
|
Log.info("ContentView is handling a notification", for: .push_notifications)
|
|
guard damus_state != nil else {
|
|
// This should never happen because `listenAndHandleLocalNotifications` is called after damus state is initialized in `onAppear`
|
|
assertionFailure("DamusState not loaded when ContentView (new handler) was handling a notification")
|
|
Log.error("DamusState not loaded when ContentView (new handler) was handling a notification", for: .push_notifications)
|
|
return
|
|
}
|
|
let local = notification
|
|
let openAction = local.toViewOpenAction()
|
|
self.execute_open_action(openAction)
|
|
}
|
|
|
|
func connect() {
|
|
// nostrdb
|
|
var mndb = Ndb()
|
|
if mndb == nil {
|
|
// try recovery
|
|
print("DB ISSUE! RECOVERING")
|
|
mndb = Ndb.safemode()
|
|
|
|
// out of space or something?? maybe we need a in-memory fallback
|
|
if mndb == nil {
|
|
logout(nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
guard let ndb = mndb else { return }
|
|
|
|
let model_cache = RelayModelCache()
|
|
let relay_filters = RelayFilters(our_pubkey: pubkey)
|
|
|
|
let settings = UserSettingsStore.globally_load_for(pubkey: pubkey)
|
|
|
|
let new_relay_filters = load_relay_filters(pubkey) == nil
|
|
|
|
self.damus_state = DamusState(keypair: keypair,
|
|
likes: EventCounter(our_pubkey: pubkey),
|
|
boosts: EventCounter(our_pubkey: pubkey),
|
|
contacts: Contacts(our_pubkey: pubkey),
|
|
mutelist_manager: MutelistManager(user_keypair: keypair),
|
|
profiles: Profiles(ndb: ndb),
|
|
dms: home.dms,
|
|
previews: PreviewCache(),
|
|
zaps: Zaps(our_pubkey: pubkey),
|
|
lnurls: LNUrls(),
|
|
settings: settings,
|
|
relay_filters: relay_filters,
|
|
relay_model_cache: model_cache,
|
|
drafts: Drafts(),
|
|
events: EventCache(ndb: ndb),
|
|
bookmarks: BookmarksManager(pubkey: pubkey),
|
|
replies: ReplyCounter(our_pubkey: pubkey),
|
|
wallet: WalletModel(settings: settings),
|
|
nav: self.navigationCoordinator,
|
|
music: MusicController(onChange: music_changed),
|
|
video: DamusVideoCoordinator(),
|
|
ndb: ndb,
|
|
quote_reposts: .init(our_pubkey: pubkey),
|
|
emoji_provider: DefaultEmojiProvider(showAllVariations: true)
|
|
)
|
|
|
|
home.damus_state = self.damus_state!
|
|
|
|
if let damus_state, damus_state.purple.enable_purple {
|
|
// Assign delegate so that we can send receipts to the Purple API server as soon as we get updates from user's purchases
|
|
StoreObserver.standard.delegate = damus_state.purple
|
|
Task {
|
|
await damus_state.purple.check_and_send_app_notifications_if_needed(handler: home.handle_damus_app_notification)
|
|
}
|
|
}
|
|
else {
|
|
// Purple API is an experimental feature. If not enabled, do not connect `StoreObserver` with Purple API to avoid leaking receipts
|
|
}
|
|
|
|
damus_state.nostrNetwork.pool.register_handler(sub_id: sub_id, handler: home.handle_event)
|
|
damus_state.nostrNetwork.connect()
|
|
}
|
|
|
|
func music_changed(_ state: MusicState) {
|
|
guard let damus_state else { return }
|
|
switch state {
|
|
case .playback_state:
|
|
break
|
|
case .song(let song):
|
|
guard let song, let kp = damus_state.keypair.to_full() else { return }
|
|
|
|
let pdata = damus_state.profiles.profile_data(damus_state.pubkey)
|
|
|
|
let desc = "\(song.title ?? "Unknown") - \(song.artist ?? "Unknown")"
|
|
let encodedDesc = desc.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
|
|
let url = encodedDesc.flatMap { enc in
|
|
URL(string: "spotify:search:\(enc)")
|
|
}
|
|
let music = UserStatus(type: .music, expires_at: Date.now.addingTimeInterval(song.playbackDuration), content: desc, created_at: UInt32(Date.now.timeIntervalSince1970), url: url)
|
|
|
|
pdata.status.music = music
|
|
|
|
guard let ev = music.to_note(keypair: kp) else { return }
|
|
damus_state.nostrNetwork.postbox.send(ev)
|
|
}
|
|
}
|
|
|
|
/// An open action within the app
|
|
/// This is used to model, store, and communicate a desired view action to be taken as a result of opening an object,
|
|
/// for example a URL
|
|
///
|
|
/// ## Implementation notes
|
|
///
|
|
/// - The reason this was created was to separate URL parsing logic, the underlying actions that mutate the state of the app, and the action to be taken on the view layer as a result. This makes it easier to test, to read the URL handling code, and to add new functionality in between the two (e.g. a confirmation screen before proceeding with a given open action)
|
|
enum ViewOpenAction {
|
|
/// Open a page route
|
|
case route(Route)
|
|
/// Open a sheet
|
|
case sheet(Sheets)
|
|
/// Open an external URL
|
|
case external_url(URL)
|
|
/// Do nothing.
|
|
///
|
|
/// ## Implementation notes
|
|
/// - This is used here instead of Optional values to make semantics explicit and force better programming intent, instead of accidentally doing nothing because of Swift's syntax sugar.
|
|
case no_action
|
|
}
|
|
|
|
/// Executes an action to open something in the app view
|
|
///
|
|
/// - Parameter open_action: The action to perform
|
|
func execute_open_action(_ open_action: ViewOpenAction) {
|
|
switch open_action {
|
|
case .route(let route):
|
|
navigationCoordinator.push(route: route)
|
|
case .sheet(let sheet):
|
|
self.active_sheet = sheet
|
|
case .external_url(let url):
|
|
this_app.open(url)
|
|
case .no_action:
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
struct TopbarSideMenuButton: View {
|
|
let damus_state: DamusState
|
|
@Binding var isSideBarOpened: Bool
|
|
|
|
var body: some View {
|
|
Button {
|
|
isSideBarOpened.toggle()
|
|
} label: {
|
|
ProfilePicView(pubkey: damus_state.pubkey, size: 32, highlight: .none, profiles: damus_state.profiles, disable_animation: damus_state.settings.disable_animation)
|
|
.opacity(isSideBarOpened ? 0 : 1)
|
|
.animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
|
|
.accessibilityHidden(true) // Knowing there is a profile picture here leads to no actionable outcome to VoiceOver users, so it is best not to show it
|
|
}
|
|
.accessibilityIdentifier(AppAccessibilityIdentifiers.main_side_menu_button.rawValue)
|
|
.accessibilityLabel(NSLocalizedString("Side menu", comment: "Accessibility label for the side menu button at the topbar"))
|
|
.disabled(isSideBarOpened)
|
|
}
|
|
}
|
|
|
|
struct ContentView_Previews: PreviewProvider {
|
|
static var previews: some View {
|
|
ContentView(keypair: Keypair(pubkey: test_pubkey, privkey: nil), appDelegate: nil)
|
|
}
|
|
}
|
|
|
|
func get_since_time(last_event: NostrEvent?) -> UInt32? {
|
|
if let last_event = last_event {
|
|
return last_event.created_at - 60 * 10
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
extension UINavigationController: UIGestureRecognizerDelegate {
|
|
override open func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
interactivePopGestureRecognizer?.delegate = self
|
|
}
|
|
|
|
public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
|
|
return viewControllers.count > 1
|
|
}
|
|
}
|
|
|
|
struct LastNotification {
|
|
let id: NoteId
|
|
let created_at: Int64
|
|
}
|
|
|
|
func get_last_event(_ timeline: Timeline) -> LastNotification? {
|
|
let str = timeline.rawValue
|
|
let last = UserDefaults.standard.string(forKey: "last_\(str)")
|
|
let last_created = UserDefaults.standard.string(forKey: "last_\(str)_time")
|
|
.flatMap { Int64($0) }
|
|
|
|
guard let last,
|
|
let note_id = NoteId(hex: last),
|
|
let last_created
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return LastNotification(id: note_id, created_at: last_created)
|
|
}
|
|
|
|
func save_last_event(_ ev: NostrEvent, timeline: Timeline) {
|
|
let str = timeline.rawValue
|
|
UserDefaults.standard.set(ev.id.hex(), forKey: "last_\(str)")
|
|
UserDefaults.standard.set(String(ev.created_at), forKey: "last_\(str)_time")
|
|
}
|
|
|
|
func save_last_event(_ ev_id: NoteId, created_at: UInt32, timeline: Timeline) {
|
|
let str = timeline.rawValue
|
|
UserDefaults.standard.set(ev_id.hex(), forKey: "last_\(str)")
|
|
UserDefaults.standard.set(String(created_at), forKey: "last_\(str)_time")
|
|
}
|
|
|
|
func update_filters_with_since(last_of_kind: [UInt32: NostrEvent], filters: [NostrFilter]) -> [NostrFilter] {
|
|
|
|
return filters.map { filter in
|
|
let kinds = filter.kinds ?? []
|
|
let initial: UInt32? = nil
|
|
let earliest = kinds.reduce(initial) { earliest, kind in
|
|
let last = last_of_kind[kind.rawValue]
|
|
let since: UInt32? = get_since_time(last_event: last)
|
|
|
|
if earliest == nil {
|
|
if since == nil {
|
|
return nil
|
|
}
|
|
return since
|
|
}
|
|
|
|
if since == nil {
|
|
return earliest
|
|
}
|
|
|
|
return since! < earliest! ? since! : earliest!
|
|
}
|
|
|
|
if let earliest = earliest {
|
|
var with_since = NostrFilter.copy(from: filter)
|
|
with_since.since = earliest
|
|
return with_since
|
|
}
|
|
|
|
return filter
|
|
}
|
|
}
|
|
|
|
|
|
func setup_notifications() {
|
|
this_app.registerForRemoteNotifications()
|
|
let center = UNUserNotificationCenter.current()
|
|
|
|
center.getNotificationSettings { settings in
|
|
guard settings.authorizationStatus == .authorized else {
|
|
center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
struct FindEvent {
|
|
let type: FindEventType
|
|
let find_from: [RelayURL]?
|
|
|
|
static func profile(pubkey: Pubkey, find_from: [RelayURL]? = nil) -> FindEvent {
|
|
return FindEvent(type: .profile(pubkey), find_from: find_from)
|
|
}
|
|
|
|
static func event(evid: NoteId, find_from: [RelayURL]? = nil) -> FindEvent {
|
|
return FindEvent(type: .event(evid), find_from: find_from)
|
|
}
|
|
}
|
|
|
|
enum FindEventType {
|
|
case profile(Pubkey)
|
|
case event(NoteId)
|
|
}
|
|
|
|
enum FoundEvent {
|
|
case profile(Pubkey)
|
|
case event(NostrEvent)
|
|
}
|
|
|
|
/// Finds an event from NostrDB if it exists, or from the network
|
|
///
|
|
/// This is the callback version. There is also an asyc/await version of this function.
|
|
///
|
|
/// - Parameters:
|
|
/// - state: Damus state
|
|
/// - query_: The query, including the event being looked for, and the relays to use when looking
|
|
/// - callback: The function to call with results
|
|
func find_event(state: DamusState, query query_: FindEvent, callback: @escaping (FoundEvent?) -> ()) {
|
|
return find_event_with_subid(state: state, query: query_, subid: UUID().description, callback: callback)
|
|
}
|
|
|
|
/// Finds an event from NostrDB if it exists, or from the network
|
|
///
|
|
/// This is a the async/await version of `find_event`. Use this when using callbacks is impossible or cumbersome.
|
|
///
|
|
/// - Parameters:
|
|
/// - state: Damus state
|
|
/// - query_: The query, including the event being looked for, and the relays to use when looking
|
|
/// - callback: The function to call with results
|
|
func find_event(state: DamusState, query query_: FindEvent) async -> FoundEvent? {
|
|
await withCheckedContinuation { continuation in
|
|
find_event(state: state, query: query_) { event in
|
|
var already_resumed = false
|
|
if !already_resumed { // Ensure we do not resume twice, as it causes a crash
|
|
continuation.resume(returning: event)
|
|
already_resumed = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: String, callback: @escaping (FoundEvent?) -> ()) {
|
|
|
|
var filter: NostrFilter? = nil
|
|
let find_from = query_.find_from
|
|
let query = query_.type
|
|
|
|
switch query {
|
|
case .profile(let pubkey):
|
|
if let profile_txn = state.ndb.lookup_profile(pubkey),
|
|
let record = profile_txn.unsafeUnownedValue,
|
|
record.profile != nil
|
|
{
|
|
callback(.profile(pubkey))
|
|
return
|
|
}
|
|
filter = NostrFilter(kinds: [.metadata], limit: 1, authors: [pubkey])
|
|
|
|
case .event(let evid):
|
|
if let ev = state.events.lookup(evid) {
|
|
callback(.event(ev))
|
|
return
|
|
}
|
|
|
|
filter = NostrFilter(ids: [evid], limit: 1)
|
|
}
|
|
|
|
var attempts: Int = 0
|
|
var has_event = false
|
|
guard let filter else { return }
|
|
|
|
state.nostrNetwork.pool.subscribe_to(sub_id: subid, filters: [filter], to: find_from) { relay_id, res in
|
|
guard case .nostr_event(let ev) = res else {
|
|
return
|
|
}
|
|
|
|
guard ev.subid == subid else {
|
|
return
|
|
}
|
|
|
|
switch ev {
|
|
case .ok:
|
|
break
|
|
case .event(_, let ev):
|
|
has_event = true
|
|
state.nostrNetwork.pool.unsubscribe(sub_id: subid)
|
|
|
|
switch query {
|
|
case .profile:
|
|
if ev.known_kind == .metadata {
|
|
callback(.profile(ev.pubkey))
|
|
}
|
|
case .event:
|
|
callback(.event(ev))
|
|
}
|
|
case .eose:
|
|
if !has_event {
|
|
attempts += 1
|
|
if attempts >= state.nostrNetwork.pool.our_descriptors.count {
|
|
callback(nil) // If we could not find any events in any of the relays we are connected to, send back nil
|
|
}
|
|
}
|
|
state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id]) // We are only finding an event once, so close subscription on eose
|
|
case .notice:
|
|
break
|
|
case .auth:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// Finds a replaceable event based on an `naddr` address.
|
|
///
|
|
/// This is the callback version of the function. There is another function that makes use of async/await
|
|
///
|
|
/// - Parameters:
|
|
/// - damus_state: The Damus state
|
|
/// - naddr: the `naddr` address
|
|
/// - callback: A function to handle the found event
|
|
func naddrLookup(damus_state: DamusState, naddr: NAddr, callback: @escaping (NostrEvent?) -> ()) {
|
|
let nostrKinds: [NostrKind]? = NostrKind(rawValue: naddr.kind).map { [$0] }
|
|
|
|
let filter = NostrFilter(kinds: nostrKinds, authors: [naddr.author])
|
|
|
|
let subid = UUID().description
|
|
|
|
damus_state.nostrNetwork.pool.subscribe_to(sub_id: subid, filters: [filter], to: nil) { relay_id, res in
|
|
guard case .nostr_event(let ev) = res else {
|
|
damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id])
|
|
return
|
|
}
|
|
|
|
if case .event(_, let ev) = ev {
|
|
for tag in ev.tags {
|
|
if(tag.count >= 2 && tag[0].string() == "d"){
|
|
if (tag[1].string() == naddr.identifier){
|
|
damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id])
|
|
callback(ev)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id])
|
|
}
|
|
}
|
|
|
|
/// Finds a replaceable event based on an `naddr` address.
|
|
///
|
|
/// This is the async/await version of the function. Another version of this function which makes use of callback functions also exists .
|
|
///
|
|
/// - Parameters:
|
|
/// - damus_state: The Damus state
|
|
/// - naddr: the `naddr` address
|
|
/// - callback: A function to handle the found event
|
|
func naddrLookup(damus_state: DamusState, naddr: NAddr) async -> NostrEvent? {
|
|
await withCheckedContinuation { continuation in
|
|
var already_resumed = false
|
|
naddrLookup(damus_state: damus_state, naddr: naddr) { event in
|
|
if !already_resumed { // Ensure we do not resume twice, as it causes a crash
|
|
continuation.resume(returning: event)
|
|
already_resumed = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func timeline_name(_ timeline: Timeline?) -> String {
|
|
guard let timeline else {
|
|
return ""
|
|
}
|
|
switch timeline {
|
|
case .home:
|
|
return NSLocalizedString("Home", comment: "Navigation bar title for Home view where notes and replies appear from those who the user is following.")
|
|
case .notifications:
|
|
return NSLocalizedString("Notifications", comment: "Toolbar label for Notifications view.")
|
|
case .search:
|
|
return NSLocalizedString("Universe 🛸", comment: "Toolbar label for the universal view where notes from all connected relay servers appear.")
|
|
case .dms:
|
|
return NSLocalizedString("DMs", comment: "Toolbar label for DMs view, where DM is the English abbreviation for Direct Message.")
|
|
}
|
|
}
|
|
|
|
@discardableResult
|
|
func handle_unfollow(state: DamusState, unfollow: FollowRef) -> Bool {
|
|
guard let keypair = state.keypair.to_full() else {
|
|
return false
|
|
}
|
|
|
|
let old_contacts = state.contacts.event
|
|
|
|
guard let ev = unfollow_reference(postbox: state.nostrNetwork.postbox, our_contacts: old_contacts, keypair: keypair, unfollow: unfollow)
|
|
else {
|
|
return false
|
|
}
|
|
|
|
notify(.unfollowed(unfollow))
|
|
|
|
state.contacts.event = ev
|
|
|
|
switch unfollow {
|
|
case .pubkey(let pk):
|
|
state.contacts.remove_friend(pk)
|
|
case .hashtag:
|
|
// nothing to handle here really
|
|
break
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
@discardableResult
|
|
func handle_follow(state: DamusState, follow: FollowRef) -> Bool {
|
|
guard let keypair = state.keypair.to_full() else {
|
|
return false
|
|
}
|
|
|
|
guard let ev = follow_reference(box: state.nostrNetwork.postbox, our_contacts: state.contacts.event, keypair: keypair, follow: follow)
|
|
else {
|
|
return false
|
|
}
|
|
|
|
notify(.followed(follow))
|
|
|
|
state.contacts.event = ev
|
|
switch follow {
|
|
case .pubkey(let pubkey):
|
|
state.contacts.add_friend_pubkey(pubkey)
|
|
case .hashtag:
|
|
// nothing to do
|
|
break
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
@discardableResult
|
|
func handle_follow_notif(state: DamusState, target: FollowTarget) -> Bool {
|
|
switch target {
|
|
case .pubkey(let pk):
|
|
state.contacts.add_friend_pubkey(pk)
|
|
case .contact(let ev):
|
|
state.contacts.add_friend_contact(ev)
|
|
}
|
|
|
|
return handle_follow(state: state, follow: target.follow_ref)
|
|
}
|
|
|
|
func handle_post_notification(keypair: FullKeypair, postbox: PostBox, events: EventCache, post: NostrPostResult) -> Bool {
|
|
switch post {
|
|
case .post(let post):
|
|
//let post = tup.0
|
|
//let to_relays = tup.1
|
|
print("post \(post.content)")
|
|
guard let new_ev = post.to_event(keypair: keypair) else {
|
|
return false
|
|
}
|
|
postbox.send(new_ev)
|
|
for eref in new_ev.referenced_ids.prefix(3) {
|
|
// also broadcast at most 3 referenced events
|
|
if let ev = events.lookup(eref) {
|
|
postbox.send(ev)
|
|
}
|
|
}
|
|
for qref in new_ev.referenced_quote_ids.prefix(3) {
|
|
// also broadcast at most 3 referenced quoted events
|
|
if let ev = events.lookup(qref.note_id) {
|
|
postbox.send(ev)
|
|
}
|
|
}
|
|
return true
|
|
case .cancel:
|
|
print("post cancelled")
|
|
return false
|
|
}
|
|
}
|
|
|
|
extension LossyLocalNotification {
|
|
/// Computes a view open action from a mention reference.
|
|
/// Use this when opening a user-presentable interface to a specific mention reference.
|
|
func toViewOpenAction() -> ContentView.ViewOpenAction {
|
|
switch self.mention {
|
|
case .pubkey(let pubkey):
|
|
return .route(.ProfileByKey(pubkey: pubkey))
|
|
case .note(let noteId):
|
|
return .route(.LoadableNostrEvent(note_reference: .note_id(noteId)))
|
|
case .nevent(let nEvent):
|
|
// TODO: Improve this by implementing a route that handles nevents with their relay hints.
|
|
return .route(.LoadableNostrEvent(note_reference: .note_id(nEvent.noteid)))
|
|
case .nprofile(let nProfile):
|
|
// TODO: Improve this by implementing a profile route that handles nprofiles with their relay hints.
|
|
return .route(.ProfileByKey(pubkey: nProfile.author))
|
|
case .nrelay:
|
|
// We do not need to implement `nrelay` support, it has been deprecated.
|
|
// See https://github.com/nostr-protocol/nips/blob/6e7a618e7f873bb91e743caacc3b09edab7796a0/BREAKING.md?plain=1#L21
|
|
return .sheet(.error(ErrorView.UserPresentableError(
|
|
user_visible_description: NSLocalizedString("You opened an invalid link. The link you tried to open refers to \"nrelay\", which has been deprecated and is not supported.", comment: "User-visible error description for a user who tries to open a deprecated \"nrelay\" link."),
|
|
tip: NSLocalizedString("Please contact the person who provided the link, and ask for another link.", comment: "User-visible tip on what to do if a link contains a deprecated \"nrelay\" reference."),
|
|
technical_info: "`MentionRef.toViewOpenAction` detected deprecated `nrelay` contents"
|
|
)))
|
|
case .naddr(let nAddr):
|
|
return .route(.LoadableNostrEvent(note_reference: .naddr(nAddr)))
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
func logout(_ state: DamusState?)
|
|
{
|
|
state?.close()
|
|
notify(.logout)
|
|
}
|
|
|