Merge "DIP: Implement API to get device identification information" (687256f0) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_sdp.cpp

100644 → 100755

+16 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@ static const Uuid UUID_PBAP_PSE = Uuid::From16Bit(0x112F);
		static const Uuid UUID_MAP_MAS = Uuid::From16Bit(0x1132);
		static const Uuid UUID_MAP_MNS = Uuid::From16Bit(0x1133);
		static const Uuid UUID_SAP = Uuid::From16Bit(0x112D);
		static const Uuid UUID_DIP = Uuid::From16Bit(0x1200);

		namespace android {
		static jmethodID method_sdpRecordFoundCallback;
		@@ -39,6 +40,7 @@ static jmethodID method_sdpMnsRecordFoundCallback;
		static jmethodID method_sdpPseRecordFoundCallback;
		static jmethodID method_sdpOppOpsRecordFoundCallback;
		static jmethodID method_sdpSapsRecordFoundCallback;
		static jmethodID method_sdpDipRecordFoundCallback;

		static const btsdp_interface_t* sBluetoothSdpInterface = NULL;

		@@ -96,6 +98,9 @@ static void classInitNative(JNIEnv* env, jclass clazz) {
		/* SAP Server record */
		method_sdpSapsRecordFoundCallback = env->GetMethodID(
		clazz, "sdpSapsRecordFoundCallback", "(I[B[BIILjava/lang/String;Z)V");
		/* DIP record */
		method_sdpDipRecordFoundCallback = env->GetMethodID(
		clazz, "sdpDipRecordFoundCallback", "(I[B[BIIIIIZZ)V");
		}

		static jboolean sdpSearchNative(JNIEnv* env, jobject obj, jbyteArray address,
		@@ -214,6 +219,17 @@ static void sdp_search_callback(bt_status_t status, const RawAddress& bd_addr,
		addr.get(), uuid.get(), (jint)record->mas.hdr.rfcomm_channel_number,
		(jint)record->mas.hdr.profile_version, service_name.get(),
		more_results);
		} else if (uuid_in == UUID_DIP) {
		ALOGD("%s, Get UUID_DIP", __func__);
		sCallbackEnv->CallVoidMethod(
		sCallbacksObj, method_sdpDipRecordFoundCallback, (jint)status,
		addr.get(), uuid.get(), (jint)record->dip.spec_id,
		(jint)record->dip.vendor,
		(jint)record->dip.vendor_id_source,
		(jint)record->dip.product,
		(jint)record->dip.version,
		record->dip.primary_record,
		more_results);
		} else {
		// we don't have a wrapper for this uuid, send as raw data
		jint record_data_size = record->hdr.user1_ptr_len;

android/app/src/com/android/bluetooth/sdp/SdpManager.java

+34 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@
		package com.android.bluetooth.sdp;

		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.SdpDipRecord;
		import android.bluetooth.SdpMasRecord;
		import android.bluetooth.SdpMnsRecord;
		import android.bluetooth.SdpOppOpsRecord;
		@@ -365,6 +366,39 @@ public class SdpManager {
		}
		}

		void sdpDipRecordFoundCallback(int status, byte[] address,
		byte[] uuid, int specificationId,
		int vendorId, int vendorIdSource,
		int productId, int version,
		boolean primaryRecord,
		boolean moreResults) {
		synchronized(TRACKER_LOCK) {
		SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid);
		SdpDipRecord sdpRecord = null;
		if (inst == null) {
		Log.e(TAG, "sdpDipRecordFoundCallback: Search instance is NULL");
		return;
		}
		inst.setStatus(status);
		if (D) {
		Log.d(TAG, "sdpDipRecordFoundCallback: status " + status);
		}
		if (status == AbstractionLayer.BT_STATUS_SUCCESS) {
		sdpRecord = new SdpDipRecord(specificationId,
		vendorId, vendorIdSource,
		productId, version,
		primaryRecord);
		}
		if (D) {
		Log.d(TAG, "UUID: " + Arrays.toString(uuid));
		}
		if (D) {
		Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString());
		}
		sendSdpIntent(inst, sdpRecord, moreResults);
		}
		}

		/* TODO: Test or remove! */
		void sdpRecordFoundCallback(int status, byte[] address, byte[] uuid, int sizeRecord,
		byte[] record) {

android/app/tests/unit/Android.bp

100644 → 100755

+1 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ android_test {
		"androidx.room_room-migration",
		"androidx.room_room-runtime",
		"androidx.room_room-testing",
		"truth-prebuilt",
		],

		asset_dirs: ["src/com/android/bluetooth/btservice/storage/schemas"],

android/app/tests/unit/src/com/android/bluetooth/sdp/DipTest.java

0 → 100755

+138 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.bluetooth.sdp;

		import static com.google.common.truth.Truth.assertThat;
		import static org.mockito.Mockito.verify;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothProfile;
		import android.bluetooth.BluetoothUuid;
		import android.bluetooth.SdpDipRecord;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.os.Looper;
		import android.os.ParcelUuid;

		import androidx.test.InstrumentationRegistry;
		import androidx.test.filters.SmallTest;
		import androidx.test.runner.AndroidJUnit4;

		import com.android.bluetooth.R;
		import com.android.bluetooth.sdp.SdpManager;
		import com.android.bluetooth.TestUtils;
		import com.android.bluetooth.btservice.AbstractionLayer;
		import com.android.bluetooth.btservice.AdapterService;
		import com.android.bluetooth.Utils;

		import org.junit.After;
		import org.junit.Assume;
		import org.junit.Before;
		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.ArgumentCaptor;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		@SmallTest
		@RunWith(AndroidJUnit4.class)
		public class DipTest {
		private BluetoothAdapter mAdapter;
		private Context mTargetContext;
		private SdpManager mSdpManager;
		private BluetoothDevice mTestDevice;

		private ArgumentCaptor<Intent> mIntentArgument = ArgumentCaptor.forClass(Intent.class);
		private ArgumentCaptor<String> mStringArgument = ArgumentCaptor.forClass(String.class);

		@Mock private AdapterService mAdapterService = null;

		@Before
		public void setUp() throws Exception {
		mTargetContext = InstrumentationRegistry.getTargetContext();
		// Set up mocks and test assets
		MockitoAnnotations.initMocks(this);

		TestUtils.setAdapterService(mAdapterService);

		if (Looper.myLooper() == null) {
		Looper.prepare();
		}

		mAdapter = BluetoothAdapter.getDefaultAdapter();
		mSdpManager = SdpManager.init(mAdapterService);

		// Get a device for testing
		mTestDevice = mAdapter.getRemoteDevice("00:01:02:03:04:05");
		}

		@After
		public void tearDown() throws Exception {
		}

		private void verifyDipSdpRecordIntent(ArgumentCaptor<Intent> intentArgument,
		int status, BluetoothDevice device,
		byte[] uuid, int specificationId,
		int vendorId, int vendorIdSource,
		int productId, int version,
		boolean primaryRecord) {
		Intent intent = intentArgument.getValue();

		assertThat(intent).isNotEqualTo(null);
		assertThat(BluetoothDevice.ACTION_SDP_RECORD).isEqualTo(intent.getAction());
		assertThat(device).isEqualTo(intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));
		assertThat(Utils.byteArrayToUuid(uuid)[0]).isEqualTo(intent.getParcelableExtra(BluetoothDevice.EXTRA_UUID));
		assertThat(status).isEqualTo(intent.getIntExtra(BluetoothDevice.EXTRA_SDP_SEARCH_STATUS, -1));

		SdpDipRecord record = intent.getParcelableExtra(BluetoothDevice.EXTRA_SDP_RECORD);
		assertThat(record).isNotEqualTo(null);
		assertThat(specificationId).isEqualTo(record.getSpecificationId());
		assertThat(vendorId).isEqualTo(record.getVendorId());
		assertThat(vendorIdSource).isEqualTo(record.getVendorIdSource());
		assertThat(productId).isEqualTo(record.getProductId());
		assertThat(version).isEqualTo(record.getVersion());
		assertThat(primaryRecord).isEqualTo(record.getPrimaryRecord());
		}

		/**
		* Test that an outgoing connection/disconnection succeeds
		*/
		@Test
		@SmallTest
		public void testDipCallbackSuccess() {
		// DIP uuid in bytes
		byte[] uuid = {0, 0, 18, 0, 0, 0, 16, 0, -128, 0, 0, -128, 95, -101, 52, -5};
		int specificationId = 0x0103;
		int vendorId = 0x18d1;
		int vendorIdSource = 1;
		int productId = 0x1234;
		int version = 0x0100;
		boolean primaryRecord = true;
		boolean moreResults = false;

		mSdpManager.sdpSearch(mTestDevice, BluetoothUuid.DIP);
		mSdpManager.sdpDipRecordFoundCallback(AbstractionLayer.BT_STATUS_SUCCESS,
		Utils.getByteAddress(mTestDevice), uuid, specificationId,
		vendorId, vendorIdSource, productId, version, primaryRecord, moreResults);
		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
		verifyDipSdpRecordIntent(mIntentArgument, AbstractionLayer.BT_STATUS_SUCCESS, mTestDevice,
		uuid, specificationId, vendorId, vendorIdSource, productId, version, primaryRecord);
		}
		}