storekit-rs 0.2.1

Safe Rust bindings for Apple's StoreKit framework — in-app purchases and transaction streams 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

use core::ptr;

use crate::error::StoreKitError;
use crate::ffi;
use crate::private::{error_from_status, take_string};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AppStoreEnvironment {
    Production,
    Sandbox,
    Xcode,
    Unknown(String),
}

impl AppStoreEnvironment {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Production => "production",
            Self::Sandbox => "sandbox",
            Self::Xcode => "xcode",
            Self::Unknown(value) => value.as_str(),
        }
    }

    pub(crate) fn from_raw(raw: String) -> Self {
        match raw.as_str() {
            "production" => Self::Production,
            "sandbox" => Self::Sandbox,
            "xcode" => Self::Xcode,
            _ => Self::Unknown(raw),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AppStorePlatform {
    IOS,
    MacOS,
    TvOS,
    VisionOS,
    Unknown(String),
}

impl AppStorePlatform {
    pub fn as_str(&self) -> &str {
        match self {
            Self::IOS => "iOS",
            Self::MacOS => "macOS",
            Self::TvOS => "tvOS",
            Self::VisionOS => "visionOS",
            Self::Unknown(value) => value.as_str(),
        }
    }

    pub(crate) fn from_raw(raw: String) -> Self {
        match raw.as_str() {
            "iOS" => Self::IOS,
            "macOS" => Self::MacOS,
            "tvOS" => Self::TvOS,
            "visionOS" => Self::VisionOS,
            _ => Self::Unknown(raw),
        }
    }
}

/// Helpers backed by `StoreKit.AppStore`.
#[derive(Debug, Clone, Copy, Default)]
pub struct AppStore;

impl AppStore {
    pub fn can_make_payments() -> Result<bool, StoreKitError> {
        let mut raw_value = 0;
        let mut error_message = ptr::null_mut();
        let status =
            unsafe { ffi::sk_app_store_can_make_payments(&mut raw_value, &mut error_message) };
        if status == ffi::status::OK {
            Ok(raw_value != 0)
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }

    pub fn device_verification_id() -> Result<Option<String>, StoreKitError> {
        let mut uuid_ptr = ptr::null_mut();
        let mut error_message = ptr::null_mut();
        let status =
            unsafe { ffi::sk_app_store_device_verification_id(&mut uuid_ptr, &mut error_message) };
        if status == ffi::status::OK {
            Ok(unsafe { take_string(uuid_ptr) })
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }

    pub fn sync() -> Result<(), StoreKitError> {
        let mut error_message = ptr::null_mut();
        let status = unsafe { ffi::sk_app_store_sync(&mut error_message) };
        if status == ffi::status::OK {
            Ok(())
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }

    pub fn show_manage_subscriptions() -> Result<(), StoreKitError> {
        let mut error_message = ptr::null_mut();
        let status = unsafe { ffi::sk_app_store_show_manage_subscriptions(&mut error_message) };
        if status == ffi::status::OK {
            Ok(())
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }

    pub fn request_review() -> Result<(), StoreKitError> {
        let mut error_message = ptr::null_mut();
        let status = unsafe { ffi::sk_app_store_request_review(&mut error_message) };
        if status == ffi::status::OK {
            Ok(())
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }

    pub fn present_offer_code_redeem_sheet() -> Result<(), StoreKitError> {
        let mut error_message = ptr::null_mut();
        let status =
            unsafe { ffi::sk_app_store_present_offer_code_redeem_sheet(&mut error_message) };
        if status == ffi::status::OK {
            Ok(())
        } else {
            Err(unsafe { error_from_status(status, error_message) })
        }
    }
}