Merge "PAST: Unify callback format to match GD" (5696d4c5) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_gatt.cpp

+62 −63

Original line number	Diff line number	Diff line
		@@ -994,6 +994,64 @@ class JniScanningCallbacks : ScanningCallbacks {
		sCallbackEnv->CallVoidMethod(mCallbacksObj,
		method_onBatchScanThresholdCrossed, client_if);
		}

		void OnPeriodicSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle,
		uint8_t sid, uint8_t address_type,
		RawAddress address, uint8_t phy,
		uint16_t interval) override {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
		return;
		}
		ScopedLocalRef<jstring> addr(sCallbackEnv.get(),
		bdaddr2newjstr(sCallbackEnv.get(), &address));

		sCallbackEnv->CallVoidMethod(
		mPeriodicScanCallbacksObj, method_onSyncStarted, reg_id, sync_handle,
		sid, address_type, addr.get(), phy, interval, status);
		}

		void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi,
		uint8_t data_status,
		std::vector<uint8_t> data) override {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(data.size()));
		sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),
		(jbyte*)data.data());

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncReport,
		sync_handle, tx_power, rssi, data_status,
		jb.get());
		}

		void OnPeriodicSyncLost(uint16_t sync_handle) override {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,
		sync_handle);
		}

		void OnPeriodicSyncTransferred(int pa_source, uint8_t status,
		RawAddress address) override {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
		return;
		}
		ScopedLocalRef<jstring> addr(sCallbackEnv.get(),
		bdaddr2newjstr(sCallbackEnv.get(), &address));

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj,
		method_onSyncTransferredCallback, pa_source,
		status, addr.get());
		}
		};

		/**
		@@ -2251,54 +2309,12 @@ static void periodicScanCleanupNative(JNIEnv* env, jobject object) {
		}
		}

		static void onSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle,
		uint8_t sid, uint8_t address_type, RawAddress address,
		uint8_t phy, uint16_t interval) {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
		return;
		}
		ScopedLocalRef<jstring> addr(sCallbackEnv.get(),
		bdaddr2newjstr(sCallbackEnv.get(), &address));

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncStarted,
		reg_id, sync_handle, sid, address_type,
		addr.get(), phy, interval, status);
		}

		static void onSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi,
		uint8_t data_status, std::vector<uint8_t> data) {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(data.size()));
		sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),
		(jbyte*)data.data());

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncReport,
		sync_handle, tx_power, rssi, data_status,
		jb.get());
		}

		static void onSyncLost(uint16_t sync_handle) {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,
		sync_handle);
		}

		static void startSyncNative(JNIEnv* env, jobject object, jint sid,
		jstring address, jint skip, jint timeout,
		jint reg_id) {
		if (!sGattIf) return;
		sGattIf->scanner->StartSync(sid, str2addr(env, address), skip, timeout,
		base::Bind(&onSyncStarted, reg_id),
		base::Bind(&onSyncReport),
		base::Bind(&onSyncLost));
		reg_id);
		}

		static void stopSyncNative(JNIEnv* env, jobject object, jint sync_handle) {
		@@ -2312,37 +2328,20 @@ static void cancelSyncNative(JNIEnv* env, jobject object, jint sid,
		sGattIf->scanner->CancelCreateSync(sid, str2addr(env, address));
		}

		static void onSyncTransferredCb(int pa_source, uint8_t status,
		RawAddress address) {
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
		return;
		}
		ScopedLocalRef<jstring> addr(sCallbackEnv.get(),
		bdaddr2newjstr(sCallbackEnv.get(), &address));

		sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj,
		method_onSyncTransferredCallback, pa_source,
		status, addr.get());
		}

		static void syncTransferNative(JNIEnv* env, jobject object, jint pa_source,
		jstring addr, jint service_data,
		jint sync_handle) {
		if (!sGattIf) return;
		sGattIf->scanner->TransferSync(str2addr(env, addr), service_data, sync_handle,
		base::Bind(&onSyncTransferredCb, pa_source));
		pa_source);
		}

		static void transferSetInfoNative(JNIEnv* env, jobject object, jint pa_source,
		jstring addr, jint service_data,
		jint adv_handle) {
		if (!sGattIf) return;
		sGattIf->scanner->TransferSetInfo(
		str2addr(env, addr), service_data, adv_handle,
		base::Bind(&onSyncTransferredCb, pa_source));
		sGattIf->scanner->TransferSetInfo(str2addr(env, addr), service_data,
		adv_handle, pa_source);
		}

		static void gattTestNative(JNIEnv* env, jobject object, jint command,

system/btif/src/btif_ble_scanner.cc

+40 −18

Original line number	Diff line number	Diff line
		@@ -335,19 +335,26 @@ class BleScannerInterfaceImpl : public BleScannerInterface {
		}

		void StartSync(uint8_t sid, RawAddress address, uint16_t skip,
		uint16_t timeout, StartSyncCb start_cb, SyncReportCb report_cb,
		SyncLostCb lost_cb) override {
		uint16_t timeout, int reg_id) override {
		const controller_t* controller = controller_get_interface();
		if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {
		uint8_t status_no_resource = 2;
		start_cb.Run(status_no_resource, -1, sid, 1, address, 0, 0);
		}
		callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, sid, 1,
		address, 0, 0);
		}
		StartSyncCb start_sync_cb =
		base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,
		base::Unretained(callbacks_), reg_id);
		SyncReportCb sync_report_cb = base::Bind(
		&ScanningCallbacks::OnPeriodicSyncReport, base::Unretained(callbacks_));
		SyncLostCb sync_lost_cb = base::Bind(&ScanningCallbacks::OnPeriodicSyncLost,
		base::Unretained(callbacks_));
		do_in_main_thread(
		FROM_HERE,
		base::Bind(&BTM_BleStartPeriodicSync, sid, address, skip, timeout,
		jni_thread_wrapper(FROM_HERE, std::move(start_cb)),
		jni_thread_wrapper(FROM_HERE, std::move(report_cb)),
		jni_thread_wrapper(FROM_HERE, std::move(lost_cb))));
		jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb)),
		jni_thread_wrapper(FROM_HERE, std::move(sync_report_cb)),
		jni_thread_wrapper(FROM_HERE, std::move(sync_lost_cb))));
		}

		void StopSync(uint16_t handle) override {
		@@ -359,8 +366,8 @@ class BleScannerInterfaceImpl : public BleScannerInterface {
		do_in_main_thread(FROM_HERE, base::Bind(&BTM_BleStopPeriodicSync, handle));
		}

		void RegisterCallbacks(ScanningCallbacks* callbacks) {
		// For GD only
		void RegisterCallbacks(ScanningCallbacks* callbacks) override {
		callbacks_ = callbacks;
		}

		void CancelCreateSync(uint8_t sid, RawAddress address) override {
		@@ -373,50 +380,65 @@ class BleScannerInterfaceImpl : public BleScannerInterface {
		}

		void TransferSync(RawAddress address, uint16_t service_data,
		uint16_t sync_handle, SyncTransferCb cb) override {
		uint16_t sync_handle, int pa_source) override {
		LOG_DEBUG("address:%s", address.ToString().c_str());
		const controller_t* controller = controller_get_interface();
		if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {
		uint8_t status_no_resource = 2;
		LOG_ERROR("PAST not supported by controller");
		cb.Run(status_no_resource, address);
		callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,
		address);
		}
		SyncTransferCb sync_transfer_cb =
		base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,
		base::Unretained(callbacks_), pa_source);
		do_in_main_thread(
		FROM_HERE,
		base::Bind(&BTM_BlePeriodicSyncTransfer, address, service_data,
		sync_handle, jni_thread_wrapper(FROM_HERE, std::move(cb))));
		sync_handle,
		jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));
		}

		void TransferSetInfo(RawAddress address, uint16_t service_data,
		uint8_t adv_handle, SyncTransferCb cb) override {
		uint8_t adv_handle, int pa_source) override {
		LOG_DEBUG("address: %s", address.ToString().c_str());
		const controller_t* controller = controller_get_interface();
		if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {
		uint8_t status_no_resource = 2;
		LOG_ERROR(" PAST not supported by controller");
		cb.Run(status_no_resource, address);
		callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,
		address);
		}

		SyncTransferCb sync_transfer_cb =
		base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,
		base::Unretained(callbacks_), pa_source);
		do_in_main_thread(
		FROM_HERE,
		base::Bind(&BTM_BlePeriodicSyncSetInfo, address, service_data,
		adv_handle, jni_thread_wrapper(FROM_HERE, std::move(cb))));
		adv_handle,
		jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));
		}

		void SyncTxParameters(RawAddress addr, uint8_t mode, uint16_t skip,
		uint16_t timeout, StartSyncCb cb) {
		uint16_t timeout, int reg_id) override {
		LOG_DEBUG("address: %s", addr.ToString().c_str());
		const controller_t* controller = controller_get_interface();
		if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {
		uint8_t status_no_resource = 2;
		LOG_ERROR(" PAST not supported by controller");
		cb.Run(status_no_resource, -1, -1, 1, addr, 0, 0);
		callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, -1, 1,
		addr, 0, 0);
		}
		StartSyncCb start_sync_cb =
		base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,
		base::Unretained(callbacks_), reg_id);
		do_in_main_thread(
		FROM_HERE,
		base::Bind(&BTM_BlePeriodicSyncTxParameters, addr, mode, skip, timeout,
		jni_thread_wrapper(FROM_HERE, std::move(cb))));
		jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb))));
		}

		ScanningCallbacks* callbacks_ = nullptr;
		};

		} // namespace

system/gd/rust/topshim/gatt/gatt_ble_scanner_shim.cc

+9 −18

Original line number	Diff line number	Diff line
		@@ -252,14 +252,7 @@ void BleScannerIntf::BatchscanReadReports(uint8_t scanner_id, int32_t scan_mode)

		void BleScannerIntf::StartSync(uint8_t sid, RustRawAddress address, uint16_t skip, uint16_t timeout) {
		RawAddress converted = rusty::CopyFromRustAddress(address);
		scanner_intf_->StartSync(
		sid,
		converted,
		skip,
		timeout,
		base::Bind(&BleScannerIntf::OnStartSyncCb, base::Unretained(this)),
		base::Bind(&BleScannerIntf::OnSyncReportCb, base::Unretained(this)),
		base::Bind(&BleScannerIntf::OnSyncLostCb, base::Unretained(this)));
		scanner_intf_->StartSync(sid, converted, skip, timeout, 0 /* place holder */);
		}

		void BleScannerIntf::StopSync(uint16_t handle) {
		@@ -273,20 +266,17 @@ void BleScannerIntf::CancelCreateSync(uint8_t sid, RustRawAddress address) {

		void BleScannerIntf::TransferSync(RustRawAddress address, uint16_t service_data, uint16_t sync_handle) {
		RawAddress converted = rusty::CopyFromRustAddress(address);
		scanner_intf_->TransferSync(
		converted, service_data, sync_handle, base::Bind(&BleScannerIntf::OnSyncTransferCb, base::Unretained(this)));
		scanner_intf_->TransferSync(converted, service_data, sync_handle, 0 /* place holder */);
		}

		void BleScannerIntf::TransferSetInfo(RustRawAddress address, uint16_t service_data, uint8_t adv_handle) {
		RawAddress converted = rusty::CopyFromRustAddress(address);
		scanner_intf_->TransferSetInfo(
		converted, service_data, adv_handle, base::Bind(&BleScannerIntf::OnSyncTransferCb, base::Unretained(this)));
		scanner_intf_->TransferSetInfo(converted, service_data, adv_handle, 0 /* place holder */);
		}

		void BleScannerIntf::SyncTxParameters(RustRawAddress address, uint8_t mode, uint16_t skip, uint16_t timeout) {
		RawAddress converted = rusty::CopyFromRustAddress(address);
		scanner_intf_->SyncTxParameters(
		converted, mode, skip, timeout, base::Bind(&BleScannerIntf::OnStartSyncCb, base::Unretained(this)));
		scanner_intf_->SyncTxParameters(converted, mode, skip, timeout, 0 /* place holder */);
		}

		void BleScannerIntf::OnRegisterCallback(RustUuid uuid, uint8_t scanner_id, uint8_t btm_status) {
		@@ -311,7 +301,8 @@ void BleScannerIntf::OnFilterConfigCallback(
		rusty::gdscan_filter_config_callback(filter_index, filt_type, avbl_space, action, btm_status);
		}

		void BleScannerIntf::OnStartSyncCb(
		void BleScannerIntf::OnPeriodicSyncStarted(
		int,
		uint8_t status,
		uint16_t sync_handle,
		uint8_t advertising_sid,
		@@ -323,16 +314,16 @@ void BleScannerIntf::OnStartSyncCb(
		rusty::gdscan_start_sync_callback(status, sync_handle, advertising_sid, address_type, &converted, phy, interval);
		}

		void BleScannerIntf::OnSyncReportCb(
		void BleScannerIntf::OnPeriodicSyncReport(
		uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t status, std::vector<uint8_t> data) {
		rusty::gdscan_sync_report_callback(sync_handle, tx_power, rssi, status, data.data(), data.size());
		}

		void BleScannerIntf::OnSyncLostCb(uint16_t sync_handle) {
		void BleScannerIntf::OnPeriodicSyncLost(uint16_t sync_handle) {
		rusty::gdscan_sync_lost_callback(sync_handle);
		}

		void BleScannerIntf::OnSyncTransferCb(uint8_t status, RawAddress address) {
		void BleScannerIntf::OnPeriodicSyncTransferred(int, uint8_t status, RawAddress address) {
		RustRawAddress converted = rusty::CopyToRustAddress(address);
		rusty::gdscan_sync_transfer_callback(status, &converted);
		}

system/gd/rust/topshim/gatt/gatt_ble_scanner_shim.h

+23 −12

Original line number	Diff line number	Diff line
		@@ -60,6 +60,24 @@ class BleScannerIntf : public ScanningCallbacks {

		void OnBatchScanThresholdCrossed(int client_if) override;

		void OnPeriodicSyncStarted(
		int reg_id,
		uint8_t status,
		uint16_t sync_handle,
		uint8_t advertising_sid,
		uint8_t address_type,
		RawAddress address,
		uint8_t phy,
		uint16_t interval) override;
		void OnPeriodicSyncReport(
		uint16_t sync_handle,
		int8_t tx_power,
		int8_t rssi,
		uint8_t status,
		std::vector<uint8_t> data) override;
		void OnPeriodicSyncLost(uint16_t sync_handle) override;
		void OnPeriodicSyncTransferred(int pa_source, uint8_t status, RawAddress address) override;

		// Implementations of BleScannerInterface. These don't inherit from
		// BleScannerInterface because the Rust FFI boundary requires some clever
		// modifications.
		@@ -147,18 +165,11 @@ class BleScannerIntf : public ScanningCallbacks {
		void OnEnableCallback(uint8_t action, uint8_t btm_status);
		void OnFilterParamSetupCallback(uint8_t scanner_id, uint8_t avbl_space, uint8_t action_type, uint8_t btm_status);
		void OnFilterConfigCallback(
		uint8_t filt_index, uint8_t filt_type, uint8_t avbl_space, uint8_t action, uint8_t btm_status);
		void OnStartSyncCb(
		uint8_t status,
		uint16_t sync_handle,
		uint8_t advertising_sid,
		uint8_t address_type,
		RawAddress address,
		uint8_t phy,
		uint16_t interval);
		void OnSyncReportCb(uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t status, std::vector<uint8_t> data);
		void OnSyncLostCb(uint16_t sync_handle);
		void OnSyncTransferCb(uint8_t status, RawAddress address);
		uint8_t filt_index,
		uint8_t filt_type,
		uint8_t avbl_space,
		uint8_t action,
		uint8_t btm_status);

		BleScannerInterface* scanner_intf_;
		};

system/include/hardware/ble_scanner.h

+15 −15

Original line number	Diff line number	Diff line
		@@ -96,6 +96,17 @@ class ScanningCallbacks {
		int num_records,
		std::vector<uint8_t> data) = 0;
		virtual void OnBatchScanThresholdCrossed(int client_if) = 0;
		virtual void OnPeriodicSyncStarted(int reg_id, uint8_t status,
		uint16_t sync_handle,
		uint8_t advertising_sid,
		uint8_t address_type, RawAddress address,
		uint8_t phy, uint16_t interval) = 0;
		virtual void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power,
		int8_t rssi, uint8_t status,
		std::vector<uint8_t> data) = 0;
		virtual void OnPeriodicSyncLost(uint16_t sync_handle) = 0;
		virtual void OnPeriodicSyncTransferred(int pa_source, uint8_t status,
		RawAddress address) = 0;
		};

		class BleScannerInterface {
		@@ -165,31 +176,20 @@ class BleScannerInterface {
		/* Read out batchscan reports */
		virtual void BatchscanReadReports(int client_if, int scan_mode) = 0;

		using StartSyncCb =
		base::Callback<void(uint8_t status, uint16_t sync_handle,
		uint8_t advertising_sid, uint8_t address_type,
		RawAddress address, uint8_t phy, uint16_t interval)>;
		using SyncReportCb =
		base::Callback<void(uint16_t sync_handle, int8_t tx_power, int8_t rssi,
		uint8_t status, std::vector<uint8_t> data)>;
		using SyncLostCb = base::Callback<void(uint16_t sync_handle)>;
		virtual void StartSync(uint8_t sid, RawAddress address, uint16_t skip,
		uint16_t timeout, StartSyncCb start_cb,
		SyncReportCb report_cb, SyncLostCb lost_cb) = 0;
		uint16_t timeout, int reg_id) = 0;
		virtual void StopSync(uint16_t handle) = 0;

		virtual void RegisterCallbacks(ScanningCallbacks* callbacks) = 0;

		virtual void CancelCreateSync(uint8_t sid, RawAddress address) = 0;
		using SyncTransferCb =
		base::Callback<void(uint8_t /status/, RawAddress /addr/)>;

		virtual void TransferSync(RawAddress address, uint16_t service_data,
		uint16_t sync_handle, SyncTransferCb cb) = 0;
		uint16_t sync_handle, int pa_source) = 0;
		virtual void TransferSetInfo(RawAddress address, uint16_t service_data,
		uint8_t adv_handle, SyncTransferCb cb) = 0;
		uint8_t adv_handle, int pa_source) = 0;
		virtual void SyncTxParameters(RawAddress addr, uint8_t mode, uint16_t skip,
		uint16_t timeout, StartSyncCb start_cb) = 0;
		uint16_t timeout, int reg_id) = 0;
		};

		#endif /* ANDROID_INCLUDE_BLE_SCANNER_H */