Merge changes from topic "tokio-test-utils" am: 1c57cd5510 (bbc57050) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_gatt.cpp

+7 −2

Original line number	Diff line number	Diff line
		@@ -2147,8 +2147,13 @@ static void gattServerSendIndicationNative(JNIEnv* env, jobject object,
		jbyte* array = env->GetByteArrayElements(val, 0);
		int val_len = env->GetArrayLength(val);

		if (bluetooth::gatt::is_connection_isolated(conn_id)) {
		auto data = ::rust::Slice<const uint8_t>((uint8_t*)array, val_len);
		bluetooth::gatt::send_indication(server_if, attr_handle, conn_id, data);
		} else {
		sGattIf->server->send_indication(server_if, attr_handle, conn_id,
		/confirm/ 1, (uint8_t*)array, val_len);
		}

		env->ReleaseByteArrayElements(val, array, JNI_ABORT);
		}

system/rust/Android.bp

+5 −1

Original line number	Diff line number	Diff line
		@@ -34,8 +34,8 @@ rust_defaults {
		"liblog_rust",
		"libanyhow",
		"libcxx",
		"libtokio",
		"libbt_common",
		"libbitflags",

		// needed to work around duplicate symbols
		// caused by bug in Soong
		@@ -71,6 +71,9 @@ rust_ffi_static {
		name: "libbluetooth_core_rs",
		crate_name: "bluetooth_core",
		defaults: ["libbluetooth_core_rs_defaults"],
		rustlibs: [
		"libtokio",
		],
		target: {
		android: {
		rustlibs: [
		@@ -85,6 +88,7 @@ rust_test_host {
		name: "libbluetooth_core_rs_test",
		defaults: ["libbluetooth_core_rs_defaults"],
		rustlibs: [
		"libtokio_for_test",
		"libtokio_test",
		],
		}

system/rust/Cargo.toml

+1 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@ bt_common = { path = "../gd/rust/common", default-features = false }
		# External dependencies
		# Note: source-of-truth is Android.bp, these are mirrored solely for IDE convenience
		anyhow = "1.0"
		bitflags = "1.3.2"
		log = "*"
		cxx = "*"
		android_logger = "*"

system/rust/src/core/mod.rs

+2 −0

Original line number	Diff line number	Diff line
		//! Shared data-types and utility methods go here.

		mod ffi;
		pub mod shared_box;
		pub mod shared_mutex;
		pub mod uuid;

		use std::{rc::Rc, thread};

system/rust/src/core/shared_box.rs

0 → 100644

+90 −0

Original line number	Diff line number	Diff line
		//! Wrapper around Rc<> to make ownership clearer
		//!
		//! The idea is to have ownership represented by a SharedBox<T>.
		//! Temporary ownership can be held using a WeakBox<T>, which should
		//! not be held across async points. This reduces the risk of accidental
		//! lifetime extension.

		use std::{
		ops::Deref,
		rc::{Rc, Weak},
		};

		/// A Box<> where static "weak" references to the contents can be taken,
		/// and fallibly upgraded at a later point. Unlike Rc<>, weak references
		/// cannot be upgraded back to owning references, so ownership remains clear
		/// and reference cycles avoided.
		#[derive(Debug)]
		pub struct SharedBox<T: ?Sized>(Rc<T>);

		impl<T> SharedBox<T> {
		/// Constructor
		pub fn new(t: T) -> Self {
		Self(t.into())
		}

		/// Produce a weak reference to the contents
		pub fn downgrade(&self) -> WeakBox<T> {
		WeakBox(Rc::downgrade(&self.0))
		}

		/// Produce an upgraded weak reference to the contents
		pub fn as_ref(&self) -> WeakBoxRef<T> {
		WeakBoxRef(self.0.deref(), Rc::downgrade(&self.0))
		}
		}

		impl<T> From<T> for SharedBox<T> {
		fn from(value: T) -> Self {
		Self(value.into())
		}
		}

		impl<T> Deref for SharedBox<T> {
		type Target = T;

		fn deref(&self) -> &Self::Target {
		self.0.deref()
		}
		}

		/// A weak reference to the contents within a SharedBox<>
		pub struct WeakBox<T>(Weak<T>);

		impl<T> WeakBox<T> {
		/// Fallibly upgrade to a strong reference, passed into the supplied closure.
		/// The strong reference is not passed into the closure to avoid accidental
		/// lifetime extension.
		///
		/// Note: reference-counting is used so that, if the passed-in closure drops
		/// the SharedBox<>, the strong reference remains safe. But please don't
		/// do that!
		pub fn with<U>(&self, f: impl FnOnce(Option<WeakBoxRef<T>>) -> U) -> U {
		f(self.0.upgrade().as_deref().map(\|x\| WeakBoxRef(x, self.0.clone())))
		}
		}

		impl<T> Clone for WeakBox<T> {
		fn clone(&self) -> Self {
		Self(self.0.clone())
		}
		}

		/// A strong reference to the contents within a SharedBox<>.
		pub struct WeakBoxRef<'a, T>(&'a T, Weak<T>);

		impl<'a, T> WeakBoxRef<'a, T> {
		/// Downgrade to a weak reference (with static lifetime) to the contents
		/// within the underlying SharedBox<>
		pub fn downgrade(&self) -> WeakBox<T> {
		WeakBox(self.1.clone())
		}
		}

		impl<'a, T> Deref for WeakBoxRef<'a, T> {
		type Target = T;

		fn deref(&self) -> &Self::Target {
		self.0
		}
		}