ndk 0.8.0

Safe Rust bindings to the Android NDK
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

//! Bindings for [sync functions]
//!
//! [sync functions]: https://developer.android.com/ndk/reference/group/sync
#![cfg(feature = "sync")]

use std::{
    ffi::CStr,
    fmt::Debug,
    // TODO: Import from std::os::fd::{} since Rust 1.66
    os::unix::io::{AsRawFd, BorrowedFd, FromRawFd, OwnedFd},
    ptr::NonNull,
};

#[doc(alias = "sync_file_info")]
#[repr(transparent)]
pub struct SyncFileInfo {
    inner: NonNull<ffi::sync_file_info>,
}

impl Debug for SyncFileInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SyncFileInfo")
            .field("name", &self.name())
            .field("status", &self.status())
            .field("flags", &self.flags())
            .field("num_fences", &self.num_fences())
            .field("fence_info", &self.fence_info())
            .finish()
    }
}

impl SyncFileInfo {
    /// Retrieve detailed information about a sync file and its fences.
    #[doc(alias = "sync_file_info")]
    pub fn new(fd: BorrowedFd<'_>) -> Option<Self> {
        let inner = NonNull::new(unsafe { ffi::sync_file_info(fd.as_raw_fd()) })?;
        Some(Self { inner })
    }

    pub fn name(&self) -> &CStr {
        let inner = unsafe { self.inner.as_ref() };
        // TODO: Switch to CStr::from_bytes_until_nul (with c_char -> u8 transmute) since MSRV 1.69
        // https://github.com/ash-rs/ash/pull/746
        unsafe { CStr::from_ptr(inner.name.as_ptr()) }
    }

    pub fn status(&self) -> i32 {
        let inner = unsafe { self.inner.as_ref() };
        inner.status
    }

    pub fn flags(&self) -> u32 {
        let inner = unsafe { self.inner.as_ref() };
        inner.flags
    }

    pub fn num_fences(&self) -> usize {
        let inner = unsafe { self.inner.as_ref() };
        inner.num_fences as usize
    }

    /// Get the array of fence infos from the sync file's info.
    #[doc(alias = "sync_get_fence_info")]
    pub fn fence_info(&self) -> &[SyncFenceInfo] {
        let inner = unsafe { self.inner.as_ref() };

        if inner.num_fences == 0 {
            &[]
        } else {
            let sync_fence_info = NonNull::new(inner.sync_fence_info as *mut _)
                .expect("sync_fence_info cannot be null if num_fences > 0");
            unsafe {
                std::slice::from_raw_parts(sync_fence_info.as_ptr(), inner.num_fences as usize)
            }
        }
    }
}

impl Drop for SyncFileInfo {
    /// Free a [`struct@ffi::sync_file_info`] structure.
    #[doc(alias = "sync_file_info_free")]
    fn drop(&mut self) {
        unsafe { ffi::sync_file_info_free(self.inner.as_ptr()) }
    }
}

#[doc(alias = "sync_fence_info")]
#[repr(transparent)]
pub struct SyncFenceInfo(ffi::sync_fence_info);

impl Debug for SyncFenceInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SyncFenceInfo")
            .field("obj_name", &self.obj_name())
            .field("driver_name", &self.driver_name())
            .field("status", &self.status())
            .field("flags", &self.flags())
            .field("timestamp_ns", &self.timestamp_ns())
            .finish()
    }
}

impl SyncFenceInfo {
    pub fn obj_name(&self) -> &CStr {
        // TODO: Switch to CStr::from_bytes_until_nul (with c_char -> u8 transmute) since MSRV 1.69
        unsafe { CStr::from_ptr(self.0.obj_name.as_ptr()) }
    }

    pub fn driver_name(&self) -> &CStr {
        // TODO: Switch to CStr::from_bytes_until_nul (with c_char -> u8 transmute) since MSRV 1.69
        unsafe { CStr::from_ptr(self.0.driver_name.as_ptr()) }
    }

    pub fn status(&self) -> i32 {
        self.0.status
    }

    pub fn flags(&self) -> u32 {
        self.0.flags
    }

    pub fn timestamp_ns(&self) -> u64 {
        self.0.timestamp_ns
    }
}

/// Merge two sync files.
///
/// This produces a new sync file with the given name which has the union of the two original sync
/// file's fences; redundant fences may be removed.
///
/// If one of the input sync files is signaled or invalid, then this function may behave like
/// `dup()`: the new file descriptor refers to the valid/unsignaled sync file with its original
/// name, rather than a new sync file.
pub fn sync_merge(name: &CStr, fd1: BorrowedFd<'_>, fd2: BorrowedFd<'_>) -> OwnedFd {
    unsafe {
        OwnedFd::from_raw_fd(ffi::sync_merge(
            name.as_ptr(),
            fd1.as_raw_fd(),
            fd2.as_raw_fd(),
        ))
    }
}