lingxia-platform 0.6.3

Platform abstraction layer for LingXia framework (Android, iOS, HarmonyOS)
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
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

use super::app::Platform;
use crate::error::PlatformError;
use crate::traits::file::{
    ChooseDirectoryRequest, ChooseFileRequest, FileDialogResult, FileService, OpenFileRequest,
};
use serde::Deserialize;
use std::path::Path;

impl FileService for Platform {
    async fn review_file(&self, request: OpenFileRequest) -> Result<(), PlatformError> {
        if !supports_native_review(&request) {
            return Err(PlatformError::NotSupported(
                "review_file is only supported for PDF and images on HarmonyOS".to_string(),
            ));
        }
        crate::rt::blocking(move || review_file_sync(request)).await
    }

    async fn open_external(&self, request: OpenFileRequest) -> Result<(), PlatformError> {
        crate::rt::blocking(move || open_external_sync(request)).await
    }

    async fn choose_file(
        &self,
        request: ChooseFileRequest,
    ) -> Result<FileDialogResult, PlatformError> {
        let payload = crate::rt::native_call(|callback_id| {
            let callback_id = callback_id.to_string();
            let multiple = if request.multiple { "1" } else { "0" };
            let title = request.title.clone().unwrap_or_default();
            let default_path = request.default_path.clone().unwrap_or_default();
            let filters_json = serde_json::to_string(
                &request
                    .filters
                    .iter()
                    .flat_map(|filter| filter.extensions.iter().cloned())
                    .collect::<Vec<String>>(),
            )
            .map_err(|e| PlatformError::Platform(format!("serialize filters failed: {e}")))?;
            lingxia_webview::platform::harmony::tsfn::call_arkts(
                "chooseFile",
                &[&callback_id, multiple, &title, &default_path, &filters_json],
            )
            .map_err(|e| PlatformError::Platform(format!("Failed to choose file: {}", e)))
        })
        .await?;
        parse_file_dialog_result(&payload)
    }

    async fn choose_directory(
        &self,
        request: ChooseDirectoryRequest,
    ) -> Result<FileDialogResult, PlatformError> {
        let payload = crate::rt::native_call(|callback_id| {
            let callback_id = callback_id.to_string();
            let title = request.title.clone().unwrap_or_default();
            let default_path = request.default_path.clone().unwrap_or_default();
            lingxia_webview::platform::harmony::tsfn::call_arkts(
                "chooseDirectory",
                &[&callback_id, &title, &default_path],
            )
            .map_err(|e| PlatformError::Platform(format!("Failed to choose directory: {}", e)))
        })
        .await?;
        parse_file_dialog_result(&payload)
    }
}

#[derive(Deserialize)]
struct HarmonyFileDialogResult {
    canceled: bool,
    paths: Vec<String>,
}

fn supports_native_review(request: &OpenFileRequest) -> bool {
    if request.is_pdf_like() {
        return true;
    }

    if let Some(mime) = request.mime_type.as_deref()
        && mime.to_ascii_lowercase().starts_with("image/")
    {
        return true;
    }

    Path::new(&request.path)
        .extension()
        .and_then(|ext| ext.to_str())
        .map(|ext| {
            matches!(
                ext.to_ascii_lowercase().as_str(),
                "jpg" | "jpeg" | "png" | "webp" | "gif" | "bmp" | "heic" | "heif"
            )
        })
        .unwrap_or(false)
}

fn review_file_sync(request: OpenFileRequest) -> Result<(), PlatformError> {
    let mime = request.mime_type.unwrap_or_default();
    let show_menu_flag = request.show_menu.unwrap_or(true);
    let show_menu = if show_menu_flag { "1" } else { "0" };
    lingxia_webview::platform::harmony::tsfn::call_arkts(
        "reviewDocument",
        &[request.path.as_str(), mime.as_str(), show_menu],
    )
    .map(|_| ())
    .map_err(|e| PlatformError::Platform(format!("Failed to review file on HarmonyOS: {}", e)))
}

fn open_external_sync(request: OpenFileRequest) -> Result<(), PlatformError> {
    let mime = request.mime_type.unwrap_or_default();
    let show_menu_flag = request.show_menu.unwrap_or(true);
    let show_menu = if show_menu_flag { "1" } else { "0" };
    lingxia_webview::platform::harmony::tsfn::call_arkts(
        "openDocumentExternal",
        &[request.path.as_str(), mime.as_str(), show_menu],
    )
    .map(|_| ())
    .map_err(|e| PlatformError::Platform(format!("Failed to open file externally: {}", e)))
}

fn parse_file_dialog_result(payload: &str) -> Result<FileDialogResult, PlatformError> {
    let parsed: HarmonyFileDialogResult = serde_json::from_str(payload)
        .map_err(|e| PlatformError::Platform(format!("parse file dialog result failed: {e}")))?;
    Ok(FileDialogResult {
        canceled: parsed.canceled,
        paths: parsed.paths,
    })
}