Snap for 11959661 from f012f080e86ae0b1ae0b91e468a3bbc13cc9c677 to 24Q3-release (8990bfa0) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_gatt.cpp

+69 −65

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@
		#include "common/init_flags.h"
		#include "hardware/bt_gatt.h"
		#include "hardware/bt_gatt_types.h"
		#include "main/shim/le_scanning_manager.h"
		#include "rust/cxx.h"
		#include "rust/src/gatt/ffi/gatt_shim.h"
		#include "src/gatt/ffi.rs.h"
		@@ -197,6 +198,8 @@ static jmethodID method_onDistanceMeasurementResult;
		* Static variables
		*/
		static const btgatt_interface_t* sGattIf = NULL;
		/** Pointer to the LE scanner interface methods.*/
		static BleScannerInterface* sScanner = NULL;
		static jobject mCallbacksObj = NULL;
		static jobject mScanCallbacksObj = NULL;
		static jobject mAdvertiseCallbacksObj = NULL;
		@@ -304,16 +307,16 @@ void btgattc_notify_cb(int conn_id, const btgatt_notify_params_t& p_data) {
		}

		void btgattc_read_characteristic_cb(int conn_id, int status,
		btgatt_read_params_t* p_data) {
		const btgatt_read_params_t& p_data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| !mCallbacksObj) return;

		ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);
		if (status == 0) { // Success
		jb.reset(sCallbackEnv->NewByteArray(p_data->value.len));
		sCallbackEnv->SetByteArrayRegion(jb.get(), 0, p_data->value.len,
		(jbyte*)p_data->value.value);
		jb.reset(sCallbackEnv->NewByteArray(p_data.value.len));
		sCallbackEnv->SetByteArrayRegion(jb.get(), 0, p_data.value.len,
		(jbyte*)p_data.value.value);
		} else {
		uint8_t value = 0;
		jb.reset(sCallbackEnv->NewByteArray(1));
		@@ -321,7 +324,7 @@ void btgattc_read_characteristic_cb(int conn_id, int status,
		}

		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onReadCharacteristic,
		conn_id, status, p_data->handle, jb.get());
		conn_id, status, p_data.handle, jb.get());
		}

		void btgattc_write_characteristic_cb(int conn_id, int status, uint16_t handle,
		@@ -1278,7 +1281,6 @@ static void initializeNative(JNIEnv* env, jobject object) {

		sGattIf->advertiser->RegisterCallbacks(
		JniAdvertisingCallbacks::GetInstance());
		sGattIf->scanner->RegisterCallbacks(JniScanningCallbacks::GetInstance());
		sGattIf->distance_measurement_manager->RegisterDistanceMeasurementCallbacks(
		JniDistanceMeasurementCallbacks::GetInstance());

		@@ -1337,24 +1339,24 @@ void btgattc_register_scanner_cb(const Uuid& app_uuid, uint8_t scannerId,

		static void registerScannerNative(JNIEnv* /* env /, jobject / object */,
		jlong app_uuid_lsb, jlong app_uuid_msb) {
		if (!sGattIf) return;
		if (!sScanner) return;

		Uuid uuid = from_java_uuid(app_uuid_msb, app_uuid_lsb);
		sGattIf->scanner->RegisterScanner(
		uuid, base::Bind(&btgattc_register_scanner_cb, uuid));
		sScanner->RegisterScanner(uuid,
		base::Bind(&btgattc_register_scanner_cb, uuid));
		}

		static void unregisterScannerNative(JNIEnv* /* env /, jobject / object */,
		jint scanner_id) {
		if (!sGattIf) return;
		if (!sScanner) return;

		sGattIf->scanner->Unregister(scanner_id);
		sScanner->Unregister(scanner_id);
		}

		static void gattClientScanNative(JNIEnv* /* env /, jobject / object */,
		jboolean start) {
		if (!sGattIf) return;
		sGattIf->scanner->Scan(start);
		if (!sScanner) return;
		sScanner->Scan(start);
		}

		static void gattClientConnectNative(JNIEnv* env, jobject /* object */,
		@@ -1548,10 +1550,9 @@ void set_scan_params_cmpl_cb(int client_if, uint8_t status) {
		static void gattSetScanParametersNative(JNIEnv* /* env /, jobject / object */,
		jint client_if, jint scan_interval_unit,
		jint scan_window_unit, jint scan_phy) {
		if (!sGattIf) return;
		sGattIf->scanner->SetScanParameters(
		client_if, /* use active scan */ 0x01, scan_interval_unit,
		scan_window_unit, scan_phy,
		if (!sScanner) return;
		sScanner->SetScanParameters(client_if, /* use active scan */ 0x01,
		scan_interval_unit, scan_window_unit, scan_phy,
		base::Bind(&set_scan_params_cmpl_cb, client_if));
		}

		@@ -1568,7 +1569,7 @@ void scan_filter_param_cb(uint8_t client_if, uint8_t avbl_space, uint8_t action,
		static void gattClientScanFilterParamAddNative(JNIEnv* env,
		jobject /* object */,
		jobject params) {
		if (!sGattIf) return;
		if (!sScanner) return;
		const int add_scan_filter_params_action = 0;
		auto filt_params = std::make_unique<btgatt_filt_param_setup_t>();

		@@ -1611,30 +1612,30 @@ static void gattClientScanFilterParamAddNative(JNIEnv* env,
		methodId = env->GetMethodID(filtparam.get(), "getRSSILowValue", "()I");
		filt_params->rssi_low_thres = env->CallIntMethod(params, methodId);

		sGattIf->scanner->ScanFilterParamSetup(
		client_if, add_scan_filter_params_action, filt_index,
		std::move(filt_params), base::Bind(&scan_filter_param_cb, client_if));
		sScanner->ScanFilterParamSetup(client_if, add_scan_filter_params_action,
		filt_index, std::move(filt_params),
		base::Bind(&scan_filter_param_cb, client_if));
		}

		static void gattClientScanFilterParamDeleteNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if,
		jint filt_index) {
		if (!sGattIf) return;
		if (!sScanner) return;
		const int delete_scan_filter_params_action = 1;
		sGattIf->scanner->ScanFilterParamSetup(
		client_if, delete_scan_filter_params_action, filt_index, nullptr,
		sScanner->ScanFilterParamSetup(client_if, delete_scan_filter_params_action,
		filt_index, nullptr,
		base::Bind(&scan_filter_param_cb, client_if));
		}

		static void gattClientScanFilterParamClearAllNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if) {
		if (!sGattIf) return;
		if (!sScanner) return;
		const int clear_scan_filter_params_action = 2;
		sGattIf->scanner->ScanFilterParamSetup(
		client_if, clear_scan_filter_params_action, 0 /* index, unused */,
		nullptr, base::Bind(&scan_filter_param_cb, client_if));
		sScanner->ScanFilterParamSetup(client_if, clear_scan_filter_params_action,
		0 /* index, unused */, nullptr,
		base::Bind(&scan_filter_param_cb, client_if));
		}

		static void scan_filter_cfg_cb(uint8_t client_if, uint8_t filt_type,
		@@ -1651,7 +1652,7 @@ static void scan_filter_cfg_cb(uint8_t client_if, uint8_t filt_type,
		static void gattClientScanFilterAddNative(JNIEnv* env, jobject /* object */,
		jint client_if, jobjectArray filters,
		jint filter_index) {
		if (!sGattIf) return;
		if (!sScanner) return;

		jmethodID uuidGetMsb;
		jmethodID uuidGetLsb;
		@@ -1666,7 +1667,7 @@ static void gattClientScanFilterAddNative(JNIEnv* env, jobject /* object */,

		int numFilters = env->GetArrayLength(filters);
		if (numFilters == 0) {
		sGattIf->scanner->ScanFilterAdd(filter_index, std::move(native_filters),
		sScanner->ScanFilterAdd(filter_index, std::move(native_filters),
		base::Bind(&scan_filter_cfg_cb, client_if));
		return;
		}
		@@ -1805,15 +1806,15 @@ static void gattClientScanFilterAddNative(JNIEnv* env, jobject /* object */,
		native_filters.push_back(curr);
		}

		sGattIf->scanner->ScanFilterAdd(filter_index, std::move(native_filters),
		sScanner->ScanFilterAdd(filter_index, std::move(native_filters),
		base::Bind(&scan_filter_cfg_cb, client_if));
		}

		static void gattClientScanFilterClearNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if, jint filt_index) {
		if (!sGattIf) return;
		sGattIf->scanner->ScanFilterClear(filt_index,
		if (!sScanner) return;
		sScanner->ScanFilterClear(filt_index,
		base::Bind(&scan_filter_cfg_cb, client_if));
		}

		@@ -1829,9 +1830,8 @@ void scan_enable_cb(uint8_t client_if, uint8_t action, uint8_t status) {
		static void gattClientScanFilterEnableNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if, jboolean enable) {
		if (!sGattIf) return;
		sGattIf->scanner->ScanFilterEnable(enable,
		base::Bind(&scan_enable_cb, client_if));
		if (!sScanner) return;
		sScanner->ScanFilterEnable(enable, base::Bind(&scan_enable_cb, client_if));
		}

		static void gattClientConfigureMTUNative(JNIEnv* /* env */,
		@@ -1875,8 +1875,8 @@ static void gattClientConfigBatchScanStorageNative(
		JNIEnv* /* env /, jobject / object */, jint client_if,
		jint max_full_reports_percent, jint max_trunc_reports_percent,
		jint notify_threshold_level_percent) {
		if (!sGattIf) return;
		sGattIf->scanner->BatchscanConfigStorage(
		if (!sScanner) return;
		sScanner->BatchscanConfigStorage(
		client_if, max_full_reports_percent, max_trunc_reports_percent,
		notify_threshold_level_percent,
		base::Bind(&batchscan_cfg_storage_cb, client_if));
		@@ -1897,25 +1897,24 @@ static void gattClientStartBatchScanNative(JNIEnv* /* env */,
		jint scan_interval_unit,
		jint scan_window_unit,
		jint addr_type, jint discard_rule) {
		if (!sGattIf) return;
		sGattIf->scanner->BatchscanEnable(
		scan_mode, scan_interval_unit, scan_window_unit, addr_type, discard_rule,
		if (!sScanner) return;
		sScanner->BatchscanEnable(scan_mode, scan_interval_unit, scan_window_unit,
		addr_type, discard_rule,
		base::Bind(&batchscan_enable_cb, client_if));
		}

		static void gattClientStopBatchScanNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if) {
		if (!sGattIf) return;
		sGattIf->scanner->BatchscanDisable(
		base::Bind(&batchscan_enable_cb, client_if));
		if (!sScanner) return;
		sScanner->BatchscanDisable(base::Bind(&batchscan_enable_cb, client_if));
		}

		static void gattClientReadScanReportsNative(JNIEnv* /* env */,
		jobject /* object */,
		jint client_if, jint scan_type) {
		if (!sGattIf) return;
		sGattIf->scanner->BatchscanReadReports(client_if, scan_type);
		if (!sScanner) return;
		sScanner->BatchscanReadReports(client_if, scan_type);
		}

		/**
		@@ -2469,6 +2468,9 @@ static void periodicScanCleanupNative(JNIEnv* env, jobject /* object */) {
		}

		static void scanInitializeNative(JNIEnv* env, jobject object) {
		sScanner = bluetooth::shim::get_ble_scanner_instance();
		sScanner->RegisterCallbacks(JniScanningCallbacks::GetInstance());

		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (mScanCallbacksObj != NULL) {
		log::warn("Cleaning up scan callback object");
		@@ -2485,42 +2487,44 @@ static void scanCleanupNative(JNIEnv* env, jobject /* object */) {
		env->DeleteGlobalRef(mScanCallbacksObj);
		mScanCallbacksObj = NULL;
		}
		if (sScanner != NULL) {
		sScanner = NULL;
		}
		}

		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,
		reg_id);
		if (!sScanner) return;
		sScanner->StartSync(sid, str2addr(env, address), skip, timeout, reg_id);
		}

		static void stopSyncNative(JNIEnv* /* env /, jobject / object */,
		jint sync_handle) {
		if (!sGattIf) return;
		sGattIf->scanner->StopSync(sync_handle);
		if (!sScanner) return;
		sScanner->StopSync(sync_handle);
		}

		static void cancelSyncNative(JNIEnv* env, jobject /* object */, jint sid,
		jstring address) {
		if (!sGattIf) return;
		sGattIf->scanner->CancelCreateSync(sid, str2addr(env, address));
		if (!sScanner) return;
		sScanner->CancelCreateSync(sid, str2addr(env, address));
		}

		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,
		if (!sScanner) return;
		sScanner->TransferSync(str2addr(env, addr), service_data, sync_handle,
		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, pa_source);
		if (!sScanner) return;
		sScanner->TransferSetInfo(str2addr(env, addr), service_data, adv_handle,
		pa_source);
		}

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

android/app/tests/unit/src/com/android/bluetooth/btservice/AdapterServiceRestartTest.java

deleted100644 → 0

+0 −316

File deleted.

Preview size limit exceeded, changes collapsed.

android/app/tests/unit/src/com/android/bluetooth/btservice/AdapterServiceTest.java

+0 −116

Original line number	Diff line number	Diff line
		@@ -89,7 +89,6 @@ import libcore.util.HexEncoding;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Ignore;
		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		@@ -959,79 +958,6 @@ public class AdapterServiceTest {
		assertThat(mAdapterService.obfuscateAddress(null)).isEmpty();
		}

		/**
		* Test: Obfuscate Bluetooth address when Bluetooth is disabled Check whether the returned value
		* meets expectation
		*/
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testObfuscateBluetoothAddress_BluetoothDisabled() {
		Map<String, Map<String, String>> adapterConfig = TestUtils.readAdapterConfig();
		assertThat(adapterConfig).isNotNull();

		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		byte[] metricsSalt = getMetricsSalt(adapterConfig);
		assertThat(metricsSalt).isNotNull();
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		byte[] obfuscatedAddress = mAdapterService.obfuscateAddress(device);
		assertThat(obfuscatedAddress).isNotEmpty();
		assertThat(isByteArrayAllZero(obfuscatedAddress)).isFalse();
		assertThat(obfuscateInJava(metricsSalt, device)).isEqualTo(obfuscatedAddress);
		}

		/**
		* Test: Obfuscate Bluetooth address when Bluetooth is enabled Check whether the returned value
		* meets expectation
		*/
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testObfuscateBluetoothAddress_BluetoothEnabled() {
		Map<String, Map<String, String>> adapterConfig = TestUtils.readAdapterConfig();
		assertThat(adapterConfig).isNotNull();

		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		doEnable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_ON);
		byte[] metricsSalt = getMetricsSalt(adapterConfig);
		assertThat(metricsSalt).isNotNull();
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		byte[] obfuscatedAddress = mAdapterService.obfuscateAddress(device);
		assertThat(obfuscatedAddress).isNotEmpty();
		assertThat(isByteArrayAllZero(obfuscatedAddress)).isFalse();
		assertThat(obfuscateInJava(metricsSalt, device)).isEqualTo(obfuscatedAddress);
		}

		/** Test: Check if obfuscated Bluetooth address stays the same after toggling Bluetooth */
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testObfuscateBluetoothAddress_PersistentBetweenToggle() {
		Map<String, Map<String, String>> adapterConfig = TestUtils.readAdapterConfig();
		assertThat(adapterConfig).isNotNull();

		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		byte[] metricsSalt = getMetricsSalt(adapterConfig);
		assertThat(metricsSalt).isNotNull();
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
		assertThat(obfuscatedAddress1).isNotEmpty();
		assertThat(isByteArrayAllZero(obfuscatedAddress1)).isFalse();
		assertThat(obfuscateInJava(metricsSalt, device)).isEqualTo(obfuscatedAddress1);
		// Enable
		doEnable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_ON);
		byte[] obfuscatedAddress3 = mAdapterService.obfuscateAddress(device);
		assertThat(obfuscatedAddress3).isNotEmpty();
		assertThat(isByteArrayAllZero(obfuscatedAddress3)).isFalse();
		assertThat(obfuscatedAddress3).isEqualTo(obfuscatedAddress1);
		// Disable
		doDisable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		byte[] obfuscatedAddress4 = mAdapterService.obfuscateAddress(device);
		assertThat(obfuscatedAddress4).isNotEmpty();
		assertThat(isByteArrayAllZero(obfuscatedAddress4)).isFalse();
		assertThat(obfuscatedAddress4).isEqualTo(obfuscatedAddress1);
		}

		@Test
		public void testAddressConsolidation() {
		// Create device properties
		@@ -1110,48 +1036,6 @@ public class AdapterServiceTest {
		assertThat(mAdapterService.getMetricId(null)).isEqualTo(0);
		}

		/**
		* Test: Get id when Bluetooth is disabled Check whether the returned value meets expectation
		*/
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testGetMetricId_BluetoothDisabled() {
		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		assertThat(mAdapterService.getMetricId(device)).isGreaterThan(0);
		}

		/** Test: Get id when Bluetooth is enabled Check whether the returned value meets expectation */
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testGetMetricId_BluetoothEnabled() {
		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		doEnable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_ON);
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		assertThat(mAdapterService.getMetricId(device)).isGreaterThan(0);
		}

		/** Test: Check if id gotten stays the same after toggling Bluetooth */
		@Test
		@Ignore("b/296127545: This is a native test")
		public void testGetMetricId_PersistentBetweenToggle() {
		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
		final int initialMetricId = mAdapterService.getMetricId(device);
		assertThat(initialMetricId).isGreaterThan(0);

		// Enable
		doEnable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_ON);
		assertThat(mAdapterService.getMetricId(device)).isEqualTo(initialMetricId);

		// Disable
		doDisable(false);
		assertThat(mAdapterService.getState()).isEqualTo(STATE_OFF);
		assertThat(mAdapterService.getMetricId(device)).isEqualTo(initialMetricId);
		}

		@Test
		public void testDump_doesNotCrash() {
		FileDescriptor fd = new FileDescriptor();

flags/opp.aconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -17,3 +17,14 @@ flag {
		purpose: PURPOSE_BUGFIX
		}
		}

		flag {
		name: "opp_ignore_content_observer_after_service_stop"
		namespace: "bluetooth"
		description: "When OppService.stop() is called, previously posted ContentObserver.onChange() should not run"
		bug: "346467641"
		metadata {
		purpose: PURPOSE_BUGFIX
		}
		}

floss/pandora/floss/floss_enums.py

+1 −0

Original line number	Diff line number	Diff line
		@@ -134,6 +134,7 @@ class BtStatus(enum.IntEnum):
		JNI_THREAD_ATTACH_ERROR = 13
		WAKE_LOCK_ERROR = 14
		BT_STATUS_TIMEOUT = 15
		DEVICE_NOT_FOUND = 16


		class SocketType(enum.IntEnum):