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