photokit 0.4.0

Safe Rust bindings for Apple's Photos framework — photo library access on macOS
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::ptr;

use base64::Engine;
use serde::Serialize;

use crate::asset::PHAssetResourceType;
use crate::error::PhotoKitError;
use crate::ffi;
use crate::object::PHObjectPlaceholder;
use crate::private::{json_cstring, take_string};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Default)]
#[serde(rename_all = "camelCase")]
/// Wraps `PHAssetResourceCreationOptions`.
pub struct PHAssetResourceCreationOptions {
    /// Corresponds to `PHAssetResourceCreationOptions.originalFilename`.
    pub original_filename: Option<String>,
    /// Corresponds to `PHAssetResourceCreationOptions.contentTypeIdentifier`.
    pub content_type_identifier: Option<String>,
    /// Corresponds to `PHAssetResourceCreationOptions.uniformTypeIdentifier`.
    pub uniform_type_identifier: Option<String>,
    #[serde(default)]
    /// Corresponds to `PHAssetResourceCreationOptions.shouldMoveFile`.
    pub should_move_file: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
/// Helper input for `PHAssetCreationRequest` resource additions.
pub struct PHAssetCreationResource {
    /// Corresponds to `PHAssetCreationResource.resourceType`.
    pub resource_type: PHAssetResourceType,
    /// Corresponds to `PHAssetCreationResource.fileUrl`.
    pub file_url: Option<String>,
    /// Corresponds to `PHAssetCreationResource.dataBase64`.
    pub data_base64: Option<String>,
    /// Corresponds to `PHAssetCreationResource.options`.
    pub options: Option<PHAssetResourceCreationOptions>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Default)]
/// Wraps `PHAssetCreationRequest`.
pub struct PHAssetCreationRequest {
    /// Serialized field carried by `PHAssetCreationRequest`.
    pub resources: Vec<PHAssetCreationResource>,
}

impl PHAssetCreationRequest {
    /// Creates a helper value for the related Photos framework API.
    pub fn new() -> Self {
        Self::default()
    }

    /// Wraps a Photos framework operation on `PHAssetCreationRequest`.
    pub fn add_file_resource(
        mut self,
        resource_type: impl Into<PHAssetResourceType>,
        file_url: impl Into<String>,
        options: Option<PHAssetResourceCreationOptions>,
    ) -> Self {
        self.resources.push(PHAssetCreationResource {
            resource_type: resource_type.into(),
            file_url: Some(file_url.into()),
            data_base64: None,
            options,
        });
        self
    }

    /// Wraps a Photos framework operation on `PHAssetCreationRequest`.
    pub fn add_data_resource(
        mut self,
        resource_type: impl Into<PHAssetResourceType>,
        data_base64: impl Into<String>,
        options: Option<PHAssetResourceCreationOptions>,
    ) -> Self {
        self.resources.push(PHAssetCreationResource {
            resource_type: resource_type.into(),
            file_url: None,
            data_base64: Some(data_base64.into()),
            options,
        });
        self
    }

    /// Wraps a Photos framework operation on `PHAssetCreationRequest`.
    pub fn add_data_resource_bytes(
        self,
        resource_type: impl Into<PHAssetResourceType>,
        data: &[u8],
        options: Option<PHAssetResourceCreationOptions>,
    ) -> Self {
        self.add_data_resource(
            resource_type,
            base64::engine::general_purpose::STANDARD.encode(data),
            options,
        )
    }

    /// Queries Photos framework state exposed by `PHAssetCreationRequest`.
    pub fn is_empty(&self) -> bool {
        self.resources.is_empty()
    }

    /// Wraps a Photos framework operation on `PHAssetCreationRequest`.
    pub fn supports_asset_resource_types(
        resource_types: &[PHAssetResourceType],
    ) -> Result<bool, PhotoKitError> {
        let resource_types_json = json_cstring(resource_types, "resource types")?;
        let mut error = ptr::null_mut();
        let supported = unsafe {
            ffi::ph_asset_creation_request_supports_resource_types(
                resource_types_json.as_ptr(),
                &mut error,
            )
        };
        if error.is_null() {
            Ok(supported != 0)
        } else {
            Err(unsafe {
                PhotoKitError::from_error_ptr(
                    error,
                    "asset creation resource type support lookup failed",
                )
            })
        }
    }

    /// Executes the Photos framework operation represented by `PHAssetCreationRequest`.
    pub fn perform(self) -> Result<String, PhotoKitError> {
        let resources_json = json_cstring(&self.resources, "asset creation resources")?;
        let mut error = ptr::null_mut();
        let payload =
            unsafe { ffi::ph_asset_creation_request_perform(resources_json.as_ptr(), &mut error) };
        if payload.is_null() {
            Err(unsafe { PhotoKitError::from_error_ptr(error, "asset creation failed") })
        } else {
            unsafe { take_string(payload) }.ok_or_else(|| {
                PhotoKitError::OperationFailed("missing asset creation payload".to_owned())
            })
        }
    }

    /// Wraps a Photos framework operation on `PHAssetCreationRequest`.
    pub fn perform_placeholder(self) -> Result<PHObjectPlaceholder, PhotoKitError> {
        self.perform().map(PHObjectPlaceholder::new)
    }
}