tauri-plugin-bare-kit 0.1.1

Effortless JavaScript backends for Tauri apps - Android 🤖 iOS 📱Linux 🐧 Macos 🖥️ Windows 💩
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#[cfg(target_os = "android")]
use base64::prelude::{Engine, BASE64_STANDARD};

#[cfg(not(target_os = "android"))]
use tauri::ipc::{InvokeBody, Request, Response};

use tauri::{command, AppHandle, Runtime, WebviewWindow};

use crate::runtime::models::*;
use crate::runtime::BareKitExt;
use crate::runtime::Result;

#[command]
pub(crate) fn bare_invalidate<R: Runtime>(app: AppHandle<R>) -> Result<()> {
    app.bare_kit().lock().unwrap().invalidate()
}

#[command]
pub(crate) fn bare_init<R: Runtime>(
    app: AppHandle<R>,
    window: WebviewWindow<R>,
    payload: InitRequest,
) -> Result<u8> {
    app.bare_kit().lock().unwrap().init(
        payload.memory_limit,
        payload.assets,
        window,
        payload.on_poll,
    )
}

#[command]
pub(crate) fn bare_start_file<R: Runtime>(
    app: AppHandle<R>,
    payload: StartFileRequest,
) -> Result<()> {
    app.bare_kit()
        .lock()
        .unwrap()
        .start_file(payload.id, payload.filename, payload.args)
}

#[command]
pub(crate) fn bare_start_utf8<R: Runtime>(
    app: AppHandle<R>,
    payload: StartUTF8Request,
) -> Result<()> {
    app.bare_kit().lock().unwrap().start_utf8(
        payload.id,
        payload.filename,
        payload.source,
        payload.args,
    )
}

#[command]
pub(crate) fn bare_start_bytes<R: Runtime>(
    app: AppHandle<R>,
    payload: StartBytesRequest,
) -> Result<()> {
    app.bare_kit().lock().unwrap().start_bytes(
        payload.id,
        payload.filename,
        payload.source,
        payload.args,
    )
}

#[cfg(not(target_os = "android"))]
#[command]
pub(crate) fn bare_read<R: Runtime>(app: AppHandle<R>, payload: ReadRequest) -> Result<Response> {
    Ok(Response::new(
        app.bare_kit().lock().unwrap().read(payload.id)?,
    ))
}

#[cfg(target_os = "android")]
#[command]
pub(crate) fn bare_read<R: Runtime>(app: AppHandle<R>, payload: ReadRequest) -> Result<String> {
    Ok(BASE64_STANDARD.encode(app.bare_kit().lock().unwrap().read(payload.id)?))
}

#[cfg(not(target_os = "android"))]
#[command]
pub(crate) fn bare_write<R: Runtime>(app: AppHandle<R>, payload: Request<'_>) -> Result<i32> {
    let InvokeBody::Raw(payload) = payload.body() else {
        return Err("Invalid payload for write request".into());
    };
    let id = payload[0];
    let data = payload[1..].to_vec();
    app.bare_kit().lock().unwrap().write(id, data)
}

#[cfg(target_os = "android")]
#[command]
pub(crate) fn bare_write<R: Runtime>(app: AppHandle<R>, payload: String) -> Result<i32> {
    let payload = BASE64_STANDARD.decode(payload)?;
    let id = payload[0];
    let data = payload[1..].to_vec();
    app.bare_kit().lock().unwrap().write(id, data)
}

#[command]
pub(crate) fn bare_update<R: Runtime>(app: AppHandle<R>, payload: UpdateRequest) -> Result<()> {
    app.bare_kit()
        .lock()
        .unwrap()
        .update(payload.id, payload.readable, payload.writable)
}

#[command]
pub(crate) fn bare_suspend<R: Runtime>(app: AppHandle<R>, payload: SuspendRequest) -> Result<()> {
    app.bare_kit()
        .lock()
        .unwrap()
        .suspend(payload.id, payload.linger)
}

#[command]
pub(crate) fn bare_resume<R: Runtime>(app: AppHandle<R>, payload: ResumeRequest) -> Result<()> {
    app.bare_kit().lock().unwrap().resume(payload.id)
}

#[command]
pub(crate) fn bare_wakeup<R: Runtime>(app: AppHandle<R>, payload: WakeupRequest) -> Result<()> {
    app.bare_kit()
        .lock()
        .unwrap()
        .wakeup(payload.id, payload.deadline)
}

#[command]
pub(crate) fn bare_terminate<R: Runtime>(
    app: AppHandle<R>,
    payload: TerminateRequest,
) -> Result<()> {
    app.bare_kit().lock().unwrap().terminate(payload.id)
}