tauri-plugin-medialibrary 0.14.0

A tauri plugin to access the systems media library (e.g. the android medialibrary)
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

use crate::scope::Entry;
use crate::MedialibraryExt;
use crate::Result;
use crate::{models::*, Error};
use tauri::ipc::{CommandScope, GlobalScope};
use tauri::{command, AppHandle, Runtime};
use log::trace;

#[command]
pub(crate) async fn get_images<R: Runtime>(
    app: AppHandle<R>,
    global_scope: GlobalScope<Entry>,
    command_scope: CommandScope<Entry>,
    request: GetLibraryContentRequest,
) -> Result<GetImagesResult> {
    if !global_scope
        .allows()
        .iter()
        .chain(command_scope.allows())
        .any(|c| c.source.eq(&request.source))
    {
        return Err(Error::MediaLibrarySourceForbidden(request.source));
    }

    let include_file_metadata = request.include_file_metadata.unwrap_or_default();

    match app.medialibrary().get_images(request) {
        Ok(images) => Ok(images.with_file_metadata(include_file_metadata)),
        Err(err) => Err(err),
    }
}

#[command]
pub(crate) async fn request_permissions<R: Runtime>(
    app: AppHandle<R>,
    args: RequestPermissionsArgs,
) -> Result<PermissionResponse> {
    app.medialibrary().request_permissions(args)
}

#[command]
pub(crate) async fn get_thumbnail<R: Runtime>(
    app: AppHandle<R>,
    uri: String,
) -> Result<GetThumbnailResponse> {
    trace!("get_thumbnail");
    return app.medialibrary().get_thumbnail(uri).await;
}

#[command]
pub(crate) async fn get_image<R: Runtime>(
    app: AppHandle<R>,
    uri: String,
) -> Result<Option<ImageInfo>> {
    app.medialibrary().get_image(uri.into())
}

#[command]
pub(crate) async fn get_available_sources<R: Runtime>(
    _app: AppHandle<R>,
    global_scope: GlobalScope<Entry>,
    _command_scope: CommandScope<Entry>,
) -> Result<Vec<MediaLibrarySource>> {
    let allowed_sources = global_scope
        .allows()
        .iter()
        .map(|f| f.source.clone())
        .collect();

    Ok(allowed_sources)
}

#[command]
pub(crate) async fn delete_image<R: Runtime>(app: AppHandle<R>, uri: String) -> Result<()> {
    app.medialibrary().delete_image(uri.into())
}