finish top level android directory files

set_abort_message.odin

@@ -0,0 +1,18 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+foreign android {
+	/**
+	 * android_set_abort_message() sets the abort message that will be shown
+	 * by [debuggerd](https://source.android.com/devices/tech/debug/native-crash).
+	 * This is meant for use by libraries that deliberately abort so that they can
+	 * provide an explanation. It is used within bionic to implement assert() and
+	 * all FORTIFY/fdsan aborts.
+	 *
+	 * Available since API level 21.
+	 */
+
+	android_set_abort_message :: proc(__msg: cstring) ---
+}

sharedmem.odin

@@ -0,0 +1,77 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+foreign android {
+	/**
+	 * Create a shared memory region.
+	 *
+	 * Create shared memory region and returns an file descriptor.  The resulting file descriptor can be
+	 * mmap'ed to process memory space with PROT_READ | PROT_WRITE | PROT_EXEC. Access to shared memory
+	 * region can be restricted with {@link ASharedMemory_setProt}.
+	 *
+	 * Use close() to release the shared memory region.
+	 *
+	 * Use <a href="/reference/android/os/ParcelFileDescriptor">android.os.ParcelFileDescriptor</a>
+	 * to pass the file descriptor to another process. File descriptors may also be sent to other
+	 * processes over a Unix domain socket with sendmsg and SCM_RIGHTS. See sendmsg(3) and
+	 * cmsg(3) man pages for more information.
+	 *
+	 * If you intend to share this file descriptor with a child process after
+	 * calling exec(3), note that you will need to use fcntl(2) with FD_SETFD
+	 * to clear the FD_CLOEXEC flag for this to work on all versions of Android.
+	 *
+	 * Available since API level 26.
+	 *
+	 * \param name an optional name.
+	 * \param size size of the shared memory region
+	 * \return file descriptor that denotes the shared memory
+	 *         -1 and sets errno on failure, or -EINVAL if the error is that size was 0.
+	 */
+	ASharedMemory_create :: proc(name: cstring, size: uint) -> i32 ---
+
+	/**
+	* Get the size of the shared memory region.
+	*
+	* Available since API level 26.
+	*
+	* \param fd file descriptor of the shared memory region
+	* \return size in bytes 0 if fd is not a valid shared memory file descriptor.
+	*/
+	ASharedMemory_getSize :: proc(fd: i32) -> uint ---
+
+	/**
+	* Restrict access of shared memory region.
+	*
+	* This function restricts access of a shared memory region. Access can only be removed. The effect
+	* applies globally to all file descriptors in all processes across the system that refer to this
+	* shared memory region. Existing memory mapped regions are not affected.
+	*
+	* It is a common use case to create a shared memory region, map it read/write locally to intialize
+	* content, and then send the shared memory to another process with read only access. Code example
+	* as below (error handling omited).
+	*
+	*
+	*     int fd = ASharedMemory_create("memory", 128)
+	*
+	*     // By default it has PROT_READ | PROT_WRITE | PROT_EXEC.
+	*     size_t memSize = ASharedMemory_getSize(fd)
+	*     char *buffer = (char *) mmap(NULL, memSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
+	*
+	*     strcpy(buffer, "This is an example.") // trivially initialize content
+	*
+	*     // limit access to read only
+	*     ASharedMemory_setProt(fd, PROT_READ)
+	*
+	*     // share fd with another process here and the other process can only map with PROT_READ.
+	*
+	* Available since API level 26.
+	*
+	* \param fd   file descriptor of the shared memory region.
+	* \param prot any bitwise-or'ed combination of PROT_READ, PROT_WRITE, PROT_EXEC denoting
+	*             updated access. Note access can only be removed, but not added back.
+	* \return 0 for success, -1 and sets errno on failure.
+	*/
+	ASharedMemory_setProt :: proc(fd: i32, prot: i32) -> i32 ---
+}

sharedmem_jni.odin

@@ -0,0 +1,24 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+foreign android {
+	/**
+	 * Returns a dup'd FD from the given Java android.os.SharedMemory object. The returned file
+	 * descriptor has all the same properties & capabilities as the FD returned from
+	 * ASharedMemory_create(), however the protection flags will be the same as those of the
+	 * android.os.SharedMemory object.
+	 *
+	 * Use close() to release the shared memory region.
+	 *
+	 * Available since API level 27.
+	 *
+	 * \param env The JNIEnv* pointer
+	 * \param sharedMemory The Java android.os.SharedMemory object
+	 * \return file descriptor that denotes the shared memory; -1 if the shared memory object is
+	 *      already closed, if the JNIEnv or jobject is NULL, or if there are too many open file
+	 *      descriptors (errno=EMFILE)
+	 */
+	ASharedMemory_dupFromJava :: proc(env: ^JNIEnv, sharedMemory: jobject) -> i32 ---
+}

storage_manager.odin

@@ -0,0 +1,121 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/**
+ * The different states of a OBB storage passed to AStorageManager_obbCallbackFunc().
+ */
+OBBState :: enum i32 {
+    /**
+     * The OBB container is now mounted and ready for use. Can be returned
+     * as the status for callbacks made during asynchronous OBB actions.
+     */
+    MOUNTED = 1,
+
+    /**
+     * The OBB container is now unmounted and not usable. Can be returned
+     * as the status for callbacks made during asynchronous OBB actions.
+     */
+    UNMOUNTED = 2,
+
+    /**
+     * There was an internal system error encountered while trying to
+     * mount the OBB. Can be returned as the status for callbacks made
+     * during asynchronous OBB actions.
+     */
+    ERROR_INTERNAL = 20,
+
+    /**
+     * The OBB could not be mounted by the system. Can be returned as the
+     * status for callbacks made during asynchronous OBB actions.
+     */
+    ERROR_COULD_NOT_MOUNT = 21,
+
+    /**
+     * The OBB could not be unmounted. This most likely indicates that a
+     * file is in use on the OBB. Can be returned as the status for
+     * callbacks made during asynchronous OBB actions.
+     */
+    ERROR_COULD_NOT_UNMOUNT = 22,
+
+    /**
+     * A call was made to unmount the OBB when it was not mounted. Can be
+     * returned as the status for callbacks made during asynchronous OBB
+     * actions.
+     */
+    ERROR_NOT_MOUNTED = 23,
+
+    /**
+     * The OBB has already been mounted. Can be returned as the status for
+     * callbacks made during asynchronous OBB actions.
+     */
+    ERROR_ALREADY_MOUNTED = 24,
+
+    /**
+     * The current application does not have permission to use this OBB.
+     * This could be because the OBB indicates it's owned by a different
+     * package. Can be returned as the status for callbacks made during
+     * asynchronous OBB actions.
+     */
+    ERROR_PERMISSION_DENIED = 25,
+}
+
+/**
+ * {@link AStorageManager} manages application OBB storage, a pointer
+ * can be obtained with AStorageManager_new().
+ */
+AStorageManager :: struct{}
+
+/**
+* Callback function for asynchronous calls made on OBB files.
+*
+* "state" is one of the following constants:
+* - {@link AOBB_STATE_MOUNTED}
+* - {@link AOBB_STATE_UNMOUNTED}
+* - {@link AOBB_STATE_ERROR_INTERNAL}
+* - {@link AOBB_STATE_ERROR_COULD_NOT_MOUNT}
+* - {@link AOBB_STATE_ERROR_COULD_NOT_UNMOUNT}
+* - {@link AOBB_STATE_ERROR_NOT_MOUNTED}
+* - {@link AOBB_STATE_ERROR_ALREADY_MOUNTED}
+* - {@link AOBB_STATE_ERROR_PERMISSION_DENIED}
+*/
+AStorageManager_obbCallbackFunc :: #type proc "c" (filename: cstring, state: OBBState, data: rawptr)
+
+foreign android {
+	/**
+	 * Obtains a new instance of AStorageManager.
+	 */
+	AStorageManager_new :: proc() -> ^AStorageManager ---
+
+	/**
+	* Release AStorageManager instance.
+	*/
+	AStorageManager_delete :: proc(mgr: ^AStorageManager) ---
+
+	/**
+	* Attempts to mount an OBB file. This is an asynchronous operation.
+	*
+	* Since API level 33, this function can only be used to mount unencrypted OBBs,
+	* i.e. the {@code key} parameter must be {@code null} or an empty string. Note
+	* that even before API level 33, mounting encrypted OBBs didn't work on many
+	* Android device implementations. Applications should not assume any particular
+	* behavior when {@code key} is nonempty.
+	*/
+	AStorageManager_mountObb :: proc(mgr: ^AStorageManager, filename: cstring, key: cstring, cb: AStorageManager_obbCallbackFunc, data: rawptr) ---
+
+	/**
+	* Attempts to unmount an OBB file. This is an asynchronous operation.
+	*/
+	AStorageManager_unmountObb :: proc(mgr: ^AStorageManager, filename: cstring, force: i32, cb: AStorageManager_obbCallbackFunc, data: rawptr) ---
+
+	/**
+	* Check whether an OBB is mounted.
+	*/
+	AStorageManager_isObbMounted :: proc(mgr: ^AStorageManager, filename: cstring) -> i32 ---
+
+	/**
+	* Get the mounted path for an OBB.
+	*/
+	AStorageManager_getMountedObbPath :: proc(mgr: ^AStorageManager, filename: cstring) -> cstring ---
+}

surface_control.odin

@@ -0,0 +1,523 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/**
+* Parameter for ASurfaceTransaction_setVisibility().
+*/
+SurfaceTransactionVisibility :: enum i8 {
+	HIDE = 0,
+	SHOW = 1,
+}
+
+/**
+* Parameter for ASurfaceTransaction_setBufferTransparency().
+*/
+SurfaceTransactionTransparency :: enum i8 {
+	TRANSPARENT = 0,
+	TRANSLUCENT = 1,
+	OPAQUE = 2,
+}
+
+/**
+ * The SurfaceControl API can be used to provide a hierarchy of surfaces for
+ * composition to the system compositor. ASurfaceControl represents a content node in
+ * this hierarchy.
+ */
+ASurfaceControl :: struct{}
+
+/**
+* ASurfaceTransaction is a collection of updates to the surface tree that must
+* be applied atomically.
+*/
+ASurfaceTransaction :: struct{}
+
+/**
+* An opaque handle returned during a callback that can be used to query general stats and stats for
+* surfaces which were either removed or for which buffers were updated after this transaction was
+* applied.
+*/
+ASurfaceTransactionStats :: struct{}
+
+/**
+* Since the transactions are applied asynchronously, the
+* ASurfaceTransaction_OnComplete callback can be used to be notified when a frame
+* including the updates in a transaction was presented.
+*
+* Buffers which are replaced or removed from the scene in the transaction invoking
+* this callback may be reused after this point.
+*
+* \param context Optional context provided by the client that is passed into
+* the callback.
+*
+* \param stats Opaque handle that can be passed to ASurfaceTransactionStats functions to query
+* information about the transaction. The handle is only valid during the callback.
+*
+* THREADING
+* The transaction completed callback can be invoked on any thread.
+*
+* Available since API level 29.
+*/
+ASurfaceTransaction_OnComplete :: #type proc "c" (_context: rawptr, stats: ^ASurfaceTransactionStats)
+
+/**
+* The ASurfaceTransaction_OnCommit callback is invoked when transaction is applied and the updates
+* are ready to be presented. This callback will be invoked before the
+* ASurfaceTransaction_OnComplete callback.
+*
+* This callback does not mean buffers have been released! It simply means that any new
+* transactions applied will not overwrite the transaction for which we are receiving
+* a callback and instead will be included in the next frame. If you are trying to avoid
+* dropping frames (overwriting transactions), and unable to use timestamps (Which provide
+* a more efficient solution), then this method provides a method to pace your transaction
+* application.
+*
+* \param context Optional context provided by the client that is passed into the callback.
+*
+* \param stats Opaque handle that can be passed to ASurfaceTransactionStats functions to query
+* information about the transaction. The handle is only valid during the callback.
+* Present and release fences are not available for this callback. Querying them using
+* ASurfaceTransactionStats_getPresentFenceFd and ASurfaceTransactionStats_getPreviousReleaseFenceFd
+* will result in failure.
+*
+* THREADING
+* The transaction committed callback can be invoked on any thread.
+*
+* Available since API level 31.
+*/
+ASurfaceTransaction_OnCommit :: #type proc "c" (_context: rawptr, stats: ^ASurfaceTransactionStats)
+
+foreign android {
+	/**
+	 * Creates an ASurfaceControl with either ANativeWindow or an ASurfaceControl as its parent.
+	 * \a debug_name is a debug name associated with this surface. It can be used to
+	 * identify this surface in the SurfaceFlinger's layer tree. It must not be
+	 * null.
+	 *
+	 * The caller takes ownership of the ASurfaceControl returned and must release it
+	 * using ASurfaceControl_release below.
+	 *
+	 * Available since API level 29.
+	 */
+	ASurfaceControl_createFromWindow :: proc(parent: ^ANativeWindow, debug_name: cstring) -> ^ASurfaceControl ---
+
+	/**
+	* See ASurfaceControl_createFromWindow.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceControl_create :: proc(parent: ^ASurfaceControl, debug_name: cstring) -> ^ASurfaceControl ---
+
+	/**
+	* Acquires a reference on the given ASurfaceControl object.  This prevents the object
+	* from being deleted until the reference is removed.
+	*
+	* To release the reference, use the ASurfaceControl_release function.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceControl_acquire :: proc(surface_control: ^ASurfaceControl) ---
+
+	/**
+	* Removes a reference that was previously acquired with one of the following functions:
+	*   ASurfaceControl_createFromWindow
+	*   ASurfaceControl_create
+	*   ANativeWindow_acquire
+	* The surface and its children may remain on display as long as their parent remains on display.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceControl_release :: proc(surface_control: ^ASurfaceControl) ---
+
+	/**
+	* The caller takes ownership of the transaction and must release it using
+	* ASurfaceTransaction_delete() below.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_create :: proc() -> ^ASurfaceTransaction ---
+
+	/**
+	* Destroys the \a transaction object.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_delete :: proc(transaction: ^ASurfaceTransaction) ---
+
+	/**
+	* Applies the updates accumulated in \a transaction.
+	*
+	* Note that the transaction is guaranteed to be applied atomically. The
+	* transactions which are applied on the same thread are also guaranteed to be
+	* applied in order.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_apply :: proc(transaction: ^ASurfaceTransaction) ---
+
+	/**
+	* Returns the timestamp of when the frame was latched by the framework. Once a frame is
+	* latched by the framework, it is presented at the following hardware vsync.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransactionStats_getLatchTime :: proc(surface_transaction_stats: ^ASurfaceTransactionStats) -> i64 ---
+
+	/**
+	* Returns a sync fence that signals when the transaction has been presented.
+	* The recipient of the callback takes ownership of the fence and is responsible for closing
+	* it. If a device does not support present fences, a -1 will be returned.
+	*
+	* This query is not valid for ASurfaceTransaction_OnCommit callback.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransactionStats_getPresentFenceFd :: proc(surface_transaction_stats: ^ASurfaceTransactionStats) -> i32 ---
+
+	/**
+	* \a outASurfaceControls returns an array of ASurfaceControl pointers that were updated during the
+	* transaction. Stats for the surfaces can be queried through ASurfaceTransactionStats functions.
+	* When the client is done using the array, it must release it by calling
+	* ASurfaceTransactionStats_releaseASurfaceControls.
+	*
+	* Available since API level 29.
+	*
+	* \a outASurfaceControlsSize returns the size of the ASurfaceControls array.
+	*/
+	ASurfaceTransactionStats_getASurfaceControls :: proc(surface_transaction_stats: ^ASurfaceTransactionStats, outASurfaceControls: ^^^ASurfaceControl, outASurfaceControlsSize: ^uint) ---
+	/**
+	* Releases the array of ASurfaceControls that were returned by
+	* ASurfaceTransactionStats_getASurfaceControls().
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransactionStats_releaseASurfaceControls :: proc(surface_controls: ^^ASurfaceControl) ---
+
+	/**
+	* Returns the timestamp of when the CURRENT buffer was acquired. A buffer is considered
+	* acquired when its acquire_fence_fd has signaled. A buffer cannot be latched or presented until
+	* it is acquired. If no acquire_fence_fd was provided, this timestamp will be set to -1.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransactionStats_getAcquireTime :: proc(surface_transaction_stats: ^ASurfaceTransactionStats, surface_control: ^ASurfaceControl) -> i64 ---
+
+	/**
+	* The returns the fence used to signal the release of the PREVIOUS buffer set on
+	* this surface. If this fence is valid (>=0), the PREVIOUS buffer has not yet been released and the
+	* fence will signal when the PREVIOUS buffer has been released. If the fence is -1 , the PREVIOUS
+	* buffer is already released. The recipient of the callback takes ownership of the
+	* previousReleaseFenceFd and is responsible for closing it.
+	*
+	* Each time a buffer is set through ASurfaceTransaction_setBuffer() on a transaction
+	* which is applied, the framework takes a ref on this buffer. The framework treats the
+	* addition of a buffer to a particular surface as a unique ref. When a transaction updates or
+	* removes a buffer from a surface, or removes the surface itself from the tree, this ref is
+	* guaranteed to be released in the OnComplete callback for this transaction. The
+	* ASurfaceControlStats provided in the callback for this surface may contain an optional fence
+	* which must be signaled before the ref is assumed to be released.
+	*
+	* The client must ensure that all pending refs on a buffer are released before attempting to reuse
+	* this buffer, otherwise synchronization errors may occur.
+	*
+	* This query is not valid for ASurfaceTransaction_OnCommit callback.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransactionStats_getPreviousReleaseFenceFd :: proc(surface_transaction_stats: ^ASurfaceTransactionStats, surface_control: ^ASurfaceControl) -> i32 ---
+
+	/**
+	* Sets the callback that will be invoked when the updates from this transaction
+	* are presented. For details on the callback semantics and data, see the
+	* comments on the ASurfaceTransaction_OnComplete declaration above.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setOnComplete :: proc(transaction: ^ASurfaceTransaction, _context: rawptr, func: ASurfaceTransaction_OnComplete) ---
+
+	/**
+	* Sets the callback that will be invoked when the updates from this transaction are applied and are
+	* ready to be presented. This callback will be invoked before the ASurfaceTransaction_OnComplete
+	* callback.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setOnCommit :: proc(transaction: ^ASurfaceTransaction, _context: rawptr, func: ASurfaceTransaction_OnCommit) ---
+
+	/**
+	* Reparents the \a surface_control from its old parent to the \a new_parent surface control.
+	* Any children of the reparented \a surface_control will remain children of the \a surface_control.
+	*
+	* The \a new_parent can be null. Surface controls with a null parent do not appear on the display.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_reparent :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, new_parent: ^ASurfaceControl) ---
+
+	/**
+	* Updates the visibility of \a surface_control. If show is set to
+	* ASURFACE_TRANSACTION_VISIBILITY_HIDE, the \a surface_control and all surfaces in its subtree will
+	* be hidden.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setVisibility :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, visibility: SurfaceTransactionVisibility) ---
+
+	/**
+	* Updates the z order index for \a surface_control. Note that the z order for a surface
+	* is relative to other surfaces which are siblings of this surface. The behavior of sibilings with
+	* the same z order is undefined.
+	*
+	* Z orders may be from MIN_INT32 to MAX_INT32. A layer's default z order index is 0.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setZOrder :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, z_order: i32) ---
+
+	/**
+	* Updates the AHardwareBuffer displayed for \a surface_control. If not -1, the
+	* acquire_fence_fd should be a file descriptor that is signaled when all pending work
+	* for the buffer is complete and the buffer can be safely read.
+	*
+	* The frameworks takes ownership of the \a acquire_fence_fd passed and is responsible
+	* for closing it.
+	*
+	* Note that the buffer must be allocated with AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE
+	* as the surface control might be composited using the GPU.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setBuffer :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, buffer: ^AHardwareBuffer, acquire_fence_fd: i32 = -1) ---
+
+	/**
+	* Updates the color for \a surface_control.  This will make the background color for the
+	* ASurfaceControl visible in transparent regions of the surface.  Colors \a r, \a g,
+	* and \a b must be within the range that is valid for \a dataspace.  \a dataspace and \a alpha
+	* will be the dataspace and alpha set for the background color layer.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setColor :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, r: f32, g: f32, b: f32, alpha: f32, dataspace: ADataSpace) ---
+
+	/**
+	* \param source The sub-rect within the buffer's content to be rendered inside the surface's area
+	* The surface's source rect is clipped by the bounds of its current buffer. The source rect's width
+	* and height must be > 0.
+	*
+	* \param destination Specifies the rect in the parent's space where this surface will be drawn. The post
+	* source rect bounds are scaled to fit the destination rect. The surface's destination rect is
+	* clipped by the bounds of its parent. The destination rect's width and height must be > 0.
+	*
+	* \param transform The transform applied after the source rect is applied to the buffer. This parameter
+	* should be set to 0 for no transform. To specify a transfrom use the NATIVE_WINDOW_TRANSFORM_*
+	* enum.
+	*
+	* Available since API level 29.
+	*
+	* @deprecated Use setCrop, setPosition, setBufferTransform, and setScale instead. Those functions
+	* provide well defined behavior and allows for more control by the apps. It also allows the caller
+	* to set different properties at different times, instead of having to specify all the desired
+	* properties at once.
+	*/
+	ASurfaceTransaction_setGeometry :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, source: ^ARect, destination: ^ARect, transform: ANativeWindowTransform) ---
+
+	/**
+	* Bounds the surface and its children to the bounds specified. The crop and buffer size will be
+	* used to determine the bounds of the surface. If no crop is specified and the surface has no
+	* buffer, the surface bounds is only constrained by the size of its parent bounds.
+	*
+	* \param crop The bounds of the crop to apply.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setCrop :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, crop: ^ARect) ---
+
+	/**
+	* Specifies the position in the parent's space where the surface will be drawn.
+	*
+	* \param x The x position to render the surface.
+	* \param y The y position to render the surface.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setPosition :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, x: i32, y: i32) ---
+
+	/**
+	* \param transform The transform applied after the source rect is applied to the buffer. This
+	* parameter should be set to 0 for no transform. To specify a transform use the
+	* NATIVE_WINDOW_TRANSFORM_* enum.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setBufferTransform :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, transform: ANativeWindowTransform) ---
+
+	/**
+	* Sets an x and y scale of a surface with (0, 0) as the centerpoint of the scale.
+	*
+	* \param xScale The scale in the x direction. Must be greater than 0.
+	* \param yScale The scale in the y direction. Must be greater than 0.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setScale :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, xScale: f32, yScale: f32) ---
+
+	/**
+	* Updates whether the content for the buffer associated with this surface is
+	* completely opaque. If true, every pixel of content inside the buffer must be
+	* opaque or visual errors can occur.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setBufferTransparency :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, transparency: SurfaceTransactionTransparency) ---
+
+	/**
+	* Updates the region for the content on this surface updated in this
+	* transaction. If unspecified, the complete surface is assumed to be damaged.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setDamageRegion :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, rects: [^]ARect , count: u32) ---
+
+	/**
+	* Specifies a desiredPresentTime for the transaction. The framework will try to present
+	* the transaction at or after the time specified.
+	*
+	* Transactions will not be presented until all of their acquire fences have signaled even if the
+	* app requests an earlier present time.
+	*
+	* If an earlier transaction has a desired present time of x, and a later transaction has a desired
+	* present time that is before x, the later transaction will not preempt the earlier transaction.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setDesiredPresentTime :: proc(transaction: ^ASurfaceTransaction, desiredPresentTime: i64) ---
+
+	/**
+	* Sets the alpha for the buffer. It uses a premultiplied blending.
+	*
+	* The \a alpha must be between 0.0 and 1.0.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setBufferAlpha :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, alpha: f32) ---
+
+	/**
+	* Sets the data space of the surface_control's buffers.
+	*
+	* If no data space is set, the surface control defaults to ADATASPACE_SRGB.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setBufferDataSpace :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, data_space: ADataSpace) ---
+
+	/**
+	* SMPTE ST 2086 "Mastering Display Color Volume" static metadata
+	*
+	* When \a metadata is set to null, the framework does not use any smpte2086 metadata when rendering
+	* the surface's buffer.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setHdrMetadata_smpte2086 :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, metadata: ^AHdrMetadata_smpte2086) ---
+
+	/**
+	* Sets the CTA 861.3 "HDR Static Metadata Extension" static metadata on a surface.
+	*
+	* When \a metadata is set to null, the framework does not use any cta861.3 metadata when rendering
+	* the surface's buffer.
+	*
+	* Available since API level 29.
+	*/
+	ASurfaceTransaction_setHdrMetadata_cta861_3 :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, metadata: ^AHdrMetadata_cta861_3) ---
+
+	/**
+	* Same as ASurfaceTransaction_setFrameRateWithChangeStrategy(transaction, surface_control,
+	* frameRate, compatibility, ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS).
+	*
+	* See ASurfaceTransaction_setFrameRateWithChangeStrategy().
+	*
+	* Available since API level 30.
+	*/
+	ASurfaceTransaction_setFrameRate :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, frameRate: f32, compatibility: ANativeWindow_FrameRateCompatibility) ---
+
+	/**
+	* Sets the intended frame rate for \a surface_control.
+	*
+	* On devices that are capable of running the display at different refresh rates, the system may
+	* choose a display refresh rate to better match this surface's frame rate. Usage of this API won't
+	* directly affect the application's frame production pipeline. However, because the system may
+	* change the display refresh rate, calls to this function may result in changes to Choreographer
+	* callback timings, and changes to the time interval at which the system releases buffers back to
+	* the application.
+	*
+	* You can register for changes in the refresh rate using
+	* \a AChoreographer_registerRefreshRateCallback.
+	*
+	* \param frameRate is the intended frame rate of this surface, in frames per second. 0 is a special
+	* value that indicates the app will accept the system's choice for the display frame rate, which is
+	* the default behavior if this function isn't called. The frameRate param does <em>not</em> need to
+	* be a valid refresh rate for this device's display - e.g., it's fine to pass 30fps to a device
+	* that can only run the display at 60fps.
+	*
+	* \param compatibility The frame rate compatibility of this surface. The compatibility value may
+	* influence the system's choice of display frame rate. To specify a compatibility use the
+	* ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* enum. This parameter is ignored when frameRate is 0.
+	*
+	* \param changeFrameRateStrategy Whether display refresh rate transitions caused by this
+	* surface should be seamless. A seamless transition is one that doesn't have any visual
+	* interruptions, such as a black screen for a second or two. See the
+	* ANATIVEWINDOW_CHANGE_FRAME_RATE_* values. This parameter is ignored when frameRate is 0.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setFrameRateWithChangeStrategy :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, frameRate: f32, compatibility: ANativeWindow_FrameRateCompatibility, changeFrameRateStrategy: ANativeWindow_ChangeFrameRateStrategy) ---
+
+	/**
+	* Indicate whether to enable backpressure for buffer submission to a given SurfaceControl.
+	*
+	* By default backpressure is disabled, which means submitting a buffer prior to receiving
+	* a callback for the previous buffer could lead to that buffer being "dropped". In cases
+	* where you are selecting for latency, this may be a desirable behavior! We had a new buffer
+	* ready, why shouldn't we show it?
+	*
+	* When back pressure is enabled, each buffer will be required to be presented
+	* before it is released and the callback delivered
+	* (absent the whole SurfaceControl being removed).
+	*
+	* Most apps are likely to have some sort of backpressure internally, e.g. you are
+	* waiting on the callback from frame N-2 before starting frame N. In high refresh
+	* rate scenarios there may not be much time between SurfaceFlinger completing frame
+	* N-1 (and therefore releasing buffer N-2) and beginning frame N. This means
+	* your app may not have enough time to respond in the callback. Using this flag
+	* and pushing buffers earlier for server side queuing will be advantageous
+	* in such cases.
+	*
+	* \param transaction The transaction in which to make the change.
+	* \param surface_control The ASurfaceControl on which to control buffer backpressure behavior.
+	* \param enableBackPressure Whether to enable back pressure.
+	*
+	* Available since API level 31.
+	*/
+	ASurfaceTransaction_setEnableBackPressure :: proc(transaction: ^ASurfaceTransaction, surface_control: ^ASurfaceControl, enableBackPressure: bool) ---
+
+	/**
+	* Sets the frame timeline to use in SurfaceFlinger.
+	*
+	* A frame timeline should be chosen based on the frame deadline the application
+	* can meet when rendering the frame and the application's desired presentation time.
+	* By setting a frame timeline, SurfaceFlinger tries to present the frame at the corresponding
+	* expected presentation time.
+	*
+	* To receive frame timelines, a callback must be posted to Choreographer using
+	* AChoreographer_postVsyncCallback(). The \c vsyncId can then be extracted from the
+	* callback payload using AChoreographerFrameCallbackData_getFrameTimelineVsyncId().
+	*
+	* \param vsyncId The vsync ID received from AChoreographer, setting the frame's presentation target
+	* to the corresponding expected presentation time and deadline from the frame to be rendered. A
+	* stale or invalid value will be ignored.
+	*
+	* Available since API level 33.
+	*/
+	ASurfaceTransaction_setFrameTimeline :: proc(transaction: ^ASurfaceTransaction, vsyncId: AVsyncId) ---
+}

surface_texture.odin

@@ -0,0 +1,128 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/**
+ * {@link ASurfaceTexture} is an opaque type to manage SurfaceTexture from native code
+ *
+ * {@link ASurfaceTexture} can be obtained from an android.graphics.SurfaceTexture object using
+ * ASurfaceTexture_fromSurfaceTexture().
+ */
+ASurfaceTexture :: struct{}
+
+foreign android {
+	/**
+	 * Release the reference to the native ASurfaceTexture acquired with
+	 * ASurfaceTexture_fromSurfaceTexture().
+	 * Failing to do so will result in leaked memory and graphic resources.
+	 *
+	 * Available since API level 28.
+	 *
+	 * \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	 */
+	ASurfaceTexture_release :: proc(st: ^ASurfaceTexture) ---
+
+	/**
+	* Returns a reference to an ANativeWindow (i.e. the Producer) for this SurfaceTexture.
+	* This is equivalent to Java's: Surface sur = new Surface(surfaceTexture)
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	* @return A reference to an ANativeWindow. This reference MUST BE released when no longer needed
+	* using ANativeWindow_release(). Failing to do so will result in leaked resources. nullptr is
+	* returned if \p st is null or if it's not an instance of android.graphics.SurfaceTexture
+	*/
+	ASurfaceTexture_acquireANativeWindow :: proc(st: ^ASurfaceTexture) -> ^ANativeWindow ---
+
+	/**
+	* Attach the SurfaceTexture to the OpenGL ES context that is current on the calling thread.  A
+	* new OpenGL ES texture object is created and populated with the SurfaceTexture image frame
+	* that was current at the time of the last call to {@link ASurfaceTexture_detachFromGLContext}.
+	* This new texture is bound to the GL_TEXTURE_EXTERNAL_OES texture target.
+	*
+	* This can be used to access the SurfaceTexture image contents from multiple OpenGL ES
+	* contexts.  Note, however, that the image contents are only accessible from one OpenGL ES
+	* context at a time.
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	* \param texName The name of the OpenGL ES texture that will be created.  This texture name
+	* must be unusued in the OpenGL ES context that is current on the calling thread.
+	* \return 0 on success, negative posix error code otherwise (see <errno.h>)
+	*/
+	ASurfaceTexture_attachToGLContext :: proc(st: ^ASurfaceTexture, texName: u32) -> i32 ---
+
+	/**
+	* Detach the SurfaceTexture from the OpenGL ES context that owns the OpenGL ES texture object.
+	* This call must be made with the OpenGL ES context current on the calling thread.  The OpenGL
+	* ES texture object will be deleted as a result of this call.  After calling this method all
+	* calls to {@link ASurfaceTexture_updateTexImage} will fail until a successful call to
+	* {@link ASurfaceTexture_attachToGLContext} is made.
+	*
+	* This can be used to access the SurfaceTexture image contents from multiple OpenGL ES
+	* contexts.  Note, however, that the image contents are only accessible from one OpenGL ES
+	* context at a time.
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	* \return 0 on success, negative posix error code otherwise (see <errno.h>)
+	*/
+	ASurfaceTexture_detachFromGLContext :: proc(st: ^ASurfaceTexture) -> i32 ---
+
+	/**
+	* Update the texture image to the most recent frame from the image stream.  This may only be
+	* called while the OpenGL ES context that owns the texture is current on the calling thread.
+	* It will implicitly bind its texture to the GL_TEXTURE_EXTERNAL_OES texture target.
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	* \return 0 on success, negative posix error code otherwise (see <errno.h>)
+	*/
+	ASurfaceTexture_updateTexImage :: proc(st: ^ASurfaceTexture) -> i32 ---
+
+	/**
+	* Retrieve the 4x4 texture coordinate transform matrix associated with the texture image set by
+	* the most recent call to updateTexImage.
+	*
+	* This transform matrix maps 2D homogeneous texture coordinates of the form (s, t, 0, 1) with s
+	* and t in the inclusive range [0, 1] to the texture coordinate that should be used to sample
+	* that location from the texture.  Sampling the texture outside of the range of this transform
+	* is undefined.
+	*
+	* The matrix is stored in column-major order so that it may be passed directly to OpenGL ES via
+	* the glLoadMatrixf or glUniformMatrix4fv functions.
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	* \param mtx the array into which the 4x4 matrix will be stored.  The array must have exactly
+	*     16 elements.
+	*/
+	ASurfaceTexture_getTransformMatrix :: proc(st: ^ASurfaceTexture, mtx: [16]f32) ---
+
+	/**
+	* Retrieve the timestamp associated with the texture image set by the most recent call to
+	* updateTexImage.
+	*
+	* This timestamp is in nanoseconds, and is normally monotonically increasing. The timestamp
+	* should be unaffected by time-of-day adjustments, and for a camera should be strictly
+	* monotonic but for a MediaPlayer may be reset when the position is set.  The
+	* specific meaning and zero point of the timestamp depends on the source providing images to
+	* the SurfaceTexture. Unless otherwise specified by the image source, timestamps cannot
+	* generally be compared across SurfaceTexture instances, or across multiple program
+	* invocations. It is mostly useful for determining time offsets between subsequent frames.
+	*
+	* For EGL/Vulkan producers, this timestamp is the desired present time set with the
+	* EGL_ANDROID_presentation_time or VK_GOOGLE_display_timing extensions
+	*
+	* Available since API level 28.
+	*
+	* \param st A ASurfaceTexture reference acquired with ASurfaceTexture_fromSurfaceTexture()
+	*/
+	ASurfaceTexture_getTimestamp :: proc(st: ^ASurfaceTexture) -> i64 ---
+}

surface_texture_jni.odin

@@ -0,0 +1,24 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+foreign android {
+	/**
+	 * Get a reference to the native ASurfaceTexture from the corresponding java object.
+	 *
+	 * The caller must keep a reference to the Java SurfaceTexture during the lifetime of the returned
+	 * ASurfaceTexture. Failing to do so could result in the ASurfaceTexture to stop functioning
+	 * properly once the Java object gets finalized.
+	 * However, this will not result in program termination.
+	 *
+	 * Available since API level 28.
+	 *
+	 * \param env JNI environment
+	 * \param surfacetexture Instance of Java SurfaceTexture object
+	 * \return native ASurfaceTexture reference or nullptr if the java object is not a SurfaceTexture.
+	 *         The returned reference MUST BE released when it's no longer needed using
+	 *         ASurfaceTexture_release().
+	 */
+	ASurfaceTexture_fromSurfaceTexture :: proc(env: ^JNIEnv, surfacetexture: jobject) -> ^ASurfaceTexture ---
+}

sync.odin

@@ -0,0 +1,87 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/* Fences indicate the status of an asynchronous task. They are initially
+ * in unsignaled state (0), and make a one-time transition to either signaled
+ * (1) or error (< 0) state. A sync file is a collection of one or more fences;
+ * the sync file's status is error if any of its fences are in error state,
+ * signaled if all of the child fences are signaled, or unsignaled otherwise.
+ *
+ * Sync files are created by various device APIs in response to submitting
+ * tasks to the device. Standard file descriptor lifetime syscalls like dup()
+ * and close() are used to manage sync file lifetime.
+ *
+ * The poll(), ppoll(), or select() syscalls can be used to wait for the sync
+ * file to change status, or (with a timeout of zero) to check its status.
+ *
+ * The functions below provide a few additional sync-specific operations.
+ */
+
+// TODO: move to sys/linux or sys/android or something idk.
+sync_fence_info :: struct {
+	obj_name: [32]u8,
+	driver_name: [32]u8,
+	status: i32,
+	flags: u32,
+	timestamp_ns: u64,
+}
+
+sync_file_info :: struct {
+	name: [32]u8,
+	status: i32,
+	flags: u32,
+	num_fences: u32,
+	pad: u32,
+	sync_fence_info: u64,
+}
+
+
+/**
+* Get the array of fence infos from the sync file's info.
+*
+* The returned array is owned by the parent sync file info, and has
+* info->num_fences entries.
+*
+* Available since API level 26.
+*/
+sync_get_fence_info :: #force_inline proc(info: ^sync_file_info) -> ^sync_fence_info {
+	return cast(^sync_fence_info)(uintptr(info.sync_fence_info))
+}
+
+foreign android {
+	/**
+	 * 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.
+	 *
+	 * The original fences remain valid, and the caller is responsible for closing
+	 * them.
+	 *
+	 * Available since API level 26.
+	 */
+	sync_merge :: proc(name: cstring, fd1: i32, fd2: i32) -> i32 ---
+
+	/**
+	* Retrieve detailed information about a sync file and its fences.
+	*
+	* The returned sync_file_info must be freed by calling sync_file_info_free().
+	*
+	* Available since API level 26.
+	*/
+	@(link_name="sync_file_info")
+	_sync_file_info :: proc(fd: i32) -> ^sync_file_info ---
+
+	/**
+	* Free a struct sync_file_info structure
+	*
+	* Available since API level 26.
+	*/
+	sync_file_info_free :: proc(info: ^sync_file_info) ---
+}

system_fonts.odin

@@ -0,0 +1,86 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/**
+ * @file system_fonts.h
+ * @brief Provides the system font configurations.
+ *
+ * These APIs provides the list of system installed font files with additional metadata about the
+ * font.
+ *
+ * The ASystemFontIterator_open method will give you an iterator which can iterate all system
+ * installed font files as shown in the following example.
+ *
+ * \code{.cpp}
+ *   ASystemFontIterator* iterator = ASystemFontIterator_open();
+ *   ASystemFont* font = NULL;
+ *
+ *   while ((font = ASystemFontIterator_next(iterator)) != nullptr) {
+ *       // Look if the font is your desired one.
+ *       if (ASystemFont_getWeight(font) == 400 && !ASystemFont_isItalic(font)
+ *           && ASystemFont_getLocale(font) == NULL) {
+ *           break;
+ *       }
+ *       ASystemFont_close(font);
+ *   }
+ *   ASystemFontIterator_close(iterator);
+ *
+ *   int fd = open(ASystemFont_getFontFilePath(font), O_RDONLY);
+ *   int collectionIndex = ASystemFont_getCollectionINdex(font);
+ *   std::vector<std::pair<uint32_t, float>> variationSettings;
+ *   for (size_t i = 0; i < ASystemFont_getAxisCount(font); ++i) {
+ *       variationSettings.push_back(std::make_pair(
+ *           ASystemFont_getAxisTag(font, i),
+ *           ASystemFont_getAxisValue(font, i)));
+ *   }
+ *   ASystemFont_close(font);
+ *
+ *   // Use this font for your text rendering engine.
+ *
+ * \endcode
+ *
+ * Available since API level 29.
+ */
+
+/**
+ * ASystemFontIterator provides access to the system font configuration.
+ *
+ * ASystemFontIterator is an iterator for all available system font settings.
+ * This iterator is not a thread-safe object. Do not pass this iterator to other threads.
+ */
+ASystemFontIterator :: struct{}
+
+foreign android {
+	/**
+	 * Create a system font iterator.
+	 *
+	 * Use ASystemFont_close() to close the iterator.
+	 *
+	 * Available since API level 29.
+	 *
+	 * \return a pointer for a newly allocated iterator, nullptr on failure.
+	 */
+	ASystemFontIterator_open :: proc() -> ^ASystemFontIterator ---
+
+	/**
+	* Close an opened system font iterator, freeing any related resources.
+	*
+	* Available since API level 29.
+	*
+	* \param iterator a pointer of an iterator for the system fonts. Do nothing if NULL is passed.
+	*/
+	ASystemFontIterator_close :: proc(iterator: ^ASystemFontIterator) ---
+
+	/**
+	* Move to the next system font.
+	*
+	* Available since API level 29.
+	*
+	* \param iterator an iterator for the system fonts. Passing NULL is not allowed.
+	* \return a font. If no more font is available, returns nullptr. You need to release the returned
+	*         font by ASystemFont_close when it is no longer needed.
+	*/
+	ASystemFontIterator_next :: proc(iterator: ^ASystemFontIterator) -> ^AFont ---
+}

thermal.odin

@@ -0,0 +1,165 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+/**
+ * Thermal status used in function {@link AThermal_getCurrentThermalStatus} and
+ * {@link AThermal_StatusCallback}.
+ */
+AThermalStatus :: enum {
+    /** Error in thermal status. */
+    ERROR = -1,
+    /** Not under throttling. */
+    NONE = 0,
+    /** Light throttling where UX is not impacted. */
+    LIGHT = 1,
+    /** Moderate throttling where UX is not largely impacted. */
+    MODERATE = 2,
+    /** Severe throttling where UX is largely impacted. */
+    SEVERE = 3,
+    /** Platform has done everything to reduce power. */
+    CRITICAL = 4,
+    /**
+     * Key components in platform are shutting down due to thermal condition.
+     * Device functionalities will be limited.
+     */
+    EMERGENCY = 5,
+    /** Need shutdown immediately. */
+    SHUTDOWN = 6,
+}
+
+/**
+ * An opaque type representing a handle to a thermal manager.
+ * An instance of thermal manager must be acquired prior to
+ * using thermal status APIs and must be released after use.
+ *
+ * <p>To use:<ul>
+ *    <li>Create a new thermal manager instance by calling the
+ *        {@link AThermal_acquireManager} function.</li>
+ *    <li>Get current thermal status with
+ *        {@link AThermal_getCurrentThermalStatus}.</li>
+ *    <li>Register a thermal status listener with
+ *        {@link AThermal_registerThermalStatusListener}.</li>
+ *    <li>Unregister a thermal status listener with
+ *        {@link AThermal_unregisterThermalStatusListener}.</li>
+ *    <li>Release the thermal manager instance with
+ *        {@link AThermal_releaseManager}.</li></ul></p>
+ *
+ */
+AThermalManager :: struct{}
+
+/**
+ * Prototype of the function that is called when thermal status changes.
+ * It's passed the updated thermal status as parameter, as well as the
+ * pointer provided by the client that registered a callback.
+ */
+AThermal_StatusCallback :: #type proc "c" (data: rawptr, status: AThermalStatus)
+
+foreign android {
+	/**
+	  * Acquire an instance of the thermal manager. This must be freed using
+	  * {@link AThermal_releaseManager}.
+	  *
+	  * Available since API level 30.
+	  *
+	  * @return manager instance on success, nullptr on failure.
+	  */
+	AThermal_acquireManager :: proc() -> ^AThermalManager ---
+
+	/**
+	* Release the thermal manager pointer acquired via
+	* {@link AThermal_acquireManager}.
+	*
+	* Available since API level 30.
+	*
+	* @param manager The manager to be released.
+	*/
+	AThermal_releaseManager :: proc(manager: ^AThermalManager) ---
+
+	/**
+	* Gets the current thermal status.
+	*
+	* Available since API level 30.
+	*
+	* @param manager The manager instance to use to query the thermal status.
+	* Acquired via {@link AThermal_acquireManager}.
+	*
+	* @return current thermal status, ATHERMAL_STATUS_ERROR on failure.
+	*/
+	AThermal_getCurrentThermalStatus :: proc(manager: ^AThermalManager) -> AThermalStatus ---
+
+	/**
+	* Register the thermal status listener for thermal status change.
+	*
+	* Available since API level 30.
+	*
+	* @param manager The manager instance to use to register.
+	* Acquired via {@link AThermal_acquireManager}.
+	* @param callback The callback function to be called when thermal status updated.
+	* @param data The data pointer to be passed when callback is called.
+	*
+	* @return 0 on success
+	*         EINVAL if the listener and data pointer were previously added and not removed.
+	*         EPERM if the required permission is not held.
+	*         EPIPE if communication with the system service has failed.
+	*/
+	AThermal_registerThermalStatusListener :: proc(manager: ^AThermalManager, callback: AThermal_StatusCallback, data: rawptr) -> i32 ---
+
+	/**
+	* Unregister the thermal status listener previously resgistered.
+	*
+	* Available since API level 30.
+	*
+	* @param manager The manager instance to use to unregister.
+	* Acquired via {@link AThermal_acquireManager}.
+	* @param callback The callback function to be called when thermal status updated.
+	* @param data The data pointer to be passed when callback is called.
+	*
+	* @return 0 on success
+	*         EINVAL if the listener and data pointer were not previously added.
+	*         EPERM if the required permission is not held.
+	*         EPIPE if communication with the system service has failed.
+	*/
+	AThermal_unregisterThermalStatusListener :: proc(manager: ^AThermalManager, callback: AThermal_StatusCallback, data: rawptr) -> i32 ---
+
+	/**
+	* Provides an estimate of how much thermal headroom the device currently has before
+	* hitting severe throttling.
+	*
+	* Note that this only attempts to track the headroom of slow-moving sensors, such as
+	* the skin temperature sensor. This means that there is no benefit to calling this function
+	* more frequently than about once per second, and attempted to call significantly
+	* more frequently may result in the function returning {@code NaN}.
+	*
+	* In addition, in order to be able to provide an accurate forecast, the system does
+	* not attempt to forecast until it has multiple temperature samples from which to
+	* extrapolate. This should only take a few seconds from the time of the first call,
+	* but during this time, no forecasting will occur, and the current headroom will be
+	* returned regardless of the value of {@code forecastSeconds}.
+	*
+	* The value returned is a non-negative float that represents how much of the thermal envelope
+	* is in use (or is forecasted to be in use). A value of 1.0 indicates that the device is
+	* (or will be) throttled at {@link #ATHERMAL_STATUS_SEVERE}. Such throttling can affect the
+	* CPU, GPU, and other subsystems. Values may exceed 1.0, but there is no implied mapping
+	* to specific thermal levels beyond that point. This means that values greater than 1.0
+	* may correspond to {@link #ATHERMAL_STATUS_SEVERE}, but may also represent heavier throttling.
+	*
+	* A value of 0.0 corresponds to a fixed distance from 1.0, but does not correspond to any
+	* particular thermal status or temperature. Values on (0.0, 1.0] may be expected to scale
+	* linearly with temperature, though temperature changes over time are typically not linear.
+	* Negative values will be clamped to 0.0 before returning.
+	*
+	* Available since API level 31.
+	*
+	* @param manager The manager instance to use.
+	*                Acquired via {@link AThermal_acquireManager}.
+	* @param forecastSeconds how many seconds into the future to forecast. Given that device
+	*                        conditions may change at any time, forecasts from further in the
+	*                        future will likely be less accurate than forecasts in the near future.
+	* @return a value greater than equal to 0.0, where 1.0 indicates the SEVERE throttling threshold,
+	*         as described above. Returns NaN if the device does not support this functionality or
+	*         if this function is called significantly faster than once per second.
+	*/
+	AThermal_getThermalHeadroom :: proc(manager: ^AThermalManager, forecastSeconds: i32) -> f32 ---
+}

trace.odin

@@ -0,0 +1,72 @@
+//+build android
+package android
+
+foreign import android "system:android"
+
+foreign android {
+	/**
+	 * Returns true if tracing is enabled. Use this to avoid expensive computation only necessary
+	 * when tracing is enabled.
+	 *
+	 * Available since API level 23.
+	 */
+	ATrace_isEnabled :: proc() -> bool ---
+
+	/**
+	 * Writes a tracing message to indicate that the given section of code has begun. This call must be
+	 * followed by a corresponding call to {@link ATrace_endSection} on the same thread.
+	 *
+	 * Note: At this time the vertical bar character '|' and newline character '\\n' are used internally
+	 * by the tracing mechanism. If \p sectionName contains these characters they will be replaced with a
+	 * space character in the trace.
+	 *
+	 * Available since API level 23.
+	 */
+	ATrace_beginSection :: proc(sectionName: cstring) ---
+
+	/**
+	 * Writes a tracing message to indicate that a given section of code has ended. This call must be
+	 * preceeded by a corresponding call to {@link ATrace_beginSection} on the same thread. Calling this method
+	 * will mark the end of the most recently begun section of code, so care must be taken to ensure
+	 * that {@link ATrace_beginSection}/{@link ATrace_endSection} pairs are properly nested and called from the same thread.
+	 *
+	 * Available since API level 23.
+	 */
+	ATrace_endSection :: proc() ---
+
+	/**
+	 * Writes a trace message to indicate that a given section of code has
+	 * begun. Must be followed by a call to {@link ATrace_endAsyncSection} with the same
+	 * methodName and cookie. Unlike {@link ATrace_beginSection} and {@link ATrace_endSection},
+	 * asynchronous events do not need to be nested. The name and cookie used to
+	 * begin an event must be used to end it.
+	 *
+	 * Available since API level 29.
+	 *
+	 * \param sectionName The method name to appear in the trace.
+	 * \param cookie Unique identifier for distinguishing simultaneous events
+	 */
+	ATrace_beginAsyncSection :: proc(sectionName: cstring, cookie: i32) ---
+
+	/**
+	 * Writes a trace message to indicate that the current method has ended.
+	 * Must be called exactly once for each call to {@link ATrace_beginAsyncSection}
+	 * using the same name and cookie.
+	 *
+	 * Available since API level 29.
+	 *
+	 * \param sectionName The method name to appear in the trace.
+	 * \param cookie Unique identifier for distinguishing simultaneous events
+	 */
+	ATrace_endAsyncSection :: proc(sectionName: cstring, cookie: i32) ---
+
+	/**
+	 * Writes trace message to indicate the value of a given counter.
+	 *
+	 * Available since API level 29.
+	 *
+	 * \param counterName The counter name to appear in the trace.
+	 * \param counterValue The counter value.
+	 */
+	ATrace_setCounter :: proc(counterName: cstring, counterValue: i64) ---
+}