Move notification changes from old branch

Author: ismailgulek

Cargo.lock

@@ -39,3 +39,4 @@ tracing = { workspace = true }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uniffi = { workspace = true }
 uniffi_macros = { workspace = true }
+rand = "0.8.5"

bindings/matrix-sdk-ffi/Cargo.toml

@@ -151,6 +151,17 @@ interface SlidingSyncBuilder {
     SlidingSync build();
 };
 
+[Enum]
+interface PusherKind {
+  Http();
+  Email();
+};
+
+[Enum]
+interface PushFormat {
+  EventIdOnly();
+};
+
 interface Client {
     void set_delegate(ClientDelegate? delegate);
 
@@ -195,6 +206,18 @@ interface Client {
 
     [Throws=ClientError]
     void logout();
+
+    [Throws=ClientError]
+    void set_pusher(string pushkey,
+                    PusherKind? kind,
+                    string app_id,
+                    string app_display_name,
+                    string device_display_name,
+                    string? profile_tag,
+                    string lang,
+                    string? url,
+                    PushFormat? format,
+                    string? default_payload);
 };
 
 interface Room {
@@ -361,6 +384,21 @@ interface AuthenticationService {
     Client restore_with_access_token(string token, string device_id);
 };
 
+dictionary NotificationItem {
+    TimelineItem item;
+    string title;
+    string? subtitle;
+    boolean is_noisy;
+    string? avatar_url;
+};
+
+interface NotificationService {
+    constructor(string base_path, string user_id);
+
+    [Throws=ClientError]
+    NotificationItem? get_notification_item(string room_id, string event_id);
+};
+
 interface SessionVerificationEmoji {};
 
 callback interface SessionVerificationControllerDelegate {

bindings/matrix-sdk-ffi/src/api.udl

@@ -5,26 +5,62 @@ use matrix_sdk::{
     config::SyncSettings,
     media::{MediaFormat, MediaRequest, MediaThumbnailSize},
     ruma::{
-        api::client::{
-            account::whoami,
-            error::ErrorKind,
-            filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
-            media::get_content_thumbnail::v3::Method,
-            session::get_login_types,
-            sync::sync_events::v3::Filter,
+        api::{
+            self,
+            client::{
+                account::whoami,
+                error::ErrorKind,
+                filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
+                media::get_content_thumbnail::v3::Method,
+                push::set_pusher::v3::PusherInit,
+                session::get_login_types,
+                sync::sync_events::v3::Filter,
+            },
         },
         events::{room::MediaSource, AnyToDeviceEvent},
+        push::PusherData,
         serde::Raw,
         TransactionId, UInt,
     },
     Client as MatrixClient, Error, LoopCtrl, RumaApiError, Session,
 };
+use serde_json::Value;
 
 use super::{
     room::Room, session_verification::SessionVerificationController, ClientState, RestoreToken,
     RUNTIME,
 };
 
+#[derive(Clone)]
+pub enum PusherKind {
+    Http,
+    Email,
+}
+
+impl PusherKind {
+    pub fn convert(&self) -> api::client::push::PusherKind {
+        use api::client::push::PusherKind as PK;
+        match self {
+            Http => PK::Http,
+            Email => PK::Email,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum PushFormat {
+    EventIdOnly,
+}
+
+impl PushFormat {
+    pub fn convert(&self) -> matrix_sdk::ruma::push::PushFormat {
+        use matrix_sdk::ruma::push::PushFormat as PF;
+        match self {
+            EventIdOnly => PF::EventIdOnly,
+        }
+    }
+}
+
 impl std::ops::Deref for Client {
     type Target = MatrixClient;
     fn deref(&self) -> &MatrixClient {
@@ -295,6 +331,52 @@ impl Client {
         tracing::warn!("Ignoring sync error: {:?}", sync_error);
         LoopCtrl::Continue
     }
+
+    /// Registers a pusher with given parameters
+    pub fn set_pusher(
+        &self,
+        pushkey: String,
+        kind: Option<PusherKind>,
+        app_id: String,
+        app_display_name: String,
+        device_display_name: String,
+        profile_tag: Option<String>,
+        lang: String,
+        url: Option<String>,
+        format: Option<PushFormat>,
+        default_payload: Option<String>,
+    ) -> anyhow::Result<()> {
+        RUNTIME.block_on(async move {
+            let mut pusher_data = PusherData::new();
+            pusher_data.url = url;
+            pusher_data.format = match format {
+                Some(fmt) => Some(fmt.convert()),
+                _ => None,
+            };
+            pusher_data.default_payload = match default_payload {
+                Some(json) => serde_json::from_str(&json)?,
+                _ => Value::Null,
+            };
+
+            let pusher_init = PusherInit {
+                pushkey: pushkey,
+                kind: match kind {
+                    Some(knd) => Some(knd.convert()),
+                    None => None,
+                },
+                app_id: app_id,
+                app_display_name: app_display_name,
+                device_display_name: device_display_name,
+                profile_tag: profile_tag,
+                lang: lang,
+                data: pusher_data,
+            };
+            match self.client.set_pusher(pusher_init.into()).await {
+                Ok(_) => Ok(()),
+                Err(error) => Err(anyhow!(error.to_string())),
+            }
+        })
+    }
 }
 
 #[uniffi::export]

bindings/matrix-sdk-ffi/src/client.rs

@@ -24,6 +24,7 @@ pub mod authentication_service;
 pub mod client;
 pub mod client_builder;
 mod helpers;
+pub mod notification_service;
 pub mod room;
 pub mod session_verification;
 pub mod sliding_sync;
@@ -50,8 +51,8 @@ pub use matrix_sdk::{
 };
 
 pub use self::{
-    authentication_service::*, client::*, room::*, session_verification::*, sliding_sync::*,
-    timeline::*,
+    authentication_service::*, client::*, notification_service::*, room::*,
+    session_verification::*, sliding_sync::*, timeline::*,
 };
 
 #[derive(Default, Debug)]

bindings/matrix-sdk-ffi/src/lib.rs

@@ -0,0 +1,89 @@
+use std::sync::Arc;
+
+use matrix_sdk::{
+    room::timeline::{
+        BundledReactions, EventTimelineItem, Message, TimelineItemContent, TimelineKey,
+    },
+    ruma::{
+        api::client::message,
+        events::room::{
+            message::{ImageMessageEventContent, MessageType, TextMessageEventContent},
+            ImageInfo,
+        },
+        EventId, MilliSecondsSinceUnixEpoch, MxcUri, ServerName, UInt, UserId,
+    },
+};
+use rand::{random, Rng};
+
+use crate::{ClientError, TimelineItem};
+
+pub struct NotificationService {
+    base_path: String,
+    user_id: String,
+}
+
+pub struct NotificationItem {
+    pub item: Arc<TimelineItem>,
+    pub title: String,
+    pub subtitle: Option<String>,
+    pub is_noisy: bool,
+    pub avatar_url: Option<String>,
+}
+
+impl NotificationService {
+    /// Creates a new notification service.
+    pub fn new(base_path: String, user_id: String) -> Self {
+        NotificationService { base_path, user_id }
+    }
+
+    pub fn get_notification_item(
+        &self,
+        _room_id: String,
+        event_id: String,
+    ) -> anyhow::Result<Option<NotificationItem>> {
+        let text_message_type = MessageType::Text(TextMessageEventContent::plain("Notified text"));
+        let mut image_info = ImageInfo::new();
+        image_info.height = UInt::new(640);
+        image_info.width = UInt::new(638);
+        image_info.mimetype = Some("image/jpeg".to_owned());
+        image_info.size = UInt::new(118141);
+        image_info.blurhash = Some("TFF~Ba5at616yD^%~T-oXU9bt6kr".to_owned());
+        let image_message_type = MessageType::Image(ImageMessageEventContent::plain(
+            "body".to_owned(),
+            (*Box::<MxcUri>::from("mxc://matrix.org/vNOdmUTIPIwWvMneNzyCzNhb")).to_owned(),
+            Some(Box::new(image_info)),
+        ));
+
+        let random = rand::thread_rng().gen_range(0..2);
+
+        let sdk_event = EventTimelineItem {
+            key: TimelineKey::EventId(EventId::parse(event_id.to_owned()).unwrap()),
+            event_id: Some(EventId::parse(event_id.to_owned()).unwrap()),
+            sender: UserId::parse("@username:example.com").unwrap(),
+            content: TimelineItemContent::Message(Message {
+                msgtype: match random {
+                    1 => image_message_type,
+                    _ => text_message_type,
+                },
+                in_reply_to: None,
+                edited: false,
+            }),
+            reactions: BundledReactions::default(),
+            origin_server_ts: Some(MilliSecondsSinceUnixEpoch::now()),
+            is_own: false,
+            encryption_info: None,
+            raw: None,
+        };
+
+        let item = NotificationItem {
+            item: Arc::new(TimelineItem(matrix_sdk::room::timeline::TimelineItem::Event(
+                sdk_event,
+            ))),
+            title: "ismailgulek".to_owned(),
+            subtitle: Some("Element iOS - Internal".to_owned()),
+            is_noisy: true,
+            avatar_url: Some("mxc://matrix.org/XzNaquIfpvjHtftUJBCRNDgX".to_owned()),
+        };
+        Ok(Some(item))
+    }
+}

bindings/matrix-sdk-ffi/src/notification_service.rs

@@ -128,7 +128,7 @@ pub enum TimelineChange {
 
 #[repr(transparent)]
 #[derive(Clone)]
-pub struct TimelineItem(matrix_sdk::room::timeline::TimelineItem);
+pub struct TimelineItem(pub matrix_sdk::room::timeline::TimelineItem);
 
 impl TimelineItem {
     fn from_arc(arc: Arc<matrix_sdk::room::timeline::TimelineItem>) -> Arc<Self> {

bindings/matrix-sdk-ffi/src/timeline.rs

@@ -81,7 +81,7 @@ matrix-sdk-sled = { version = "0.2.0", path = "../matrix-sdk-sled", default-feat
 mime = "0.3.16"
 rand = { version = "0.8.5", optional = true }
 reqwest = { version = "0.11.10", default_features = false }
-ruma = { workspace = true, features = ["compat", "rand", "unstable-msc2448", "unstable-msc2965"] }
+ruma = { workspace = true, features = ["compat", "rand", "unstable-msc2448", "unstable-msc2965", "unstable-pre-spec"] }
 serde = "1.0.136"
 serde_json = "1.0.79"
 thiserror = "1.0.30"

crates/matrix-sdk/Cargo.toml

@@ -50,7 +50,10 @@ use ruma::{
             error::ErrorKind,
             filter::{create_filter::v3::Request as FilterUploadRequest, FilterDefinition},
             membership::{join_room_by_id, join_room_by_id_or_alias},
-            push::get_notifications::v3::Notification,
+            push::{
+                get_notifications::v3::Notification,
+                set_pusher::{self, v3::Pusher},
+            },
             room::create_room,
             session::{
                 get_login_types, login, logout, refresh_token, sso_login, sso_login_with_provider,
@@ -2365,6 +2368,12 @@ impl Client {
         let request = logout::v3::Request::new();
         self.send(request, None).await
     }
+
+    /// Sets a given pusher
+    pub async fn set_pusher(&self, pusher: Pusher) -> HttpResult<set_pusher::v3::Response> {
+        let request = set_pusher::v3::Request::new(pusher);
+        self.send(request, None).await
+    }
 }
 
 // The http mocking library is not supported for wasm32