tauri-plugin-matrix-svelte 0.2.0

A Tauri plugin that exposes high level Matrix data through Svelte Rune stores
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use matrix_ui_serializable::models::events::{FrontendDevice, MediaStreamEvent};
use matrix_ui_serializable::{
    MatrixClientConfig, MatrixRequest, MediaRequestParameters, OwnedDeviceId, OwnedRoomId,
    OwnedUserId,
};
use tauri::ipc::Channel;
use tauri::{AppHandle, Runtime, command};

use crate::Result;
use crate::models::mobile::WatchNotificationResult;
use crate::{Error, MatrixSvelteExt};

#[command]
pub(crate) async fn login_and_create_new_session<R: Runtime>(
    app: AppHandle<R>,
    config: MatrixClientConfig,
) -> Result<()> {
    // TODO: create error variants to display rich error messages to frontend
    app.matrix_svelte()
        .login_and_create_new_session(config)
        .await
}

#[command]
pub(crate) fn submit_async_request<R: Runtime>(
    app: AppHandle<R>,
    request: MatrixRequest,
) -> Result<()> {
    // TODO: create add some sender / receiver mechanism to display rich error
    // messages to frontend in case of error
    app.matrix_svelte().submit_async_request(request)
}

#[tauri::command]
pub(crate) async fn fetch_media<R: Runtime>(
    app: AppHandle<R>,
    media_request: MediaRequestParameters,
    on_event: Channel<MediaStreamEvent>,
) -> Result<()> {
    on_event.send(MediaStreamEvent::Started).unwrap();

    match app
        .matrix_svelte()
        .fetch_media(media_request, &on_event)
        .await
    {
        Ok(total_bytes) => {
            on_event
                .send(MediaStreamEvent::Finished { total_bytes })
                .unwrap();
            Ok(())
        }
        Err(e) => {
            on_event
                .send(MediaStreamEvent::Error {
                    message: e.to_string(),
                })
                .unwrap();
            Err(Error::Anyhow(e))
        }
    }
}

#[command]
pub(crate) async fn fetch_user_profile<R: Runtime>(
    app: AppHandle<R>,
    user_id: OwnedUserId,
    room_id: Option<OwnedRoomId>,
) -> Result<bool> {
    app.matrix_svelte()
        .fetch_user_profile(user_id, room_id)
        .await
}

#[command]
pub(crate) async fn get_devices<R: Runtime>(
    app_handle: AppHandle<R>,
    user_id: OwnedUserId,
) -> Result<Vec<FrontendDevice>> {
    app_handle.matrix_svelte().get_devices(user_id).await
}

#[command]
pub(crate) async fn verify_device<R: Runtime>(
    app_handle: AppHandle<R>,
    user_id: OwnedUserId,
    device_id: OwnedDeviceId,
) -> Result<()> {
    app_handle
        .matrix_svelte()
        .verify_device(user_id, device_id)
        .await
}

// Mobile only

#[command]
pub(crate) async fn watch_notifications<R: Runtime>(
    app_handle: AppHandle<R>,
    channel: Channel,
) -> Result<WatchNotificationResult> {
    app_handle.matrix_svelte().watch_notifications(channel)
}