Refactor conversations

conversations/src/common.rs

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::Arc;
+
+pub use crate::errors::ChatError;
+use crate::types::{AddressedEncryptedPayload, ContentData};
+
+pub type ChatId<'a> = &'a str;
+pub type ChatIdOwned = Arc<str>;
+
+pub trait HasChatId: Debug {
+    fn id(&self) -> ChatId<'_>;
+}
+
+pub trait InboundMessageHandler {
+    fn handle_frame(
+        &mut self,
+        encoded_payload: &[u8],
+    ) -> Result<(Box<dyn Chat>, Vec<ContentData>), ChatError>;
+}
+
+pub trait Chat: HasChatId + Debug {
+    fn send_message(&mut self, content: &[u8])
+    -> Result<Vec<AddressedEncryptedPayload>, ChatError>;
+
+    fn remote_id(&self) -> String;
+}
+
+pub struct ChatStore {
+    chats: HashMap<Arc<str>, Box<dyn Chat>>,
+    handlers: HashMap<Arc<str>, Box<dyn InboundMessageHandler>>,
+}
+
+impl ChatStore {
+    pub fn new() -> Self {
+        Self {
+            chats: HashMap::new(),
+            handlers: HashMap::new(),
+        }
+    }
+
+    pub fn insert_chat(&mut self, conversation: impl Chat + HasChatId + 'static) -> ChatIdOwned {
+        let key: ChatIdOwned = Arc::from(conversation.id());
+        self.chats.insert(key.clone(), Box::new(conversation));
+        key
+    }
+
+    pub fn register_handler(
+        &mut self,
+        handler: impl InboundMessageHandler + HasChatId + 'static,
+    ) -> ChatIdOwned {
+        let key: ChatIdOwned = Arc::from(handler.id());
+        self.handlers.insert(key.clone(), Box::new(handler));
+        key
+    }
+
+    pub fn get_chat(&self, id: ChatId) -> Option<&(dyn Chat + '_)> {
+        self.chats.get(id).map(|c| c.as_ref())
+    }
+
+    pub fn get_mut_chat(&mut self, id: &str) -> Option<&mut (dyn Chat + '_)> {
+        Some(self.chats.get_mut(id)?.as_mut())
+    }
+
+    pub fn get_handler(&mut self, id: ChatId) -> Option<&mut (dyn InboundMessageHandler + '_)> {
+        Some(self.handlers.get_mut(id)?.as_mut())
+    }
+
+    pub fn chat_ids(&self) -> impl Iterator<Item = ChatIdOwned> + '_ {
+        self.chats.keys().cloned()
+    }
+
+    pub fn handler_ids(&self) -> impl Iterator<Item = ChatIdOwned> + '_ {
+        self.handlers.keys().cloned()
+    }
+}

conversations/src/context.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, rc::Rc, sync::Arc};
 
 use crate::{
-    conversation::{ConversationStore, Convo, Id},
+    common::{Chat, ChatStore, HasChatId},
     errors::ChatError,
     identity::Identity,
     inbox::Inbox,
@@ -20,9 +20,8 @@ pub type ConvoHandle = u32;
 // Ctx manages lifetimes of objects to process and generate payloads.
 pub struct Context {
     _identity: Rc<Identity>,
-    store: ConversationStore,
+    store: ChatStore,
     inbox: Inbox,
-    buf_size: usize,
     convo_handle_map: HashMap<u32, Arc<str>>,
     next_convo_handle: ConvoHandle,
 }
@@ -33,22 +32,13 @@ impl Context {
         let inbox = Inbox::new(Rc::clone(&identity)); //
         Self {
             _identity: identity,
-            store: ConversationStore::new(),
+            store: ChatStore::new(),
             inbox,
-            buf_size: 0,
             convo_handle_map: HashMap::new(),
             next_convo_handle: INITIAL_CONVO_HANDLE,
         }
     }
 
-    pub fn buffer_size(&self) -> usize {
-        self.buf_size
-    }
-
-    pub fn set_buffer_size(&mut self, size: usize) {
-        self.buf_size = size
-    }
-
     pub fn create_private_convo(
         &mut self,
         remote_bundle: &Introduction,
@@ -99,43 +89,25 @@ impl Context {
         Ok(Introduction::from(pkb).into())
     }
 
-    fn add_convo(&mut self, convo: impl Convo + Id + 'static) -> ConvoHandle {
+    fn add_convo(&mut self, convo: impl Chat + HasChatId + 'static) -> ConvoHandle {
         let handle = self.next_convo_handle;
         self.next_convo_handle += 1;
-        let convo_id = self.store.insert_convo(convo);
+        let convo_id = self.store.insert_chat(convo);
         self.convo_handle_map.insert(handle, convo_id);
 
         handle
     }
 
     // Returns a mutable reference to a Convo for a given ConvoHandle
-    fn get_convo_mut(&mut self, handle: ConvoHandle) -> Result<&mut dyn Convo, ChatError> {
+    fn get_convo_mut(&mut self, handle: ConvoHandle) -> Result<&mut dyn Chat, ChatError> {
         let convo_id = self
             .convo_handle_map
             .get(&handle)
             .ok_or_else(|| ChatError::NoConvo(handle))?
             .clone();
 
         self.store
-            .get_mut(&convo_id)
+            .get_mut_chat(&convo_id)
             .ok_or_else(|| ChatError::NoConvo(handle))
     }
 }
-
-#[cfg(test)]
-
-mod tests {
-    use super::*;
-    use crate::conversation::GroupTestConvo;
-
-    #[test]
-    fn convo_store_get() {
-        let mut store: ConversationStore = ConversationStore::new();
-
-        let new_convo = GroupTestConvo::new();
-        let convo_id = store.insert_convo(new_convo);
-
-        let convo = store.get_mut(&convo_id).ok_or_else(|| 0);
-        convo.unwrap();
-    }
-}

conversations/src/dm/mod.rs

@@ -0,0 +1 @@
+pub mod privatev1;

conversations/src/conversation/privatev1.rs → conversations/src/dm/privatev1.rs

@@ -9,8 +9,8 @@ use std::fmt::Debug;
 use x25519_dalek::PublicKey;
 
 use crate::{
-    conversation::{ChatError, ConversationId, Convo, Id},
-    errors::EncryptionError,
+    common::{Chat, ChatId, HasChatId},
+    errors::{ChatError, EncryptionError},
     proto,
     types::AddressedEncryptedPayload,
     utils::timestamp_millis,
@@ -91,14 +91,14 @@ impl PrivateV1Convo {
     }
 }
 
-impl Id for PrivateV1Convo {
-    fn id(&self) -> ConversationId {
+impl HasChatId for PrivateV1Convo {
+    fn id(&self) -> ChatId<'_> {
         // TODO: implementation
         "private_v1_convo_id"
     }
 }
 
-impl Convo for PrivateV1Convo {
+impl Chat for PrivateV1Convo {
     fn send_message(
         &mut self,
         content: &[u8],

conversations/src/ffi/mod.rs

@@ -0,0 +1 @@
+pub mod api;

conversations/src/group/mod.rs

@@ -0,0 +1 @@
+// Group chat module

conversations/src/identity.rs

@@ -1,7 +1,6 @@
 use blake2::{Blake2b512, Digest};
 use std::fmt;
-
-use crate::crypto::{PublicKey, StaticSecret};
+pub use x25519_dalek::{PublicKey, StaticSecret};
 
 pub struct Identity {
     secret: StaticSecret,

conversations/src/inbox/handshake.rs

@@ -5,7 +5,7 @@ use blake2::{
 use crypto::{DomainSeparator, PrekeyBundle, SecretKey, X3Handshake};
 use rand_core::{CryptoRng, RngCore};
 
-use crate::crypto::{PublicKey, StaticSecret};
+use crate::identity::{PublicKey, StaticSecret};
 
 type Blake2bMac256 = Blake2bMac<U32>;