aboutsummaryrefslogtreecommitdiffstats
path: root/src/main.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/main.rs')
-rw-r--r--src/main.rs478
1 files changed, 385 insertions, 93 deletions
diff --git a/src/main.rs b/src/main.rs
index b2308fb..1a940fd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,38 +1,127 @@
+use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
+use std::fmt::Debug;
+use std::ops::{Deref, DerefMut};
use iced::futures::{SinkExt, Stream, StreamExt};
-use iced::widget::{button, column, row, text, text_input};
-use iced::{stream, Element, Subscription, Task, Theme};
+use iced::widget::text::{Fragment, IntoFragment};
+use iced::widget::{
+ button, center, column, container, mouse_area, opaque, row, stack, text, text_input, Text,
+};
+use iced::{stream, Color, Element, Subscription, Task, Theme};
use jid::JID;
use luz::chat::{Chat, Message as ChatMessage};
use luz::presence::{Offline, Presence};
use luz::CommandMessage;
use luz::{roster::Contact, user::User, LuzHandle, UpdateMessage};
-use tokio::sync::oneshot;
+use tokio::sync::{mpsc, oneshot};
use tokio_stream::wrappers::ReceiverStream;
+use tracing::info;
-#[derive(Default)]
pub struct Macaw {
- client: Option<LuzHandle>,
+ client: Account,
roster: HashMap<JID, Contact>,
users: HashMap<JID, User>,
presences: HashMap<JID, Presence>,
chats: HashMap<JID, (Chat, Vec<ChatMessage>)>,
subscription_requests: HashSet<JID>,
- connection_status: Option<Presence>,
+}
+
+pub struct Creds {
+ jid: String,
+ password: String,
+}
+
+impl Macaw {
+ pub fn new(client: Option<Client>) -> Self {
+ let account;
+ if let Some(client) = client {
+ account = Account::LoggedIn(client);
+ } else {
+ account = Account::LoggedOut {
+ jid: "".to_string(),
+ password: "".to_string(),
+ error: None,
+ };
+ }
+
+ Self {
+ client: account,
+ roster: HashMap::new(),
+ users: HashMap::new(),
+ presences: HashMap::new(),
+ chats: HashMap::new(),
+ subscription_requests: HashSet::new(),
+ }
+ }
+}
+
+pub enum Account {
+ LoggedIn(Client),
+ LoggedOut {
+ jid: String,
+ password: String,
+ error: Option<Error>,
+ },
+}
+
+#[derive(Debug, Clone)]
+pub enum Error {
+ InvalidJID(String),
+ DatabaseConnection,
+}
+
+#[derive(Clone, Debug)]
+pub struct Client {
+ client: LuzHandle,
+ jid: JID,
+ connection_status: Presence,
+}
+
+impl DerefMut for Client {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.client
+ }
+}
+
+impl Deref for Client {
+ type Target = LuzHandle;
+
+ fn deref(&self) -> &Self::Target {
+ &self.client
+ }
}
fn main() -> iced::Result {
tracing_subscriber::fmt::init();
- iced::application("Macaw", Macaw::update, Macaw::view)
- .subscription(Macaw::subscription)
- .run()
+ let client: Option<(JID, LuzHandle, mpsc::Receiver<UpdateMessage>)> = None;
+
+ if let Some((jid, luz_handle, update_recv)) = client {
+ let stream = ReceiverStream::new(update_recv);
+ let stream = stream.map(|message| Message::Luz(message));
+ iced::application("Macaw", Macaw::update, Macaw::view).run_with(|| {
+ (
+ Macaw::new(Some(Client {
+ client: luz_handle,
+ // TODO:
+ jid,
+ connection_status: Presence::Offline(Offline::default()),
+ })),
+ // TODO: autoconnect config
+ Task::stream(stream),
+ )
+ })
+ } else {
+ iced::application("Macaw", Macaw::update, Macaw::view)
+ .run_with(|| (Macaw::new(None), Task::none()))
+ }
}
#[derive(Debug, Clone)]
enum Message {
- ClientCreated(LuzHandle),
+ LoginModal(LoginModalMessage),
+ ClientCreated(Client),
Luz(UpdateMessage),
Roster(HashMap<JID, Contact>),
Connect,
@@ -40,27 +129,15 @@ enum Message {
OpenChat(JID),
}
-impl Macaw {
- fn stream() -> impl Stream<Item = Message> {
- stream::channel(100, |mut output| async {
- let (luz, recv) = LuzHandle::new(
- "test@blos.sm".try_into().unwrap(),
- "slayed".to_string(),
- "./macaw.db",
- )
- .await
- .unwrap();
- output.send(Message::ClientCreated(luz)).await;
- let stream = ReceiverStream::new(recv);
- let stream = stream.map(|message| Message::Luz(message)).map(Ok);
- stream.forward(output).await;
- })
- }
-
- fn subscription(&self) -> Subscription<Message> {
- Subscription::run(Macaw::stream)
- }
+#[derive(Debug, Clone)]
+enum LoginModalMessage {
+ JID(String),
+ Password(String),
+ Submit,
+ Error(Error),
+}
+impl Macaw {
fn update(&mut self, message: Message) -> Task<Message> {
match message {
Message::Luz(update_message) => match update_message {
@@ -68,18 +145,35 @@ impl Macaw {
tracing::error!("Luz error: {:?}", error);
Task::none()
}
- UpdateMessage::Online(online, vec) => {
- self.connection_status = Some(Presence::Online(online));
- let mut roster = HashMap::new();
- for contact in vec {
- roster.insert(contact.user_jid.clone(), contact);
+ UpdateMessage::Online(online, vec) => match &mut self.client {
+ Account::LoggedIn(client) => {
+ client.connection_status = Presence::Online(online);
+ let mut roster = HashMap::new();
+ for contact in vec {
+ roster.insert(contact.user_jid.clone(), contact);
+ }
+ self.roster = roster;
+ Task::none()
}
- self.roster = roster;
- Task::none()
- }
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => Task::none(),
+ },
UpdateMessage::Offline(offline) => {
- self.connection_status = Some(Presence::Offline(offline));
- Task::none()
+ // TODO: update all contacts' presences to unknown (offline)
+ match &mut self.client {
+ Account::LoggedIn(client) => {
+ client.connection_status = Presence::Offline(offline);
+ Task::none()
+ }
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => Task::none(),
+ }
}
UpdateMessage::FullRoster(vec) => {
let mut macaw_roster = HashMap::new();
@@ -118,13 +212,13 @@ impl Macaw {
Task::none()
}
},
- Message::ClientCreated(luz_handle) => {
- let cloned: LuzHandle = luz_handle.clone();
- self.client = Some(cloned);
+ // TODO: NEXT
+ Message::ClientCreated(client) => {
+ self.client = Account::LoggedIn(client.clone());
let (send, recv) = oneshot::channel();
Task::perform(
async move {
- luz_handle.send(CommandMessage::GetRoster(send)).await;
+ client.client.send(CommandMessage::GetRoster(send)).await;
recv.await
},
|result| {
@@ -141,64 +235,262 @@ impl Macaw {
self.roster = hash_map;
Task::none()
}
- Message::Connect => {
- let client = self.client.clone();
- Task::future(async move {
- client.clone().unwrap().send(CommandMessage::Connect).await;
- })
- .discard()
- }
- Message::Disconnect => {
- let client = self.client.clone();
- Task::future(async move {
- client
- .clone()
- .unwrap()
- .send(CommandMessage::Disconnect(Offline::default()))
- .await;
- })
- .discard()
- }
+ Message::Connect => match &self.client {
+ Account::LoggedIn(client) => {
+ let client = client.client.clone();
+ Task::future(async move {
+ client.send(CommandMessage::Connect).await;
+ })
+ .discard()
+ }
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => Task::none(),
+ },
+ Message::Disconnect => match &self.client {
+ Account::LoggedIn(client) => {
+ let client = client.client.clone();
+ Task::future(async move {
+ client
+ .send(CommandMessage::Disconnect(Offline::default()))
+ .await;
+ })
+ .discard()
+ }
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => Task::none(),
+ },
Message::OpenChat(jid) => todo!(),
+ Message::LoginModal(login_modal_message) => match login_modal_message {
+ LoginModalMessage::JID(j) => match &mut self.client {
+ Account::LoggedIn(_client) => Task::none(),
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => {
+ *jid = j;
+ Task::none()
+ }
+ },
+ LoginModalMessage::Password(p) => match &mut self.client {
+ Account::LoggedIn(_client) => Task::none(),
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => {
+ *password = p;
+ Task::none()
+ }
+ },
+ LoginModalMessage::Submit => match &self.client {
+ Account::LoggedIn(_client) => Task::none(),
+ Account::LoggedOut {
+ jid: jid_str,
+ password,
+ error,
+ } => {
+ info!("submitting login");
+ let jid_str = jid_str.clone();
+ let password = password.clone();
+ Task::future(async move {
+ let jid: Result<JID, _> = jid_str.parse();
+ match jid {
+ Ok(j) => {
+ let result =
+ LuzHandle::new(j.clone(), password.to_string(), "macaw.db")
+ .await;
+ match result {
+ Ok((luz_handle, receiver)) => {
+ let stream = ReceiverStream::new(receiver);
+ let stream =
+ stream.map(|message| Message::Luz(message));
+ vec![
+ Task::done(Message::ClientCreated(Client {
+ client: luz_handle,
+ jid: j,
+ connection_status: Presence::Offline(
+ Offline::default(),
+ ),
+ })),
+ Task::stream(stream),
+ ]
+ }
+ Err(e) => {
+ tracing::error!("error (database probably)");
+ return vec![Task::done(Message::LoginModal(
+ LoginModalMessage::Error(Error::DatabaseConnection),
+ ))];
+ }
+ }
+ }
+ Err(_) => {
+ tracing::error!("parsing jid");
+ return vec![Task::done(Message::LoginModal(
+ LoginModalMessage::Error(Error::InvalidJID(
+ jid_str.to_string(),
+ )),
+ ))];
+ }
+ }
+ })
+ .then(|tasks| Task::batch(tasks))
+ }
+ },
+ LoginModalMessage::Error(e) => match &mut self.client {
+ Account::LoggedIn(_client) => Task::none(),
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => {
+ tracing::error!("luz::new: {:?}", e);
+ *error = Some(e);
+ Task::none()
+ }
+ },
+ },
}
}
fn view(&self) -> Element<Message> {
- let mut contacts: Vec<Element<Message>> = Vec::new();
- for (_, contact) in &self.roster {
- contacts.push(
- button(match &contact.user_jid.localpart {
- Some(u) => u,
- None => "no username",
- })
- .on_press(Message::OpenChat(contact.user_jid.clone()))
- .into(),
- );
- }
- let column = column(contacts);
- let connection_status = match &self.connection_status {
- Some(s) => match s {
- Presence::Online(online) => "connected",
- Presence::Offline(offline) => "disconnected",
- },
- None => "no account",
+ let ui = {
+ let mut contacts: Vec<Element<Message>> = Vec::new();
+ for (_, contact) in &self.roster {
+ let jid: Cow<'_, str> = (&contact.user_jid).into();
+ contacts.push(
+ button(text(jid))
+ .on_press(Message::OpenChat(contact.user_jid.clone()))
+ .into(),
+ );
+ }
+ let column = column(contacts);
+ let connection_status = match &self.client {
+ Account::LoggedIn(client) => match &client.connection_status {
+ Presence::Online(_online) => "online",
+ Presence::Offline(_offline) => "disconnected",
+ },
+ Account::LoggedOut {
+ jid: _,
+ password: _,
+ error,
+ } => "disconnected",
+ };
+ // match &self.client.as_ref().map(|client| &client.connection_status) {
+ // Some(s) => match s {
+ // Presence::Online(online) => "connected",
+ // Presence::Offline(offline) => "disconnected",
+ // },
+ // None => "no account",
+ // };
+ let client_jid: Cow<'_, str> = match &self.client {
+ Account::LoggedIn(client) => (&client.jid).into(),
+ Account::LoggedOut {
+ jid: _,
+ password: _,
+ error,
+ } => Cow::from("no account"),
+ // map(|client| (&client.jid).into());
+ };
+ column![
+ row![
+ text(client_jid),
+ text(connection_status),
+ button("connect").on_press(Message::Connect),
+ button("disconnect").on_press(Message::Disconnect)
+ ],
+ text("Buddy List:"),
+ //
+ //
+ column,
+ ]
};
- column![
- row![
- text("test@blos.sm"),
- text(connection_status),
- button("connect").on_press(Message::Connect),
- button("disconnect").on_press(Message::Disconnect)
- ],
- text("Buddy List:"),
- //
- //
- column,
- ]
- .into()
+
+ // temporarily center to fill space
+ let ui = center(ui).into();
+
+ match &self.client {
+ Account::LoggedIn(_client) => ui,
+ Account::LoggedOut {
+ jid,
+ password,
+ error,
+ } => {
+ let signup = container(
+ column![
+ text("Log In").size(24),
+ column![
+ column![
+ text("JID").size(12),
+ text_input("berry@macaw.chat", &jid)
+ .on_input(|j| Message::LoginModal(LoginModalMessage::JID(j)))
+ .on_submit(Message::LoginModal(LoginModalMessage::Submit))
+ .padding(5),
+ ]
+ .spacing(5),
+ column![
+ text("Password").size(12),
+ text_input("", &password)
+ .on_input(|p| Message::LoginModal(LoginModalMessage::Password(
+ p
+ )))
+ .on_submit(Message::LoginModal(LoginModalMessage::Submit))
+ .secure(true)
+ .padding(5),
+ ]
+ .spacing(5),
+ button(text("Submit"))
+ .on_press(Message::LoginModal(LoginModalMessage::Submit)),
+ ]
+ .spacing(10)
+ ]
+ .spacing(20),
+ )
+ .width(300)
+ .padding(10)
+ .style(container::rounded_box);
+
+ // signup.into()
+ modal(ui, signup)
+ }
+ }
}
fn theme(&self) -> Theme {
Theme::Dark
}
}
+
+fn modal<'a, Message>(
+ base: impl Into<Element<'a, Message>>,
+ content: impl Into<Element<'a, Message>>,
+ // on_blur: Message,
+) -> Element<'a, Message>
+where
+ Message: Clone + 'a,
+{
+ stack![
+ base.into(),
+ opaque(
+ mouse_area(center(opaque(content)).style(|_theme| {
+ container::Style {
+ background: Some(
+ Color {
+ a: 0.8,
+ ..Color::BLACK
+ }
+ .into(),
+ ),
+ ..container::Style::default()
+ }
+ })) // .on_press(on_blur)
+ )
+ ]
+ .into()
+}
generated by cgit (git 2.34.1) at 2025-04-04 16:42:43 +0000