tauri_plugin_android_fs/models/
dir.rs1use serde::{Deserialize, Serialize};
2use std::str::FromStr;
3use crate::*;
4
5
6#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
8#[non_exhaustive]
9pub enum PrivateDir {
10
11 Data,
24
25 Cache,
41
42 NoBackupData,
56}
57
58#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
60#[non_exhaustive]
61pub enum AppDir {
62
63 Data,
75
76 Cache,
88
89 #[deprecated(note = "For Android 11 (API level 30) or higher, this is deprecated. Use `PublicDir` of `PublicStorage` instead.")]
103 PublicMedia
104}
105
106#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
107#[non_exhaustive]
108pub enum PublicDir {
109
110 #[serde(untagged)]
111 Image(PublicImageDir),
112
113 #[serde(untagged)]
114 Video(PublicVideoDir),
115
116 #[serde(untagged)]
117 Audio(PublicAudioDir),
118
119 #[serde(untagged)]
120 GeneralPurpose(PublicGeneralPurposeDir),
121}
122
123#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
125#[non_exhaustive]
126pub enum PublicImageDir {
127
128 Pictures,
129
130 DCIM,
131}
132
133#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
135#[non_exhaustive]
136pub enum PublicVideoDir {
137
138 Movies,
139
140 DCIM,
141}
142
143#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
145#[non_exhaustive]
146pub enum PublicAudioDir {
147
148 Music,
149
150 Alarms,
151
152 Audiobooks,
154
155 Notifications,
156
157 Podcasts,
158
159 Ringtones,
160
161 Recordings,
163}
164
165#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Deserialize, Serialize)]
167#[non_exhaustive]
168pub enum PublicGeneralPurposeDir {
169
170 Documents,
171
172 Download,
175}
176
177impl std::fmt::Display for PublicImageDir {
178 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
179 match self {
180 PublicImageDir::Pictures => write!(f, "Pictures"),
181 PublicImageDir::DCIM => write!(f, "DCIM"),
182 }
183 }
184}
185
186impl std::fmt::Display for PublicVideoDir {
187 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
188 match self {
189 PublicVideoDir::Movies => write!(f, "Movies"),
190 PublicVideoDir::DCIM => write!(f, "DCIM"),
191 }
192 }
193}
194
195impl std::fmt::Display for PublicAudioDir {
196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197 match self {
198 PublicAudioDir::Music => write!(f, "Music"),
199 PublicAudioDir::Alarms => write!(f, "Alarms"),
200 PublicAudioDir::Audiobooks => write!(f, "Audiobooks"),
201 PublicAudioDir::Notifications => write!(f, "Notifications"),
202 PublicAudioDir::Podcasts => write!(f, "Podcasts"),
203 PublicAudioDir::Ringtones => write!(f, "Ringtones"),
204 PublicAudioDir::Recordings => write!(f, "Recordings"),
205 }
206 }
207}
208
209impl std::fmt::Display for PublicGeneralPurposeDir {
210 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
211 match self {
212 PublicGeneralPurposeDir::Documents => write!(f, "Documents"),
213 PublicGeneralPurposeDir::Download => write!(f, "Download"),
214 }
215 }
216}
217
218impl std::fmt::Display for PublicDir {
219 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
220 match self {
221 PublicDir::Image(p) => p.fmt(f),
222 PublicDir::Video(p) => p.fmt(f),
223 PublicDir::Audio(p) => p.fmt(f),
224 PublicDir::GeneralPurpose(p) => p.fmt(f),
225 }
226 }
227}
228
229macro_rules! impl_into_pubdir {
230 ($target: ident, $wrapper: ident) => {
231 impl From<$target> for PublicDir {
232 fn from(value: $target) -> Self {
233 Self::$wrapper(value)
234 }
235 }
236 };
237}
238impl_into_pubdir!(PublicImageDir, Image);
239impl_into_pubdir!(PublicVideoDir, Video);
240impl_into_pubdir!(PublicAudioDir, Audio);
241impl_into_pubdir!(PublicGeneralPurposeDir, GeneralPurpose);
242
243impl FromStr for PublicImageDir {
244 type Err = Error;
245
246 fn from_str(s: &str) -> Result<Self> {
247 if s.eq_ignore_ascii_case("pictures") {
248 Ok(PublicImageDir::Pictures)
249 }
250 else if s.eq_ignore_ascii_case("dcim") {
251 Ok(PublicImageDir::DCIM)
252 }
253 else {
254 Err(Error::with(format!("invalid PublicImageDir: {s}")))
255 }
256 }
257}
258
259impl FromStr for PublicVideoDir {
260 type Err = Error;
261
262 fn from_str(s: &str) -> Result<Self> {
263 if s.eq_ignore_ascii_case("movies") {
264 Ok(PublicVideoDir::Movies)
265 }
266 else if s.eq_ignore_ascii_case("dcim") {
267 Ok(PublicVideoDir::DCIM)
268 }
269 else {
270 Err(Error::with(format!("invalid PublicVideoDir: {s}")))
271 }
272 }
273}
274
275impl FromStr for PublicAudioDir {
276 type Err = Error;
277
278 fn from_str(s: &str) -> Result<Self> {
279 if s.eq_ignore_ascii_case("music") {
280 Ok(PublicAudioDir::Music)
281 }
282 else if s.eq_ignore_ascii_case("alarms") {
283 Ok(PublicAudioDir::Alarms)
284 }
285 else if s.eq_ignore_ascii_case("audiobooks") {
286 Ok(PublicAudioDir::Audiobooks)
287 }
288 else if s.eq_ignore_ascii_case("notifications") {
289 Ok(PublicAudioDir::Notifications)
290 }
291 else if s.eq_ignore_ascii_case("podcasts") {
292 Ok(PublicAudioDir::Podcasts)
293 }
294 else if s.eq_ignore_ascii_case("ringtones") {
295 Ok(PublicAudioDir::Ringtones)
296 }
297 else if s.eq_ignore_ascii_case("recordings") {
298 Ok(PublicAudioDir::Recordings)
299 }
300 else {
301 Err(Error::with(format!("invalid PublicAudioDir: {s}")))
302 }
303 }
304}
305
306impl FromStr for PublicGeneralPurposeDir {
307 type Err = Error;
308
309 fn from_str(s: &str) -> Result<Self> {
310 if s.eq_ignore_ascii_case("documents") {
311 Ok(PublicGeneralPurposeDir::Documents)
312 }
313 else if s.eq_ignore_ascii_case("download") {
314 Ok(PublicGeneralPurposeDir::Download)
315 }
316 else if s.eq_ignore_ascii_case("downloads") {
317 Ok(PublicGeneralPurposeDir::Download)
318 }
319 else {
320 Err(Error::with(format!("invalid PublicGeneralPurposeDir: {s}")))
321 }
322 }
323}
324
325impl FromStr for PublicDir {
326 type Err = Error;
327
328 fn from_str(s: &str) -> Result<Self> {
329 if let Ok(v) = PublicImageDir::from_str(s) {
330 Ok(PublicDir::Image(v))
331 }
332 else if let Ok(v) = PublicVideoDir::from_str(s) {
333 Ok(PublicDir::Video(v))
334 }
335 else if let Ok(v) = PublicAudioDir::from_str(s) {
336 Ok(PublicDir::Audio(v))
337 }
338 else if let Ok(v) = PublicGeneralPurposeDir::from_str(s) {
339 Ok(PublicDir::GeneralPurpose(v))
340 }
341 else {
342 Err(Error::with(format!("invalid PublicDir: {s}")))
343 }
344 }
345}