* Convenience wrapper for a file descriptor. */

* Represents one strong pointer to an AIBinder object. */

A segment of a writable parcel, used for [`BorrowedParcel::sized_write`].

* Represents a local or remote object which can be used for IPC or which can itself be sent. * * This object has a refcount associated with it and w

* Represents a type of AIBinder object which can be sent out. */

* Represents a handle on a death notification. See AIBinder_linkToDeath/AIBinder_unlinkToDeath. */

* The AIBinder object associated with this can be retrieved if it is still alive so that it can be * re-used. The intention of this is to enable the

* Represents a registration to servicemanager which can be cleared anytime. */

* This is a helper class that encapsulates a standard way to keep track of and chain binder errors * along with service specific errors. * * It is

Trait for transparent Rust wrappers around android C++ native types. The pointer return by this trait's methods should be immediately passed to C++ a

An object that can be associate with an [`InterfaceClass`].

A thread pool for running binder transactions.

A runtime for executing an async binder server.

A struct whose instances can be restored from a [`Parcel`]. Might be able to hook this up as a serde backend in the future?

Helper trait for types that can be deserialized as arrays. Defaults to calling Deserialize::deserialize() manually for every element, but can be overr

Helper trait for types that can be nullable when deserialized.

Expose exception codes from anonymous enum in binder_status.h

Interface for transforming a generic SpIBinder into a specific remote interface trait. # Example For Binder interface `IFoo`, the following implemen

Async trivial testing binder interface

Interface of binder local or remote objects. This trait corresponds to the parts of the interface of the C++ `IBinder` class which are public.

Internal interface of binder local or remote objects for making transactions. This trait corresponds to the parts of the interface of the C++ `IBinde

Trivial testing binder interface

Trivial testing binder interface

Super-trait for Binder interfaces. This trait allows conversion of a Binder interface trait object into an IBinder object for IPC calls. All Binder r

Super-trait for Binder parcelables. This trait is equivalent `android::Parcelable` in C++, and defines a common interface that all parcelables need t

Metadata that `ParcelableHolder` needs for all parcelables. The compiler auto-generates implementations of this trait for AIDL parcelables.

Static utility functions to manage Binder process state.

Generic interface to remote binder objects. Corresponds to the C++ `BpInterface` class.

A segment of a readable parcel, used for [`Parcel::sized_read`].

A local service that can be remotable via Binder. An object that implement this interface made be made into a Binder service via `Binder::new(object)

* Convenience wrapper. See AIBinder_DeathRecipient. */

* Convenience wrapper. See AIBinder_Weak. */

* Convenience wrapper. See AParcel. */

A struct whose instances can be written to a [`Parcel`]. Might be able to hook this up as a serde backend in the future?

Helper trait for types that can be serialized as arrays. Defaults to calling Serialize::serialize() manually for every element, but can be overridden

Helper trait for types that can be nullable when serialized. We really need this trait instead of implementing `Serialize for Option<T>` because of th

A strong reference to a Binder remote object. This struct encapsulates the generic C++ `sp<IBinder>` class. This wrapper is untyped; typed interface

Safety: `Status` always contains a owning pointer to a valid `AStatus`. The lifetime of the contained pointer is the same as the `Status` object. High

Expose error codes from anonymous enum in binder_status.h

Strong reference to a binder object

Static utility functions to manage Binder thread state.

Implemented by sync interfaces to specify what the associated async interface is. Generic to handle the fact that async interfaces are generic over a

Implemented by async interfaces to specify what the associated sync interface is. The binder in any object implementing this trait should be compatib

Use the Tokio `spawn_blocking` pool with AIDL.

Wrapper around Tokio runtime types for providing a runtime to a binder server.

A weak reference to a Binder remote object. This struct encapsulates the generic C++ `wp<IBinder>` class. This wrapper is untyped; typed interface ac