354 lines
13 KiB
Rust
354 lines
13 KiB
Rust
use anyhow::{anyhow, Error};
|
|
use global::{constants::NEW_MESSAGE_SUB_ID, get_client};
|
|
use gpui::{
|
|
div, prelude::FluentBuilder, px, uniform_list, App, AppContext, Context, Entity, FocusHandle,
|
|
InteractiveElement, IntoElement, ParentElement, Render, Styled, Subscription, Task, TextAlign,
|
|
Window,
|
|
};
|
|
use nostr_sdk::prelude::*;
|
|
use smallvec::{smallvec, SmallVec};
|
|
use ui::{
|
|
button::{Button, ButtonVariants},
|
|
input::{InputEvent, TextInput},
|
|
theme::{scale::ColorScaleStep, ActiveTheme},
|
|
ContextModal, IconName, Sizable,
|
|
};
|
|
|
|
use crate::device::Device;
|
|
|
|
const MESSAGE: &str = "In order to receive messages from others, you need to setup Messaging Relays. You can use the recommend relays or add more.";
|
|
const HELP_TEXT: &str = "Please add some relays.";
|
|
|
|
pub fn init(window: &mut Window, cx: &mut App) -> Entity<Relays> {
|
|
Relays::new(window, cx)
|
|
}
|
|
|
|
pub struct Relays {
|
|
relays: Entity<Vec<RelayUrl>>,
|
|
input: Entity<TextInput>,
|
|
focus_handle: FocusHandle,
|
|
is_loading: bool,
|
|
#[allow(dead_code)]
|
|
subscriptions: SmallVec<[Subscription; 1]>,
|
|
}
|
|
|
|
impl Relays {
|
|
pub fn new(window: &mut Window, cx: &mut App) -> Entity<Self> {
|
|
let client = get_client();
|
|
|
|
let relays = cx.new(|cx| {
|
|
let relays = vec![
|
|
RelayUrl::parse("wss://auth.nostr1.com").unwrap(),
|
|
RelayUrl::parse("wss://relay.0xchat.com").unwrap(),
|
|
];
|
|
|
|
let task: Task<Result<Vec<RelayUrl>, Error>> = cx.background_spawn(async move {
|
|
let signer = client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::InboxRelays)
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
if let Some(event) = client.database().query(filter).await?.first_owned() {
|
|
let relays = event
|
|
.tags
|
|
.filter_standardized(TagKind::Relay)
|
|
.filter_map(|t| match t {
|
|
TagStandard::Relay(url) => Some(url.to_owned()),
|
|
_ => None,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Ok(relays)
|
|
} else {
|
|
Err(anyhow!("Messaging Relays not found."))
|
|
}
|
|
});
|
|
|
|
cx.spawn(|this, cx| async move {
|
|
if let Ok(relays) = task.await {
|
|
_ = cx.update(|cx| {
|
|
_ = this.update(cx, |this: &mut Vec<RelayUrl>, cx| {
|
|
*this = relays;
|
|
cx.notify();
|
|
});
|
|
});
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
relays
|
|
});
|
|
|
|
let input = cx.new(|cx| {
|
|
TextInput::new(window, cx)
|
|
.text_size(ui::Size::XSmall)
|
|
.small()
|
|
.placeholder("wss://example.com")
|
|
});
|
|
|
|
cx.new(|cx| {
|
|
let mut subscriptions = smallvec![];
|
|
|
|
subscriptions.push(cx.subscribe_in(
|
|
&input,
|
|
window,
|
|
move |this: &mut Relays, _, input_event, window, cx| {
|
|
if let InputEvent::PressEnter = input_event {
|
|
this.add(window, cx);
|
|
}
|
|
},
|
|
));
|
|
|
|
Self {
|
|
relays,
|
|
input,
|
|
subscriptions,
|
|
is_loading: false,
|
|
focus_handle: cx.focus_handle(),
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn update(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
let relays = self.relays.read(cx).clone();
|
|
let window_handle = window.window_handle();
|
|
|
|
// Show loading spinner
|
|
self.set_loading(true, cx);
|
|
|
|
let task: Task<Result<EventId, Error>> = cx.background_spawn(async move {
|
|
let client = get_client();
|
|
let signer = client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
// If user didn't have any NIP-65 relays, add default ones
|
|
if client.database().relay_list(public_key).await?.is_empty() {
|
|
let builder = EventBuilder::relay_list(vec![
|
|
(RelayUrl::parse("wss://relay.damus.io/").unwrap(), None),
|
|
(RelayUrl::parse("wss://relay.primal.net/").unwrap(), None),
|
|
]);
|
|
|
|
if let Err(e) = client.send_event_builder(builder).await {
|
|
log::error!("Failed to send relay list event: {}", e);
|
|
}
|
|
}
|
|
|
|
let tags: Vec<Tag> = relays
|
|
.iter()
|
|
.map(|relay| Tag::custom(TagKind::Relay, vec![relay.to_string()]))
|
|
.collect();
|
|
|
|
let builder = EventBuilder::new(Kind::InboxRelays, "").tags(tags);
|
|
let output = client.send_event_builder(builder).await?;
|
|
|
|
// Connect to messaging relays
|
|
for relay in relays.into_iter() {
|
|
_ = client.add_relay(&relay).await;
|
|
_ = client.connect_relay(&relay).await;
|
|
}
|
|
|
|
let sub_id = SubscriptionId::new(NEW_MESSAGE_SUB_ID);
|
|
|
|
// Close old subscription
|
|
client.unsubscribe(&sub_id).await;
|
|
|
|
// Subscribe to new messages
|
|
if let Err(e) = client
|
|
.subscribe_with_id(
|
|
sub_id,
|
|
Filter::new()
|
|
.kind(Kind::GiftWrap)
|
|
.pubkey(public_key)
|
|
.limit(0),
|
|
None,
|
|
)
|
|
.await
|
|
{
|
|
log::error!("Failed to subscribe to new messages: {}", e);
|
|
}
|
|
|
|
Ok(output.val)
|
|
});
|
|
|
|
cx.spawn(|this, mut cx| async move {
|
|
if task.await.is_ok() {
|
|
cx.update_window(window_handle, |_, window, cx| {
|
|
_ = this.update(cx, |this, cx| {
|
|
this.set_loading(false, cx);
|
|
cx.notify();
|
|
});
|
|
|
|
if let Some(device) = Device::global(cx) {
|
|
let relays = this
|
|
.read_with(cx, |this, cx| this.relays.read(cx).clone())
|
|
.unwrap();
|
|
|
|
device.update(cx, |this, cx| {
|
|
if let Some(profile) = this.profile() {
|
|
let new_profile = profile.clone().relays(Some(relays.into()));
|
|
this.set_profile(new_profile, cx);
|
|
}
|
|
})
|
|
}
|
|
|
|
window.close_modal(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
pub fn loading(&self) -> bool {
|
|
self.is_loading
|
|
}
|
|
|
|
fn set_loading(&mut self, status: bool, cx: &mut Context<Self>) {
|
|
self.is_loading = status;
|
|
cx.notify();
|
|
}
|
|
|
|
fn add(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
let value = self.input.read(cx).text().to_string();
|
|
|
|
if !value.starts_with("ws") {
|
|
return;
|
|
}
|
|
|
|
if let Ok(url) = RelayUrl::parse(&value) {
|
|
self.relays.update(cx, |this, cx| {
|
|
if !this.contains(&url) {
|
|
this.push(url);
|
|
cx.notify();
|
|
}
|
|
});
|
|
|
|
self.input.update(cx, |this, cx| {
|
|
this.set_text("", window, cx);
|
|
});
|
|
}
|
|
}
|
|
|
|
fn remove(&mut self, ix: usize, _window: &mut Window, cx: &mut Context<Self>) {
|
|
self.relays.update(cx, |this, cx| {
|
|
this.remove(ix);
|
|
cx.notify();
|
|
});
|
|
}
|
|
}
|
|
|
|
impl Render for Relays {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
div()
|
|
.track_focus(&self.focus_handle)
|
|
.flex()
|
|
.flex_col()
|
|
.gap_2()
|
|
.w_full()
|
|
.child(
|
|
div()
|
|
.px_2()
|
|
.text_xs()
|
|
.text_color(cx.theme().base.step(cx, ColorScaleStep::ELEVEN))
|
|
.child(MESSAGE),
|
|
)
|
|
.child(
|
|
div()
|
|
.px_2()
|
|
.w_full()
|
|
.flex()
|
|
.flex_col()
|
|
.gap_2()
|
|
.child(
|
|
div()
|
|
.flex()
|
|
.items_center()
|
|
.w_full()
|
|
.gap_2()
|
|
.child(self.input.clone())
|
|
.child(
|
|
Button::new("add_relay_btn")
|
|
.icon(IconName::Plus)
|
|
.small()
|
|
.rounded(px(cx.theme().radius))
|
|
.on_click(
|
|
cx.listener(|this, _, window, cx| this.add(window, cx)),
|
|
),
|
|
),
|
|
)
|
|
.map(|this| {
|
|
let view = cx.entity();
|
|
let relays = self.relays.read(cx).clone();
|
|
let total = relays.len();
|
|
|
|
if !relays.is_empty() {
|
|
this.child(
|
|
uniform_list(
|
|
view,
|
|
"relays",
|
|
total,
|
|
move |_, range, _window, cx| {
|
|
let mut items = Vec::new();
|
|
|
|
for ix in range {
|
|
let item = relays.get(ix).unwrap().clone().to_string();
|
|
|
|
items.push(
|
|
div().group("").w_full().h_9().py_0p5().child(
|
|
div()
|
|
.px_2()
|
|
.h_full()
|
|
.w_full()
|
|
.flex()
|
|
.items_center()
|
|
.justify_between()
|
|
.rounded(px(cx.theme().radius))
|
|
.bg(cx
|
|
.theme()
|
|
.base
|
|
.step(cx, ColorScaleStep::THREE))
|
|
.text_xs()
|
|
.child(item)
|
|
.child(
|
|
Button::new("remove_{ix}")
|
|
.icon(IconName::Close)
|
|
.xsmall()
|
|
.ghost()
|
|
.invisible()
|
|
.group_hover("", |this| {
|
|
this.visible()
|
|
})
|
|
.on_click(cx.listener(
|
|
move |this, _, window, cx| {
|
|
this.remove(ix, window, cx)
|
|
},
|
|
)),
|
|
),
|
|
),
|
|
)
|
|
}
|
|
|
|
items
|
|
},
|
|
)
|
|
.w_full()
|
|
.min_h(px(120.)),
|
|
)
|
|
} else {
|
|
this.h_20()
|
|
.mb_2()
|
|
.flex()
|
|
.items_center()
|
|
.justify_center()
|
|
.text_xs()
|
|
.text_align(TextAlign::Center)
|
|
.child(HELP_TEXT)
|
|
}
|
|
}),
|
|
)
|
|
}
|
|
}
|