maa_framework/
resource.rs

1use std::{fmt::Display, ops::Deref, ptr::null_mut};
2
3use crate::{
4    buffer::string_buffer::MaaStringBuffer, internal, maa_bool, CallbackHandler, MaaResult,
5    MaaStatus,
6};
7
8pub use internal::MaaResId;
9use serde::{Deserialize, Serialize};
10
11#[derive(Debug, Serialize, Deserialize)]
12pub enum MaaResOption {
13    Invalid,
14}
15
16impl MaaResOption {
17    fn get_inner_key(&self) -> internal::MaaResOption {
18        match self {
19            MaaResOption::Invalid => internal::MaaResOptionEnum_MaaResOption_Invalid,
20        }
21    }
22}
23
24impl Display for MaaResOption {
25    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26        match self {
27            MaaResOption::Invalid => write!(f, "Invalid"),
28        }
29    }
30}
31
32/// A resource instance
33///
34/// # Note
35///
36/// See [MaaInstance](crate::instance::MaaInstance) for lifetime hints.
37#[derive(Debug)]
38pub struct MaaResourceInstance<T> {
39    pub(crate) handle: internal::MaaResourceHandle,
40    _phantom: std::marker::PhantomData<T>,
41}
42
43impl<T> Deref for MaaResourceInstance<T> {
44    type Target = internal::MaaResourceHandle;
45
46    fn deref(&self) -> &Self::Target {
47        &self.handle
48    }
49}
50
51unsafe impl<T> Send for MaaResourceInstance<T> {}
52unsafe impl<T> Sync for MaaResourceInstance<T> {}
53
54impl<T> MaaResourceInstance<T> {
55    pub fn new(handler: Option<T>) -> Self
56    where
57        T: CallbackHandler,
58    {
59        let handle = unsafe {
60            match handler {
61                Some(handler) => {
62                    let handler = Box::new(handler);
63                    let handler = Box::into_raw(handler);
64                    internal::MaaResourceCreate(
65                        Some(internal::callback_handler::<T>),
66                        handler.cast(),
67                    )
68                }
69                None => internal::MaaResourceCreate(None, null_mut()),
70            }
71        };
72
73        MaaResourceInstance {
74            handle,
75            _phantom: std::marker::PhantomData,
76        }
77    }
78
79    pub(crate) fn new_from_handle(handle: internal::MaaResourceHandle) -> Self {
80        MaaResourceInstance {
81            handle,
82            _phantom: std::marker::PhantomData,
83        }
84    }
85
86    pub fn post_path(&self, path: &str) -> MaaResId {
87        let path = internal::to_cstring(path);
88        unsafe { internal::MaaResourcePostPath(self.handle, path) }
89    }
90
91    pub fn status(&self, id: MaaResId) -> MaaResult<MaaStatus> {
92        let status = unsafe { internal::MaaResourceStatus(self.handle, id) };
93
94        MaaStatus::try_from(status)
95    }
96
97    pub fn wait(&self, id: MaaResId) -> MaaResult<MaaStatus> {
98        let status = unsafe { internal::MaaResourceWait(self.handle, id) };
99
100        MaaStatus::try_from(status)
101    }
102
103    pub fn loaded(&self) -> bool {
104        let loaded = unsafe { internal::MaaResourceLoaded(self.handle) };
105        maa_bool!(loaded)
106    }
107
108    pub fn set_option(&self, option: MaaResOption) -> MaaResult<()> {
109        let key = option.get_inner_key();
110        let ret = unsafe {
111            match option {
112                MaaResOption::Invalid => {
113                    internal::MaaResourceSetOption(self.handle, key, null_mut(), 0)
114                }
115            }
116        };
117
118        if maa_bool!(ret) {
119            Ok(())
120        } else {
121            Err(crate::error::Error::MaaResourceSetOptionError(option))
122        }
123    }
124
125    pub fn get_hash(&self) -> MaaResult<String> {
126        let buffer = MaaStringBuffer::new();
127
128        let ret = unsafe { internal::MaaResourceGetHash(self.handle, buffer.handle) };
129
130        if maa_bool!(ret) {
131            Ok(buffer.string())
132        } else {
133            Err(crate::error::Error::MaaResourceGetHashError)
134        }
135    }
136
137    pub fn get_task_list(&self) -> MaaResult<String> {
138        let buffer = MaaStringBuffer::new();
139
140        let ret = unsafe { internal::MaaResourceGetTaskList(self.handle, buffer.handle) };
141
142        if maa_bool!(ret) {
143            let task_list = buffer.string();
144
145            Ok(task_list)
146        } else {
147            Err(crate::error::Error::MaaResourceGetTaskListError)
148        }
149    }
150
151    pub fn clear(&self) -> MaaResult<()> {
152        let ret = unsafe { internal::MaaResourceClear(self.handle) };
153
154        if maa_bool!(ret) {
155            Ok(())
156        } else {
157            Err(crate::error::Error::MaaResourceClearError)
158        }
159    }
160}
161
162impl<T> Drop for MaaResourceInstance<T> {
163    fn drop(&mut self) {
164        unsafe {
165            internal::MaaResourceDestroy(self.handle);
166        }
167    }
168}