ndk/asset: Add missing is_allocated() and open_file_descriptor() (#409)

These two functions are not exactly critical but may be useful to some
developers.

`is_allocated()` tells us whether a backing buffer is created in RAM, or
if the data is directly `mmap()`'ed from the APK (e.g. because no
decompression was needed and alignment requirements are upheld).  Note
that it only returns `true` after the asset is "mapped" (or read in some
way) via e.g `get_buffer()`; solely opening the asset is not enough to
trigger the allocation and decompression.

`open_file_descriptor()` gives the user a file descriptor, which simply
seems to be a `dup()` of that from the opened APK, together with an
offset and size of the given `AAsset` within that APK.  It also requires
the asset to be stored uncompressed within the APK.

Author: MarijnS95

ndk/CHANGELOG.md

@@ -18,6 +18,7 @@
 - native_window: Add `lock()` to blit raw pixel data. (#404)
 - hardware_buffer_format: Add `YCbCr_P010` and `R8_UNORM` variants. (#405)
 - **Breaking:** hardware_buffer_format: Add catch-all variant. (#407)
+- ndk/asset: Add missing `is_allocated()` and `open_file_descriptor()` methods. (#409)
 - **Breaking:** media_codec: Add support for asynchronous notification callbacks. (#410)
 - Add panic guards to callbacks. (#412)
 - looper: Add `remove_fd()` to unregister events/callbacks for a file descriptor. (#416)

ndk/src/asset.rs

@@ -6,6 +6,8 @@
 
 use std::ffi::{CStr, CString};
 use std::io;
+// TODO: Import from std::os::fd::{} since Rust 1.66
+use std::os::unix::io::{FromRawFd, OwnedFd};
 use std::ptr::NonNull;
 
 /// A native [`AAssetManager *`]
@@ -224,7 +226,34 @@ impl Asset {
         }
     }
 
-    //pub fn open_file_descriptor(&self) -> TODO
+    /// Returns whether this asset's internal buffer is allocated in ordinary RAM (i.e. not `mmap`ped).
+    #[doc(alias = "AAsset_isAllocated")]
+    pub fn is_allocated(&self) -> bool {
+        unsafe { ffi::AAsset_isAllocated(self.ptr.as_ptr()) != 0 }
+    }
+
+    /// Open a new file descriptor that can be used to read the asset data.
+    ///
+    /// Returns an error if direct fd access is not possible (for example, if the asset is compressed).
+    #[doc(alias = "AAsset_openFileDescriptor64")]
+    pub fn open_file_descriptor(&self) -> io::Result<OpenedFileDescriptor> {
+        let mut offset = 0;
+        let mut size = 0;
+        let res =
+            unsafe { ffi::AAsset_openFileDescriptor64(self.ptr.as_ptr(), &mut offset, &mut size) };
+        if res >= 0 {
+            Ok(OpenedFileDescriptor {
+                fd: unsafe { OwnedFd::from_raw_fd(res) },
+                offset: offset as usize,
+                size: size as usize,
+            })
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Android Asset openFileDescriptor error",
+            ))
+        }
+    }
 }
 
 impl io::Read for Asset {
@@ -268,3 +297,12 @@ impl io::Seek for Asset {
         }
     }
 }
+
+/// Contains the opened file descriptor returned by [`Asset::open_file_descriptor()`], together
+/// with the offset and size of the given asset within that file descriptor.
+#[derive(Debug)]
+pub struct OpenedFileDescriptor {
+    pub fd: OwnedFd,
+    pub offset: usize,
+    pub size: usize,
+}