summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libs/binder/rust/binder_tokio/lib.rs12
-rw-r--r--libs/binder/rust/src/binder.rs106
-rw-r--r--libs/binder/rust/src/lib.rs63
-rw-r--r--libs/binder/rust/src/parcel/parcelable.rs63
-rw-r--r--libs/binder/rust/src/parcel/parcelable_holder.rs12
-rw-r--r--libs/binder/rust/tests/integration.rs84
-rw-r--r--libs/binder/rust/tests/serialization.rs9
7 files changed, 171 insertions, 178 deletions
diff --git a/libs/binder/rust/binder_tokio/lib.rs b/libs/binder/rust/binder_tokio/lib.rs
index 9dcef4260e..47dcdc2bc3 100644
--- a/libs/binder/rust/binder_tokio/lib.rs
+++ b/libs/binder/rust/binder_tokio/lib.rs
@@ -28,8 +28,8 @@
//!
//! [`Tokio`]: crate::Tokio
-use binder::{BinderAsyncPool, BoxFuture, FromIBinder, StatusCode, Strong};
-use binder::binder_impl::BinderAsyncRuntime;
+use binder::public_api::{BinderAsyncPool, BoxFuture, Strong};
+use binder::{FromIBinder, StatusCode, BinderAsyncRuntime};
use std::future::Future;
/// Retrieve an existing service for a particular interface, sleeping for a few
@@ -37,12 +37,12 @@ use std::future::Future;
pub async fn get_interface<T: FromIBinder + ?Sized + 'static>(name: &str) -> Result<Strong<T>, StatusCode> {
if binder::is_handling_transaction() {
// See comment in the BinderAsyncPool impl.
- return binder::get_interface::<T>(name);
+ return binder::public_api::get_interface::<T>(name);
}
let name = name.to_string();
let res = tokio::task::spawn_blocking(move || {
- binder::get_interface::<T>(&name)
+ binder::public_api::get_interface::<T>(&name)
}).await;
// The `is_panic` branch is not actually reachable in Android as we compile
@@ -61,12 +61,12 @@ pub async fn get_interface<T: FromIBinder + ?Sized + 'static>(name: &str) -> Res
pub async fn wait_for_interface<T: FromIBinder + ?Sized + 'static>(name: &str) -> Result<Strong<T>, StatusCode> {
if binder::is_handling_transaction() {
// See comment in the BinderAsyncPool impl.
- return binder::wait_for_interface::<T>(name);
+ return binder::public_api::wait_for_interface::<T>(name);
}
let name = name.to_string();
let res = tokio::task::spawn_blocking(move || {
- binder::wait_for_interface::<T>(&name)
+ binder::public_api::wait_for_interface::<T>(&name)
}).await;
// The `is_panic` branch is not actually reachable in Android as we compile
diff --git a/libs/binder/rust/src/binder.rs b/libs/binder/rust/src/binder.rs
index 7895a7293d..4d6b294000 100644
--- a/libs/binder/rust/src/binder.rs
+++ b/libs/binder/rust/src/binder.rs
@@ -536,13 +536,13 @@ impl<I: FromIBinder + ?Sized> Eq for Weak<I> {}
/// ```
macro_rules! binder_fn_get_class {
($class:ty) => {
- binder_fn_get_class!($crate::binder_impl::InterfaceClass::new::<$class>());
+ binder_fn_get_class!($crate::InterfaceClass::new::<$class>());
};
($constructor:expr) => {
- fn get_class() -> $crate::binder_impl::InterfaceClass {
+ fn get_class() -> $crate::InterfaceClass {
static CLASS_INIT: std::sync::Once = std::sync::Once::new();
- static mut CLASS: Option<$crate::binder_impl::InterfaceClass> = None;
+ static mut CLASS: Option<$crate::InterfaceClass> = None;
CLASS_INIT.call_once(|| unsafe {
// Safety: This assignment is guarded by the `CLASS_INIT` `Once`
@@ -772,7 +772,7 @@ macro_rules! declare_binder_interface {
native: $native($on_transact),
proxy: $proxy {},
$(async: $async_interface,)?
- stability: $crate::binder_impl::Stability::default(),
+ stability: $crate::Stability::default(),
}
}
};
@@ -811,7 +811,7 @@ macro_rules! declare_binder_interface {
$($fname: $fty = $finit),*
},
$(async: $async_interface,)?
- stability: $crate::binder_impl::Stability::default(),
+ stability: $crate::Stability::default(),
}
}
};
@@ -828,9 +828,9 @@ macro_rules! declare_binder_interface {
} => {
$crate::declare_binder_interface! {
$interface[$descriptor] {
- @doc[concat!("A binder [`Remotable`]($crate::binder_impl::Remotable) that holds an [`", stringify!($interface), "`] object.")]
+ @doc[concat!("A binder [`Remotable`]($crate::Remotable) that holds an [`", stringify!($interface), "`] object.")]
native: $native($on_transact),
- @doc[concat!("A binder [`Proxy`]($crate::binder_impl::Proxy) that holds an [`", stringify!($interface), "`] remote interface.")]
+ @doc[concat!("A binder [`Proxy`]($crate::Proxy) that holds an [`", stringify!($interface), "`] remote interface.")]
proxy: $proxy {
$($fname: $fty = $finit),*
},
@@ -867,7 +867,7 @@ macro_rules! declare_binder_interface {
}
}
- impl $crate::binder_impl::Proxy for $proxy
+ impl $crate::Proxy for $proxy
where
$proxy: $interface,
{
@@ -875,7 +875,7 @@ macro_rules! declare_binder_interface {
$descriptor
}
- fn from_binder(mut binder: $crate::SpIBinder) -> std::result::Result<Self, $crate::StatusCode> {
+ fn from_binder(mut binder: $crate::SpIBinder) -> $crate::Result<Self> {
Ok(Self { binder, $($fname: $finit),* })
}
}
@@ -887,19 +887,19 @@ macro_rules! declare_binder_interface {
impl $native {
/// Create a new binder service.
pub fn new_binder<T: $interface + Sync + Send + 'static>(inner: T, features: $crate::BinderFeatures) -> $crate::Strong<dyn $interface> {
- let mut binder = $crate::binder_impl::Binder::new_with_stability($native(Box::new(inner)), $stability);
+ let mut binder = $crate::Binder::new_with_stability($native(Box::new(inner)), $stability);
#[cfg(not(android_vndk))]
- $crate::binder_impl::IBinderInternal::set_requesting_sid(&mut binder, features.set_requesting_sid);
+ $crate::IBinderInternal::set_requesting_sid(&mut binder, features.set_requesting_sid);
$crate::Strong::new(Box::new(binder))
}
}
- impl $crate::binder_impl::Remotable for $native {
+ impl $crate::Remotable for $native {
fn get_descriptor() -> &'static str {
$descriptor
}
- fn on_transact(&self, code: $crate::binder_impl::TransactionCode, data: &$crate::binder_impl::BorrowedParcel<'_>, reply: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ fn on_transact(&self, code: $crate::TransactionCode, data: &$crate::BorrowedParcel<'_>, reply: &mut $crate::BorrowedParcel<'_>) -> $crate::Result<()> {
match $on_transact(&*self.0, code, data, reply) {
// The C++ backend converts UNEXPECTED_NULL into an exception
Err($crate::StatusCode::UNEXPECTED_NULL) => {
@@ -913,19 +913,19 @@ macro_rules! declare_binder_interface {
}
}
- fn on_dump(&self, file: &std::fs::File, args: &[&std::ffi::CStr]) -> std::result::Result<(), $crate::StatusCode> {
+ fn on_dump(&self, file: &std::fs::File, args: &[&std::ffi::CStr]) -> $crate::Result<()> {
self.0.dump(file, args)
}
- fn get_class() -> $crate::binder_impl::InterfaceClass {
+ fn get_class() -> $crate::InterfaceClass {
static CLASS_INIT: std::sync::Once = std::sync::Once::new();
- static mut CLASS: Option<$crate::binder_impl::InterfaceClass> = None;
+ static mut CLASS: Option<$crate::InterfaceClass> = None;
CLASS_INIT.call_once(|| unsafe {
// Safety: This assignment is guarded by the `CLASS_INIT` `Once`
// variable, and therefore is thread-safe, as it can only occur
// once.
- CLASS = Some($crate::binder_impl::InterfaceClass::new::<$crate::binder_impl::Binder<$native>>());
+ CLASS = Some($crate::InterfaceClass::new::<$crate::Binder<$native>>());
});
unsafe {
// Safety: The `CLASS` variable can only be mutated once, above,
@@ -936,25 +936,25 @@ macro_rules! declare_binder_interface {
}
impl $crate::FromIBinder for dyn $interface {
- fn try_from(mut ibinder: $crate::SpIBinder) -> std::result::Result<$crate::Strong<dyn $interface>, $crate::StatusCode> {
- use $crate::binder_impl::AssociateClass;
+ fn try_from(mut ibinder: $crate::SpIBinder) -> $crate::Result<$crate::Strong<dyn $interface>> {
+ use $crate::AssociateClass;
let existing_class = ibinder.get_class();
if let Some(class) = existing_class {
- if class != <$native as $crate::binder_impl::Remotable>::get_class() &&
- class.get_descriptor() == <$native as $crate::binder_impl::Remotable>::get_descriptor()
+ if class != <$native as $crate::Remotable>::get_class() &&
+ class.get_descriptor() == <$native as $crate::Remotable>::get_descriptor()
{
// The binder object's descriptor string matches what we
// expect. We still need to treat this local or already
// associated object as remote, because we can't cast it
// into a Rust service object without a matching class
// pointer.
- return Ok($crate::Strong::new(Box::new(<$proxy as $crate::binder_impl::Proxy>::from_binder(ibinder)?)));
+ return Ok($crate::Strong::new(Box::new(<$proxy as $crate::Proxy>::from_binder(ibinder)?)));
}
}
- if ibinder.associate_class(<$native as $crate::binder_impl::Remotable>::get_class()) {
- let service: std::result::Result<$crate::binder_impl::Binder<$native>, $crate::StatusCode> =
+ if ibinder.associate_class(<$native as $crate::Remotable>::get_class()) {
+ let service: $crate::Result<$crate::Binder<$native>> =
std::convert::TryFrom::try_from(ibinder.clone());
if let Ok(service) = service {
// We were able to associate with our expected class and
@@ -962,7 +962,7 @@ macro_rules! declare_binder_interface {
return Ok($crate::Strong::new(Box::new(service)));
} else {
// Service is remote
- return Ok($crate::Strong::new(Box::new(<$proxy as $crate::binder_impl::Proxy>::from_binder(ibinder)?)));
+ return Ok($crate::Strong::new(Box::new(<$proxy as $crate::Proxy>::from_binder(ibinder)?)));
}
}
@@ -970,18 +970,18 @@ macro_rules! declare_binder_interface {
}
}
- impl $crate::binder_impl::Serialize for dyn $interface + '_
+ impl $crate::parcel::Serialize for dyn $interface + '_
where
dyn $interface: $crate::Interface
{
- fn serialize(&self, parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
let binder = $crate::Interface::as_binder(self);
parcel.write(&binder)
}
}
- impl $crate::binder_impl::SerializeOption for dyn $interface + '_ {
- fn serialize_option(this: Option<&Self>, parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ impl $crate::parcel::SerializeOption for dyn $interface + '_ {
+ fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
parcel.write(&this.map($crate::Interface::as_binder))
}
}
@@ -1004,25 +1004,25 @@ macro_rules! declare_binder_interface {
$(
// Async interface trait implementations.
impl<P: $crate::BinderAsyncPool> $crate::FromIBinder for dyn $async_interface<P> {
- fn try_from(mut ibinder: $crate::SpIBinder) -> std::result::Result<$crate::Strong<dyn $async_interface<P>>, $crate::StatusCode> {
- use $crate::binder_impl::AssociateClass;
+ fn try_from(mut ibinder: $crate::SpIBinder) -> $crate::Result<$crate::Strong<dyn $async_interface<P>>> {
+ use $crate::AssociateClass;
let existing_class = ibinder.get_class();
if let Some(class) = existing_class {
- if class != <$native as $crate::binder_impl::Remotable>::get_class() &&
- class.get_descriptor() == <$native as $crate::binder_impl::Remotable>::get_descriptor()
+ if class != <$native as $crate::Remotable>::get_class() &&
+ class.get_descriptor() == <$native as $crate::Remotable>::get_descriptor()
{
// The binder object's descriptor string matches what we
// expect. We still need to treat this local or already
// associated object as remote, because we can't cast it
// into a Rust service object without a matching class
// pointer.
- return Ok($crate::Strong::new(Box::new(<$proxy as $crate::binder_impl::Proxy>::from_binder(ibinder)?)));
+ return Ok($crate::Strong::new(Box::new(<$proxy as $crate::Proxy>::from_binder(ibinder)?)));
}
}
- if ibinder.associate_class(<$native as $crate::binder_impl::Remotable>::get_class()) {
- let service: std::result::Result<$crate::binder_impl::Binder<$native>, $crate::StatusCode> =
+ if ibinder.associate_class(<$native as $crate::Remotable>::get_class()) {
+ let service: $crate::Result<$crate::Binder<$native>> =
std::convert::TryFrom::try_from(ibinder.clone());
if let Ok(service) = service {
// We were able to associate with our expected class and
@@ -1031,7 +1031,7 @@ macro_rules! declare_binder_interface {
//return Ok($crate::Strong::new(Box::new(service)));
} else {
// Service is remote
- return Ok($crate::Strong::new(Box::new(<$proxy as $crate::binder_impl::Proxy>::from_binder(ibinder)?)));
+ return Ok($crate::Strong::new(Box::new(<$proxy as $crate::Proxy>::from_binder(ibinder)?)));
}
}
@@ -1039,15 +1039,15 @@ macro_rules! declare_binder_interface {
}
}
- impl<P: $crate::BinderAsyncPool> $crate::binder_impl::Serialize for dyn $async_interface<P> + '_ {
- fn serialize(&self, parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ impl<P: $crate::BinderAsyncPool> $crate::parcel::Serialize for dyn $async_interface<P> + '_ {
+ fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
let binder = $crate::Interface::as_binder(self);
parcel.write(&binder)
}
}
- impl<P: $crate::BinderAsyncPool> $crate::binder_impl::SerializeOption for dyn $async_interface<P> + '_ {
- fn serialize_option(this: Option<&Self>, parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ impl<P: $crate::BinderAsyncPool> $crate::parcel::SerializeOption for dyn $async_interface<P> + '_ {
+ fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
parcel.write(&this.map($crate::Interface::as_binder))
}
}
@@ -1067,11 +1067,11 @@ macro_rules! declare_binder_interface {
}
}
- impl<P: $crate::BinderAsyncPool> $crate::binder_impl::ToAsyncInterface<P> for dyn $interface {
+ impl<P: $crate::BinderAsyncPool> $crate::ToAsyncInterface<P> for dyn $interface {
type Target = dyn $async_interface<P>;
}
- impl<P: $crate::BinderAsyncPool> $crate::binder_impl::ToSyncInterface for dyn $async_interface<P> {
+ impl<P: $crate::BinderAsyncPool> $crate::ToSyncInterface for dyn $async_interface<P> {
type Target = dyn $interface;
}
)?
@@ -1103,29 +1103,29 @@ macro_rules! declare_binder_enum {
}
}
- impl $crate::binder_impl::Serialize for $enum {
- fn serialize(&self, parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ impl $crate::parcel::Serialize for $enum {
+ fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
parcel.write(&self.0)
}
}
- impl $crate::binder_impl::SerializeArray for $enum {
- fn serialize_array(slice: &[Self], parcel: &mut $crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), $crate::StatusCode> {
+ impl $crate::parcel::SerializeArray for $enum {
+ fn serialize_array(slice: &[Self], parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {
let v: Vec<$backing> = slice.iter().map(|x| x.0).collect();
- <$backing as $crate::binder_impl::SerializeArray>::serialize_array(&v[..], parcel)
+ <$backing as binder::parcel::SerializeArray>::serialize_array(&v[..], parcel)
}
}
- impl $crate::binder_impl::Deserialize for $enum {
- fn deserialize(parcel: &$crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<Self, $crate::StatusCode> {
+ impl $crate::parcel::Deserialize for $enum {
+ fn deserialize(parcel: &$crate::parcel::BorrowedParcel<'_>) -> $crate::Result<Self> {
parcel.read().map(Self)
}
}
- impl $crate::binder_impl::DeserializeArray for $enum {
- fn deserialize_array(parcel: &$crate::binder_impl::BorrowedParcel<'_>) -> std::result::Result<Option<Vec<Self>>, $crate::StatusCode> {
+ impl $crate::parcel::DeserializeArray for $enum {
+ fn deserialize_array(parcel: &$crate::parcel::BorrowedParcel<'_>) -> $crate::Result<Option<Vec<Self>>> {
let v: Option<Vec<$backing>> =
- <$backing as $crate::binder_impl::DeserializeArray>::deserialize_array(parcel)?;
+ <$backing as binder::parcel::DeserializeArray>::deserialize_array(parcel)?;
Ok(v.map(|v| v.into_iter().map(Self).collect()))
}
}
diff --git a/libs/binder/rust/src/lib.rs b/libs/binder/rust/src/lib.rs
index 1d7de98c0d..20d90f7b3c 100644
--- a/libs/binder/rust/src/lib.rs
+++ b/libs/binder/rust/src/lib.rs
@@ -101,50 +101,45 @@ mod binder;
mod binder_async;
mod error;
mod native;
-mod parcel;
mod state;
use binder_ndk_sys as sys;
-pub use binder::{BinderFeatures, FromIBinder, IBinder, Interface, Strong, Weak};
-pub use crate::binder_async::{BinderAsyncPool, BoxFuture};
-pub use error::{ExceptionCode, Status, StatusCode};
-pub use native::{
- add_service, force_lazy_services_persist, is_handling_transaction, register_lazy_service,
-};
-pub use parcel::{ParcelFileDescriptor, Parcelable, ParcelableHolder};
-pub use proxy::{
- get_interface, get_service, wait_for_interface, wait_for_service, DeathRecipient, SpIBinder,
- WpIBinder,
+pub mod parcel;
+
+pub use crate::binder::{
+ BinderFeatures, FromIBinder, IBinder, IBinderInternal, Interface, InterfaceClass, Remotable,
+ Stability, Strong, ToAsyncInterface, ToSyncInterface, TransactionCode, TransactionFlags, Weak,
+ FIRST_CALL_TRANSACTION, FLAG_CLEAR_BUF, FLAG_ONEWAY, FLAG_PRIVATE_LOCAL, LAST_CALL_TRANSACTION,
};
+pub use crate::binder_async::{BoxFuture, BinderAsyncPool, BinderAsyncRuntime};
+pub use error::{status_t, ExceptionCode, Result, Status, StatusCode};
+pub use native::{add_service, force_lazy_services_persist, is_handling_transaction, register_lazy_service, Binder};
+pub use parcel::{BorrowedParcel, Parcel};
+pub use proxy::{get_interface, get_service, wait_for_interface, wait_for_service};
+pub use proxy::{AssociateClass, DeathRecipient, Proxy, SpIBinder, WpIBinder};
pub use state::{ProcessState, ThreadState};
-/// Binder result containing a [`Status`] on error.
-pub type Result<T> = std::result::Result<T, Status>;
-
-/// Advanced Binder APIs needed internally by AIDL or when manually using Binder
-/// without AIDL.
-pub mod binder_impl {
- pub use crate::binder::{
- IBinderInternal, InterfaceClass, Remotable, Stability, ToAsyncInterface, ToSyncInterface,
- TransactionCode, TransactionFlags, FIRST_CALL_TRANSACTION, FLAG_CLEAR_BUF, FLAG_ONEWAY,
- FLAG_PRIVATE_LOCAL, LAST_CALL_TRANSACTION,
- };
- pub use crate::binder_async::BinderAsyncRuntime;
- pub use crate::error::status_t;
- pub use crate::native::Binder;
- pub use crate::parcel::{
- BorrowedParcel, Deserialize, DeserializeArray, DeserializeOption, Parcel,
- ParcelableMetadata, Serialize, SerializeArray, SerializeOption, NON_NULL_PARCELABLE_FLAG,
- NULL_PARCELABLE_FLAG,
- };
- pub use crate::proxy::{AssociateClass, Proxy};
-}
-
/// Unstable, in-development API that only allowlisted clients are allowed to use.
-#[doc(hidden)]
pub mod unstable_api {
pub use crate::binder::AsNative;
pub use crate::proxy::unstable_api::new_spibinder;
pub use crate::sys::AIBinder;
}
+
+/// The public API usable outside AIDL-generated interface crates.
+pub mod public_api {
+ pub use super::parcel::{ParcelFileDescriptor, ParcelableHolder};
+ pub use super::{
+ add_service, force_lazy_services_persist, get_interface, register_lazy_service,
+ wait_for_interface,
+ };
+ pub use super::{
+ BinderAsyncPool, BinderFeatures, BoxFuture, DeathRecipient, ExceptionCode, IBinder,
+ Interface, ProcessState, SpIBinder, Status, StatusCode, Strong, ThreadState, Weak,
+ WpIBinder,
+ };
+
+ /// Binder result containing a [`Status`] on error.
+ pub type Result<T> = std::result::Result<T, Status>;
+}
diff --git a/libs/binder/rust/src/parcel/parcelable.rs b/libs/binder/rust/src/parcel/parcelable.rs
index 0c7e48df0c..61f88b6cce 100644
--- a/libs/binder/rust/src/parcel/parcelable.rs
+++ b/libs/binder/rust/src/parcel/parcelable.rs
@@ -802,32 +802,35 @@ impl<T: DeserializeOption> Deserialize for Option<T> {
#[macro_export]
macro_rules! impl_serialize_for_parcelable {
($parcelable:ident) => {
- impl $crate::binder_impl::Serialize for $parcelable {
+ impl $crate::parcel::Serialize for $parcelable {
fn serialize(
&self,
- parcel: &mut $crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<(), $crate::StatusCode> {
- <Self as $crate::binder_impl::SerializeOption>::serialize_option(Some(self), parcel)
+ parcel: &mut $crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<()> {
+ <Self as $crate::parcel::SerializeOption>::serialize_option(
+ Some(self),
+ parcel,
+ )
}
}
- impl $crate::binder_impl::SerializeArray for $parcelable {}
+ impl $crate::parcel::SerializeArray for $parcelable {}
- impl $crate::binder_impl::SerializeOption for $parcelable {
+ impl $crate::parcel::SerializeOption for $parcelable {
fn serialize_option(
this: Option<&Self>,
- parcel: &mut $crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<(), $crate::StatusCode> {
+ parcel: &mut $crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<()> {
if let Some(this) = this {
- use $crate::Parcelable;
- parcel.write(&$crate::binder_impl::NON_NULL_PARCELABLE_FLAG)?;
+ use $crate::parcel::Parcelable;
+ parcel.write(&$crate::parcel::NON_NULL_PARCELABLE_FLAG)?;
this.write_to_parcel(parcel)
} else {
- parcel.write(&$crate::binder_impl::NULL_PARCELABLE_FLAG)
+ parcel.write(&$crate::parcel::NULL_PARCELABLE_FLAG)
}
}
}
- };
+ }
}
/// Implement `Deserialize` trait and friends for a parcelable
@@ -839,54 +842,54 @@ macro_rules! impl_serialize_for_parcelable {
#[macro_export]
macro_rules! impl_deserialize_for_parcelable {
($parcelable:ident) => {
- impl $crate::binder_impl::Deserialize for $parcelable {
+ impl $crate::parcel::Deserialize for $parcelable {
fn deserialize(
- parcel: &$crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<Self, $crate::StatusCode> {
- $crate::binder_impl::DeserializeOption::deserialize_option(parcel)
+ parcel: &$crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<Self> {
+ $crate::parcel::DeserializeOption::deserialize_option(parcel)
.transpose()
.unwrap_or(Err($crate::StatusCode::UNEXPECTED_NULL))
}
fn deserialize_from(
&mut self,
- parcel: &$crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<(), $crate::StatusCode> {
+ parcel: &$crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<()> {
let status: i32 = parcel.read()?;
- if status == $crate::binder_impl::NULL_PARCELABLE_FLAG {
+ if status == $crate::parcel::NULL_PARCELABLE_FLAG {
Err($crate::StatusCode::UNEXPECTED_NULL)
} else {
- use $crate::Parcelable;
+ use $crate::parcel::Parcelable;
self.read_from_parcel(parcel)
}
}
}
- impl $crate::binder_impl::DeserializeArray for $parcelable {}
+ impl $crate::parcel::DeserializeArray for $parcelable {}
- impl $crate::binder_impl::DeserializeOption for $parcelable {
+ impl $crate::parcel::DeserializeOption for $parcelable {
fn deserialize_option(
- parcel: &$crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<Option<Self>, $crate::StatusCode> {
+ parcel: &$crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<Option<Self>> {
let mut result = None;
Self::deserialize_option_from(&mut result, parcel)?;
Ok(result)
}
fn deserialize_option_from(
this: &mut Option<Self>,
- parcel: &$crate::binder_impl::BorrowedParcel<'_>,
- ) -> std::result::Result<(), $crate::StatusCode> {
+ parcel: &$crate::parcel::BorrowedParcel<'_>,
+ ) -> $crate::Result<()> {
let status: i32 = parcel.read()?;
- if status == $crate::binder_impl::NULL_PARCELABLE_FLAG {
+ if status == $crate::parcel::NULL_PARCELABLE_FLAG {
*this = None;
Ok(())
} else {
- use $crate::Parcelable;
+ use $crate::parcel::Parcelable;
this.get_or_insert_with(Self::default)
.read_from_parcel(parcel)
}
}
}
- };
+ }
}
impl<T: Serialize> Serialize for Box<T> {
@@ -915,7 +918,7 @@ impl<T: DeserializeOption> DeserializeOption for Box<T> {
#[cfg(test)]
mod tests {
- use crate::parcel::Parcel;
+ use crate::Parcel;
use super::*;
#[test]
diff --git a/libs/binder/rust/src/parcel/parcelable_holder.rs b/libs/binder/rust/src/parcel/parcelable_holder.rs
index bc70ea6c30..b4282b2ec8 100644
--- a/libs/binder/rust/src/parcel/parcelable_holder.rs
+++ b/libs/binder/rust/src/parcel/parcelable_holder.rs
@@ -15,8 +15,8 @@
*/
use crate::binder::Stability;
-use crate::error::StatusCode;
-use crate::parcel::{BorrowedParcel, Parcel, Parcelable};
+use crate::error::{Result, StatusCode};
+use crate::parcel::{Parcel, BorrowedParcel, Parcelable};
use crate::{impl_deserialize_for_parcelable, impl_serialize_for_parcelable};
use downcast_rs::{impl_downcast, DowncastSync};
@@ -97,7 +97,7 @@ impl ParcelableHolder {
}
/// Set the parcelable contained in this `ParcelableHolder`.
- pub fn set_parcelable<T>(&mut self, p: Arc<T>) -> Result<(), StatusCode>
+ pub fn set_parcelable<T>(&mut self, p: Arc<T>) -> Result<()>
where
T: Any + Parcelable + ParcelableMetadata + std::fmt::Debug + Send + Sync,
{
@@ -126,7 +126,7 @@ impl ParcelableHolder {
/// * `Ok(None)` if the holder is empty or the descriptor does not match
/// * `Ok(Some(_))` if the object holds a parcelable of type `T`
/// with the correct descriptor
- pub fn get_parcelable<T>(&self) -> Result<Option<Arc<T>>, StatusCode>
+ pub fn get_parcelable<T>(&self) -> Result<Option<Arc<T>>>
where
T: Any + Parcelable + ParcelableMetadata + Default + std::fmt::Debug + Send + Sync,
{
@@ -180,7 +180,7 @@ impl_serialize_for_parcelable!(ParcelableHolder);
impl_deserialize_for_parcelable!(ParcelableHolder);
impl Parcelable for ParcelableHolder {
- fn write_to_parcel(&self, parcel: &mut BorrowedParcel<'_>) -> Result<(), StatusCode> {
+ fn write_to_parcel(&self, parcel: &mut BorrowedParcel<'_>) -> Result<()> {
parcel.write(&self.stability)?;
let mut data = self.data.lock().unwrap();
@@ -219,7 +219,7 @@ impl Parcelable for ParcelableHolder {
}
}
- fn read_from_parcel(&mut self, parcel: &BorrowedParcel<'_>) -> Result<(), StatusCode> {
+ fn read_from_parcel(&mut self, parcel: &BorrowedParcel<'_>) -> Result<()> {
self.stability = parcel.read()?;
let data_size: i32 = parcel.read()?;
diff --git a/libs/binder/rust/tests/integration.rs b/libs/binder/rust/tests/integration.rs
index 50daf1c0cc..80dc47682c 100644
--- a/libs/binder/rust/tests/integration.rs
+++ b/libs/binder/rust/tests/integration.rs
@@ -17,13 +17,11 @@
//! Rust Binder crate integration tests
use binder::{declare_binder_enum, declare_binder_interface};
-use binder::{BinderFeatures, Interface, StatusCode, ThreadState};
-// Import from internal API for testing only, do not use this module in
-// production.
-use binder::binder_impl::{
- Binder, BorrowedParcel, IBinderInternal, TransactionCode, FIRST_CALL_TRANSACTION,
+use binder::parcel::BorrowedParcel;
+use binder::{
+ Binder, BinderFeatures, IBinderInternal, Interface, StatusCode, ThreadState, TransactionCode,
+ FIRST_CALL_TRANSACTION,
};
-
use std::convert::{TryFrom, TryInto};
use std::ffi::CStr;
use std::fs::File;
@@ -122,7 +120,7 @@ impl TryFrom<u32> for TestTransactionCode {
}
impl Interface for TestService {
- fn dump(&self, _file: &File, args: &[&CStr]) -> Result<(), StatusCode> {
+ fn dump(&self, _file: &File, args: &[&CStr]) -> binder::Result<()> {
let mut dump_args = self.dump_args.lock().unwrap();
dump_args.extend(args.iter().map(|s| s.to_str().unwrap().to_owned()));
Ok(())
@@ -130,22 +128,22 @@ impl Interface for TestService {
}
impl ITest for TestService {
- fn test(&self) -> Result<String, StatusCode> {
+ fn test(&self) -> binder::Result<String> {
Ok(self.s.clone())
}
- fn get_dump_args(&self) -> Result<Vec<String>, StatusCode> {
+ fn get_dump_args(&self) -> binder::Result<Vec<String>> {
let args = self.dump_args.lock().unwrap().clone();
Ok(args)
}
- fn get_selinux_context(&self) -> Result<String, StatusCode> {
+ fn get_selinux_context(&self) -> binder::Result<String> {
let sid =
ThreadState::with_calling_sid(|sid| sid.map(|s| s.to_string_lossy().into_owned()));
sid.ok_or(StatusCode::UNEXPECTED_NULL)
}
- fn get_is_handling_transaction(&self) -> Result<bool, StatusCode> {
+ fn get_is_handling_transaction(&self) -> binder::Result<bool> {
Ok(binder::is_handling_transaction())
}
}
@@ -153,31 +151,31 @@ impl ITest for TestService {
/// Trivial testing binder interface
pub trait ITest: Interface {
/// Returns a test string
- fn test(&self) -> Result<String, StatusCode>;
+ fn test(&self) -> binder::Result<String>;
/// Return the arguments sent via dump
- fn get_dump_args(&self) -> Result<Vec<String>, StatusCode>;
+ fn get_dump_args(&self) -> binder::Result<Vec<String>>;
/// Returns the caller's SELinux context
- fn get_selinux_context(&self) -> Result<String, StatusCode>;
+ fn get_selinux_context(&self) -> binder::Result<String>;
/// Returns the value of calling `is_handling_transaction`.
- fn get_is_handling_transaction(&self) -> Result<bool, StatusCode>;
+ fn get_is_handling_transaction(&self) -> binder::Result<bool>;
}
/// Async trivial testing binder interface
pub trait IATest<P>: Interface {
/// Returns a test string
- fn test(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>>;
+ fn test(&self) -> binder::BoxFuture<'static, binder::Result<String>>;
/// Return the arguments sent via dump
- fn get_dump_args(&self) -> binder::BoxFuture<'static, Result<Vec<String>, StatusCode>>;
+ fn get_dump_args(&self) -> binder::BoxFuture<'static, binder::Result<Vec<String>>>;
/// Returns the caller's SELinux context
- fn get_selinux_context(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>>;
+ fn get_selinux_context(&self) -> binder::BoxFuture<'static, binder::Result<String>>;
/// Returns the value of calling `is_handling_transaction`.
- fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, Result<bool, StatusCode>>;
+ fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, binder::Result<bool>>;
}
declare_binder_interface! {
@@ -195,7 +193,7 @@ fn on_transact(
code: TransactionCode,
_data: &BorrowedParcel<'_>,
reply: &mut BorrowedParcel<'_>,
-) -> Result<(), StatusCode> {
+) -> binder::Result<()> {
match code.try_into()? {
TestTransactionCode::Test => reply.write(&service.test()?),
TestTransactionCode::GetDumpArgs => reply.write(&service.get_dump_args()?),
@@ -205,21 +203,21 @@ fn on_transact(
}
impl ITest for BpTest {
- fn test(&self) -> Result<String, StatusCode> {
+ fn test(&self) -> binder::Result<String> {
let reply =
self.binder
.transact(TestTransactionCode::Test as TransactionCode, 0, |_| Ok(()))?;
reply.read()
}
- fn get_dump_args(&self) -> Result<Vec<String>, StatusCode> {
+ fn get_dump_args(&self) -> binder::Result<Vec<String>> {
let reply =
self.binder
.transact(TestTransactionCode::GetDumpArgs as TransactionCode, 0, |_| Ok(()))?;
reply.read()
}
- fn get_selinux_context(&self) -> Result<String, StatusCode> {
+ fn get_selinux_context(&self) -> binder::Result<String> {
let reply = self.binder.transact(
TestTransactionCode::GetSelinuxContext as TransactionCode,
0,
@@ -228,7 +226,7 @@ impl ITest for BpTest {
reply.read()
}
- fn get_is_handling_transaction(&self) -> Result<bool, StatusCode> {
+ fn get_is_handling_transaction(&self) -> binder::Result<bool> {
let reply = self.binder.transact(
TestTransactionCode::GetIsHandlingTransaction as TransactionCode,
0,
@@ -239,7 +237,7 @@ impl ITest for BpTest {
}
impl<P: binder::BinderAsyncPool> IATest<P> for BpTest {
- fn test(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>> {
+ fn test(&self) -> binder::BoxFuture<'static, binder::Result<String>> {
let binder = self.binder.clone();
P::spawn(
move || binder.transact(TestTransactionCode::Test as TransactionCode, 0, |_| Ok(())),
@@ -247,7 +245,7 @@ impl<P: binder::BinderAsyncPool> IATest<P> for BpTest {
)
}
- fn get_dump_args(&self) -> binder::BoxFuture<'static, Result<Vec<String>, StatusCode>> {
+ fn get_dump_args(&self) -> binder::BoxFuture<'static, binder::Result<Vec<String>>> {
let binder = self.binder.clone();
P::spawn(
move || binder.transact(TestTransactionCode::GetDumpArgs as TransactionCode, 0, |_| Ok(())),
@@ -255,7 +253,7 @@ impl<P: binder::BinderAsyncPool> IATest<P> for BpTest {
)
}
- fn get_selinux_context(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>> {
+ fn get_selinux_context(&self) -> binder::BoxFuture<'static, binder::Result<String>> {
let binder = self.binder.clone();
P::spawn(
move || binder.transact(TestTransactionCode::GetSelinuxContext as TransactionCode, 0, |_| Ok(())),
@@ -263,7 +261,7 @@ impl<P: binder::BinderAsyncPool> IATest<P> for BpTest {
)
}
- fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, Result<bool, StatusCode>> {
+ fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, binder::Result<bool>> {
let binder = self.binder.clone();
P::spawn(
move || binder.transact(TestTransactionCode::GetIsHandlingTransaction as TransactionCode, 0, |_| Ok(())),
@@ -273,40 +271,40 @@ impl<P: binder::BinderAsyncPool> IATest<P> for BpTest {
}
impl ITest for Binder<BnTest> {
- fn test(&self) -> Result<String, StatusCode> {
+ fn test(&self) -> binder::Result<String> {
self.0.test()
}
- fn get_dump_args(&self) -> Result<Vec<String>, StatusCode> {
+ fn get_dump_args(&self) -> binder::Result<Vec<String>> {
self.0.get_dump_args()
}
- fn get_selinux_context(&self) -> Result<String, StatusCode> {
+ fn get_selinux_context(&self) -> binder::Result<String> {
self.0.get_selinux_context()
}
- fn get_is_handling_transaction(&self) -> Result<bool, StatusCode> {
+ fn get_is_handling_transaction(&self) -> binder::Result<bool> {
self.0.get_is_handling_transaction()
}
}
impl<P: binder::BinderAsyncPool> IATest<P> for Binder<BnTest> {
- fn test(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>> {
+ fn test(&self) -> binder::BoxFuture<'static, binder::Result<String>> {
let res = self.0.test();
Box::pin(async move { res })
}
- fn get_dump_args(&self) -> binder::BoxFuture<'static, Result<Vec<String>, StatusCode>> {
+ fn get_dump_args(&self) -> binder::BoxFuture<'static, binder::Result<Vec<String>>> {
let res = self.0.get_dump_args();
Box::pin(async move { res })
}
- fn get_selinux_context(&self) -> binder::BoxFuture<'static, Result<String, StatusCode>> {
+ fn get_selinux_context(&self) -> binder::BoxFuture<'static, binder::Result<String>> {
let res = self.0.get_selinux_context();
Box::pin(async move { res })
}
- fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, Result<bool, StatusCode>> {
+ fn get_is_handling_transaction(&self) -> binder::BoxFuture<'static, binder::Result<bool>> {
let res = self.0.get_is_handling_transaction();
Box::pin(async move { res })
}
@@ -327,7 +325,7 @@ fn on_transact_same_descriptor(
_code: TransactionCode,
_data: &BorrowedParcel<'_>,
_reply: &mut BorrowedParcel<'_>,
-) -> Result<(), StatusCode> {
+) -> binder::Result<()> {
Ok(())
}
@@ -365,12 +363,9 @@ mod tests {
use std::time::Duration;
use binder::{
- BinderFeatures, DeathRecipient, FromIBinder, IBinder, Interface, SpIBinder, StatusCode,
- Strong,
+ Binder, BinderFeatures, DeathRecipient, FromIBinder, IBinder, IBinderInternal, Interface,
+ SpIBinder, StatusCode, Strong,
};
- // Import from impl API for testing only, should not be necessary as long as
- // you are using AIDL.
- use binder::binder_impl::{Binder, IBinderInternal, TransactionCode};
use binder_tokio::Tokio;
@@ -748,7 +743,8 @@ mod tests {
let _process = ScopedServiceProcess::new(service_name);
let test_client: Strong<dyn ITest> =
- binder::get_interface(service_name).expect("Did not get test binder service");
+ binder::get_interface(service_name)
+ .expect("Did not get test binder service");
let mut remote = test_client.as_binder();
assert!(remote.is_binder_alive());
remote.ping_binder().expect("Could not ping remote service");
@@ -929,7 +925,7 @@ mod tests {
let service2 = service2.as_binder();
let parcel = service1.prepare_transact().unwrap();
- let res = service2.submit_transact(super::TestTransactionCode::Test as TransactionCode, parcel, 0);
+ let res = service2.submit_transact(super::TestTransactionCode::Test as binder::TransactionCode, parcel, 0);
match res {
Ok(_) => panic!("submit_transact should fail"),
diff --git a/libs/binder/rust/tests/serialization.rs b/libs/binder/rust/tests/serialization.rs
index b62da7be03..1fc761e2c8 100644
--- a/libs/binder/rust/tests/serialization.rs
+++ b/libs/binder/rust/tests/serialization.rs
@@ -18,12 +18,11 @@
//! access.
use binder::declare_binder_interface;
+use binder::parcel::ParcelFileDescriptor;
use binder::{
- BinderFeatures, ExceptionCode, Interface, ParcelFileDescriptor, SpIBinder, Status, StatusCode,
+ Binder, BinderFeatures, BorrowedParcel, ExceptionCode, Interface, Result, SpIBinder, Status,
+ StatusCode, TransactionCode,
};
-// Import from impl API for testing only, should not be necessary as long as you
-// are using AIDL.
-use binder::binder_impl::{BorrowedParcel, Binder, TransactionCode};
use std::ffi::{c_void, CStr, CString};
use std::sync::Once;
@@ -114,7 +113,7 @@ fn on_transact(
code: TransactionCode,
parcel: &BorrowedParcel<'_>,
reply: &mut BorrowedParcel<'_>,
-) -> Result<(), StatusCode> {
+) -> Result<()> {
match code {
bindings::Transaction_TEST_BOOL => {
assert_eq!(parcel.read::<bool>()?, true);
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-24 10:54:25 +0000