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 binaryninjacore_sys::*;
use std::result;
use crate::rc::*;
use crate::string::*;
pub type Result<R> = result::Result<R, ()>;
#[derive(PartialEq, Eq, Hash)]
pub struct BackgroundTask {
pub(crate) handle: *mut BNBackgroundTask,
}
impl BackgroundTask {
pub(crate) unsafe fn from_raw(handle: *mut BNBackgroundTask) -> Self {
debug_assert!(!handle.is_null());
Self { handle }
}
pub fn new<S: BnStrCompatible>(initial_text: S, can_cancel: bool) -> Result<Ref<Self>> {
let text = initial_text.into_bytes_with_nul();
let handle = unsafe { BNBeginBackgroundTask(text.as_ref().as_ptr() as *mut _, can_cancel) };
if handle.is_null() {
return Err(());
}
unsafe { Ok(Ref::new(Self { handle })) }
}
pub fn can_cancel(&self) -> bool {
unsafe { BNCanCancelBackgroundTask(self.handle) }
}
pub fn is_cancelled(&self) -> bool {
unsafe { BNIsBackgroundTaskCancelled(self.handle) }
}
pub fn is_finished(&self) -> bool {
unsafe { BNIsBackgroundTaskFinished(self.handle) }
}
pub fn get_progress_text(&self) -> BnString {
unsafe { BnString::from_raw(BNGetBackgroundTaskProgressText(self.handle)) }
}
pub fn cancel(&self) {
unsafe { BNCancelBackgroundTask(self.handle) }
}
pub fn finish(&self) {
unsafe { BNFinishBackgroundTask(self.handle) }
}
pub fn set_progress_text<S: BnStrCompatible>(&self, text: S) {
let progress_text = text.into_bytes_with_nul();
unsafe {
BNSetBackgroundTaskProgressText(self.handle, progress_text.as_ref().as_ptr() as *mut _)
}
}
pub fn running_tasks() -> Array<BackgroundTask> {
unsafe {
let mut count = 0;
let handles = BNGetRunningBackgroundTasks(&mut count);
Array::new(handles, count, ())
}
}
}
unsafe impl RefCountable for BackgroundTask {
unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
Ref::new(Self {
handle: BNNewBackgroundTaskReference(handle.handle),
})
}
unsafe fn dec_ref(handle: &Self) {
BNFreeBackgroundTask(handle.handle);
}
}
impl CoreArrayProvider for BackgroundTask {
type Raw = *mut BNBackgroundTask;
type Context = ();
}
unsafe impl CoreOwnedArrayProvider for BackgroundTask {
unsafe fn free(raw: *mut *mut BNBackgroundTask, count: usize, _context: &()) {
BNFreeBackgroundTaskList(raw, count);
}
}
unsafe impl<'a> CoreArrayWrapper<'a> for BackgroundTask {
type Wrapped = Guard<'a, BackgroundTask>;
unsafe fn wrap_raw(
raw: &'a *mut BNBackgroundTask,
context: &'a (),
) -> Guard<'a, BackgroundTask> {
Guard::new(BackgroundTask::from_raw(*raw), context)
}
}
impl ToOwned for BackgroundTask {
type Owned = Ref<Self>;
fn to_owned(&self) -> Self::Owned {
unsafe { RefCountable::inc_ref(self) }
}
}
unsafe impl Send for BackgroundTask {}
unsafe impl Sync for BackgroundTask {}