tauri-plugin-android-fs 28.2.2

Android file system API for Tauri.
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

use serde::{Deserialize, Serialize};


#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
pub struct Size {
    pub width: u32,
    pub height: u32
}

#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
#[non_exhaustive]
pub enum ImageFormat {

    /// - Loss less
    /// - Support transparency
    Png,

    /// - Lossy
    /// - Unsupport transparency
    Jpeg,

    /// - Lossy (**Not loss less**)
    /// - Support transparency
    Webp,

    /// - Lossy
    /// - Unsupport transparency
    JpegWith {

        /// Range is `0.0 ~ 1.0`  
        /// 0.0 means compress for the smallest size.  
        /// 1.0 means compress for max visual quality.  
        quality: f32
    },

    /// - Lossy
    /// - Support transparency
    WebpWith {
        
        /// Range is `0.0 ~ 1.0`  
        /// 0.0 means compress for the smallest size.  
        /// 1.0 means compress for max visual quality.  
        quality: f32
    }
}

#[allow(unused)]
impl ImageFormat {

    pub(crate) fn mime_type(&self) -> &'static str {
        match self {
            ImageFormat::Jpeg | ImageFormat::JpegWith { .. } => "image/jpeg",
            ImageFormat::Webp | ImageFormat::WebpWith { .. } => "image/webp",
            ImageFormat::Png => "image/png",
        }
    }

    pub(crate) fn from_mime_type(mime_type: &str) -> Option<Self> {
        match mime_type {
            "image/jpeg" | "image/jpg" => Some(Self::Jpeg),
            "image/webp" => Some(Self::Webp),
            "image/png" => Some(Self::Png),
            _ => None,
        }
    }

    pub(crate) fn from_name(name: &str) -> Option<Self> {
        if name.eq_ignore_ascii_case("jpeg") || name.eq_ignore_ascii_case("jpg") {
            Some(Self::Jpeg)
        }
        else if name.eq_ignore_ascii_case("webp") {
            Some(Self::Webp)
        }
        else if name.eq_ignore_ascii_case("png") {
            Some(Self::Png)
        }
        else {
            None
        }
    }

    pub(crate) fn to_quality_and_format_str(&self) -> (f32, &'static str) {
        match self {
            ImageFormat::Png => (1.0, "Png"),
            ImageFormat::Jpeg => (0.75, "Jpeg"),
            ImageFormat::Webp => (0.7, "Webp"),
            ImageFormat::JpegWith { quality } => (*quality, "Jpeg"),
            ImageFormat::WebpWith { quality } => (*quality, "Webp"),
        }
    }
}