Merge changes from topics "presubmit-am-8c61daffdb4b4416a046c21d4c0e5433",... (64e18366) · Commits · e / os / android_packages_modules_Bluetooth

android/app/res/values/config.xml

+28 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,34 @@
		<integer name="gatt_low_power_min_interval">80</integer>
		<integer name="gatt_low_power_max_interval">100</integer>

		<!-- min/max connection intervals/latencies for companion devices -->
		<!-- Primary companion -->
		<integer name="gatt_high_priority_min_interval_primary">6</integer>
		<integer name="gatt_high_priority_max_interval_primary">8</integer>
		<integer name="gatt_high_priority_latency_primary">45</integer>

		<integer name="gatt_balanced_priority_min_interval_primary">6</integer>
		<integer name="gatt_balanced_priority_max_interval_primary">10</integer>
		<integer name="gatt_balanced_priority_latency_primary">120</integer>

		<integer name="gatt_low_power_min_interval_primary">8</integer>
		<integer name="gatt_low_power_max_interval_primary">10</integer>
		<integer name="gatt_low_power_latency_primary">150</integer>

		<!-- Secondary companion -->
		<integer name="gatt_high_priority_min_interval_secondary">6</integer>
		<integer name="gatt_high_priority_max_interval_secondary">6</integer>
		<integer name="gatt_high_priority_latency_secondary">0</integer>

		<integer name="gatt_balanced_priority_min_interval_secondary">12</integer>
		<integer name="gatt_balanced_priority_max_interval_secondary">12</integer>
		<integer name="gatt_balanced_priority_latency_secondary">30</integer>

		<integer name="gatt_low_power_min_interval_secondary">80</integer>
		<integer name="gatt_low_power_max_interval_secondary">100</integer>
		<integer name="gatt_low_power_latency_secondary">15</integer>
		<!-- ============================================================ -->

		<!-- Specifies latency parameters for high priority, balanced and low power
		GATT configurations. These values represents the number of packets a
		peripheral device is allowed to skip. -->

android/app/src/com/android/bluetooth/btservice/AdapterService.java

+50 −0

Original line number	Diff line number	Diff line
		@@ -300,6 +300,7 @@ public class AdapterService extends Service {
		private ActiveDeviceManager mActiveDeviceManager;
		private DatabaseManager mDatabaseManager;
		private SilenceDeviceManager mSilenceDeviceManager;
		private CompanionManager mBtCompanionManager;
		private AppOpsManager mAppOps;

		private BluetoothSocketManagerBinder mBluetoothSocketManagerBinder;
		@@ -441,6 +442,7 @@ public class AdapterService extends Service {
		getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_LOCAL_IO_CAPS_BLE);
		getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_DYNAMIC_AUDIO_BUFFER);
		mAdapterStateMachine.sendMessage(AdapterState.BREDR_STARTED);
		mBtCompanionManager.loadCompanionInfo();
		}
		break;
		case BluetoothAdapter.STATE_OFF:
		@@ -542,6 +544,8 @@ public class AdapterService extends Service {
		Looper.getMainLooper());
		mSilenceDeviceManager.start();

		mBtCompanionManager = new CompanionManager(this, new ServiceFactory());

		mBluetoothSocketManagerBinder = new BluetoothSocketManagerBinder(this);

		mActivityAttributionService = new ActivityAttributionService();
		@@ -1556,6 +1560,32 @@ public class AdapterService extends Service {
		return !mCleaningUp;
		}

		/**
		* Get an metadata of given device and key
		*
		* @param device Bluetooth device
		* @param key Metadata key
		* @param value Metadata value
		* @return if metadata is set successfully
		*/
		public boolean setMetadata(BluetoothDevice device, int key, byte[] value) {
		if (value == null \|\| value.length > BluetoothDevice.METADATA_MAX_LENGTH) {
		return false;
		}
		return mDatabaseManager.setCustomMeta(device, key, value);
		}

		/**
		* Get an metadata of given device and key
		*
		* @param device Bluetooth device
		* @param key Metadata key
		* @return value of given device and key combination
		*/
		public byte[] getMetadata(BluetoothDevice device, int key) {
		return mDatabaseManager.getCustomMeta(device, key);
		}

		/**
		* Handlers for incoming service calls
		*/
		@@ -3171,6 +3201,10 @@ public class AdapterService extends Service {
		service.mBluetoothKeystoreService.factoryReset();
		}

		if (service.mBtCompanionManager != null) {
		service.mBtCompanionManager.factoryReset();
		}

		return service.factoryResetNative();
		}

		@@ -5458,6 +5492,22 @@ public class AdapterService extends Service {
		return getMetricIdNative(Utils.getByteAddress(device));
		}

		public CompanionManager getCompanionManager() {
		return mBtCompanionManager;
		}

		/**
		* Call for the AdapterService receives bond state change
		*
		* @param device Bluetooth device
		* @param state bond state
		*/
		public void onBondStateChanged(BluetoothDevice device, int state) {
		if (mBtCompanionManager != null) {
		mBtCompanionManager.onBondStateChanged(device, state);
		}
		}

		/**
		* Allow audio low latency
		*

android/app/src/com/android/bluetooth/btservice/BondStateMachine.java

+1 −0

Original line number	Diff line number	Diff line
		@@ -470,6 +470,7 @@ final class BondStateMachine extends StateMachine {
		if (newState == BluetoothDevice.BOND_NONE) {
		intent.putExtra(BluetoothDevice.EXTRA_UNBOND_REASON, reason);
		}
		mAdapterService.onBondStateChanged(device, newState);
		mAdapterService.sendBroadcastAsUser(intent, UserHandle.ALL, BLUETOOTH_CONNECT,
		Utils.getTempAllowlistBroadcastOptions());
		infoLog("Bond State Change Intent:" + device + " " + state2str(oldState) + " => "

android/app/src/com/android/bluetooth/btservice/CompanionManager.java

0 → 100644

+370 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.btservice;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothGatt;
		import android.content.Context;
		import android.content.SharedPreferences;
		import android.util.Log;

		import androidx.annotation.VisibleForTesting;

		import com.android.bluetooth.R;

		import java.util.HashSet;
		import java.util.Set;

		/**
		A CompanionManager to specify parameters between companion devices and regular devices.

		1. A paired device is recognized as a companion device if its METADATA_SOFTWARE_VERSION is
		set to BluetoothDevice.COMPANION_TYPE_PRIMARY or BluetoothDevice.COMPANION_TYPE_SECONDARY.
		2. Only can have one companion device at a time.
		3. Remove bond does not remove the companion device record.
		4. Factory reset Bluetooth removes the companion device.
		5. Companion device has individual GATT connection parameters.
		*/

		public class CompanionManager {
		private static final String TAG = "BluetoothCompanionManager";

		private BluetoothDevice mCompanionDevice;
		private int mCompanionType;

		private final int[] mGattConnHighPrimary;
		private final int[] mGattConnBalancePrimary;
		private final int[] mGattConnLowPrimary;
		private final int[] mGattConnHighSecondary;
		private final int[] mGattConnBalanceSecondary;
		private final int[] mGattConnLowSecondary;
		private final int[] mGattConnHighDefault;
		private final int[] mGattConnBalanceDefault;
		private final int[] mGattConnLowDefault;

		@VisibleForTesting static final int COMPANION_TYPE_NONE = 0;
		@VisibleForTesting static final int COMPANION_TYPE_PRIMARY = 1;
		@VisibleForTesting static final int COMPANION_TYPE_SECONDARY = 2;

		public static final int GATT_CONN_INTERVAL_MIN = 0;
		public static final int GATT_CONN_INTERVAL_MAX = 1;
		public static final int GATT_CONN_LATENCY = 2;

		@VisibleForTesting static final String COMPANION_INFO = "bluetooth_companion_info";
		@VisibleForTesting static final String COMPANION_DEVICE_KEY = "companion_device";
		@VisibleForTesting static final String COMPANION_TYPE_KEY = "companion_type";

		private final AdapterService mAdapterService;
		private final BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();
		private final Set<BluetoothDevice> mMetadataListeningDevices = new HashSet<>();

		public CompanionManager(AdapterService service, ServiceFactory factory) {
		mAdapterService = service;
		mGattConnHighDefault = new int[] {
		service.getResources().getInteger(R.integer.gatt_high_priority_min_interval),
		service.getResources().getInteger(R.integer.gatt_high_priority_max_interval),
		service.getResources().getInteger(R.integer.gatt_high_priority_latency)};
		mGattConnBalanceDefault = new int[] {
		service.getResources().getInteger(R.integer.gatt_balanced_priority_min_interval),
		service.getResources().getInteger(R.integer.gatt_balanced_priority_max_interval),
		service.getResources().getInteger(R.integer.gatt_balanced_priority_latency)};
		mGattConnLowDefault = new int[] {
		service.getResources().getInteger(R.integer.gatt_low_power_min_interval),
		service.getResources().getInteger(R.integer.gatt_low_power_max_interval),
		service.getResources().getInteger(R.integer.gatt_low_power_latency)};

		mGattConnHighPrimary = new int[] {
		service.getResources().getInteger(
		R.integer.gatt_high_priority_min_interval_primary),
		service.getResources().getInteger(
		R.integer.gatt_high_priority_max_interval_primary),
		service.getResources().getInteger(
		R.integer.gatt_high_priority_latency_primary)};
		mGattConnBalancePrimary = new int[] {
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_min_interval_primary),
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_max_interval_primary),
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_latency_primary)};
		mGattConnLowPrimary = new int[] {
		service.getResources().getInteger(R.integer.gatt_low_power_min_interval_primary),
		service.getResources().getInteger(R.integer.gatt_low_power_max_interval_primary),
		service.getResources().getInteger(R.integer.gatt_low_power_latency_primary)};

		mGattConnHighSecondary = new int[] {
		service.getResources().getInteger(
		R.integer.gatt_high_priority_min_interval_secondary),
		service.getResources().getInteger(
		R.integer.gatt_high_priority_max_interval_secondary),
		service.getResources().getInteger(R.integer.gatt_high_priority_latency_secondary)};
		mGattConnBalanceSecondary = new int[] {
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_min_interval_secondary),
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_max_interval_secondary),
		service.getResources().getInteger(
		R.integer.gatt_balanced_priority_latency_secondary)};
		mGattConnLowSecondary = new int[] {
		service.getResources().getInteger(R.integer.gatt_low_power_min_interval_secondary),
		service.getResources().getInteger(R.integer.gatt_low_power_max_interval_secondary),
		service.getResources().getInteger(R.integer.gatt_low_power_latency_secondary)};
		}

		void loadCompanionInfo() {
		synchronized (mMetadataListeningDevices) {
		String address = getCompanionPreferences().getString(COMPANION_DEVICE_KEY, "");

		try {
		mCompanionDevice = mAdapter.getRemoteDevice(address);
		mCompanionType = getCompanionPreferences().getInt(
		COMPANION_TYPE_KEY, COMPANION_TYPE_NONE);
		} catch (IllegalArgumentException e) {
		mCompanionDevice = null;
		mCompanionType = COMPANION_TYPE_NONE;
		}
		}

		if (mCompanionDevice == null) {
		// We don't have any companion phone registered, try look from the bonded devices
		for (BluetoothDevice device : mAdapter.getBondedDevices()) {
		byte[] metadata = mAdapterService.getMetadata(device,
		BluetoothDevice.METADATA_SOFTWARE_VERSION);
		if (metadata == null) {
		continue;
		}
		String valueStr = new String(metadata);
		if ((valueStr.equals(BluetoothDevice.COMPANION_TYPE_PRIMARY)
		\|\| valueStr.equals(BluetoothDevice.COMPANION_TYPE_SECONDARY))) {
		// found the companion device, store and unregister all listeners
		Log.i(TAG, "Found companion device from the database!");
		setCompanionDevice(device, valueStr);
		break;
		}
		registerMetadataListener(device);
		}
		}
		Log.i(TAG, "Companion device is " + mCompanionDevice + ", type=" + mCompanionType);
		}

		final BluetoothAdapter.OnMetadataChangedListener mMetadataListener =
		new BluetoothAdapter.OnMetadataChangedListener() {
		@Override
		public void onMetadataChanged(BluetoothDevice device, int key, byte[] value) {
		String valueStr = new String(value);
		Log.d(TAG, String.format("Metadata updated in Device %s: %d = %s.", device,
		key, value == null ? null : valueStr));
		if (key == BluetoothDevice.METADATA_SOFTWARE_VERSION
		&& (valueStr.equals(BluetoothDevice.COMPANION_TYPE_PRIMARY)
		\|\| valueStr.equals(BluetoothDevice.COMPANION_TYPE_SECONDARY))) {
		setCompanionDevice(device, valueStr);
		}
		}
		};

		private void setCompanionDevice(BluetoothDevice companionDevice, String type) {
		synchronized (mMetadataListeningDevices) {
		Log.i(TAG, "setCompanionDevice: " + companionDevice + ", type=" + type);
		mCompanionDevice = companionDevice;
		mCompanionType = type.equals(BluetoothDevice.COMPANION_TYPE_PRIMARY)
		? COMPANION_TYPE_PRIMARY : COMPANION_TYPE_SECONDARY;

		// unregister all metadata listeners
		for (BluetoothDevice device : mMetadataListeningDevices) {
		try {
		mAdapter.removeOnMetadataChangedListener(device, mMetadataListener);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "failed to unregister metadata listener for "
		+ device + " " + e);
		}
		}
		mMetadataListeningDevices.clear();

		SharedPreferences.Editor pref = getCompanionPreferences().edit();
		pref.putString(COMPANION_DEVICE_KEY, mCompanionDevice.getAddress());
		pref.putInt(COMPANION_TYPE_KEY, mCompanionType);
		pref.apply();
		}
		}

		private SharedPreferences getCompanionPreferences() {
		return mAdapterService.getSharedPreferences(COMPANION_INFO, Context.MODE_PRIVATE);
		}

		/**
		* Bond state change event from the AdapterService
		*
		* @param device the Bluetooth device
		* @param state the new Bluetooth bond state of the device
		*/
		public void onBondStateChanged(BluetoothDevice device, int state) {
		synchronized (mMetadataListeningDevices) {
		if (mCompanionDevice != null) {
		// We already have the companion device, do not care bond state change any more.
		return;
		}
		switch (state) {
		case BluetoothDevice.BOND_BONDING:
		registerMetadataListener(device);
		break;
		case BluetoothDevice.BOND_NONE:
		removeMetadataListener(device);
		break;
		default:
		break;
		}
		}
		}

		private void registerMetadataListener(BluetoothDevice device) {
		synchronized (mMetadataListeningDevices) {
		Log.d(TAG, "register metadata listener: " + device);
		try {
		mAdapter.addOnMetadataChangedListener(
		device, mAdapterService.getMainExecutor(), mMetadataListener);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "failed to register metadata listener for "
		+ device + " " + e);
		}
		mMetadataListeningDevices.add(device);
		}
		}

		private void removeMetadataListener(BluetoothDevice device) {
		synchronized (mMetadataListeningDevices) {
		if (!mMetadataListeningDevices.contains(device)) return;

		Log.d(TAG, "remove metadata listener: " + device);
		try {
		mAdapter.removeOnMetadataChangedListener(device, mMetadataListener);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "failed to unregister metadata listener for "
		+ device + " " + e);
		}
		mMetadataListeningDevices.remove(device);
		}
		}


		/**
		* Method to get the stored companion device
		*
		* @return the companion Bluetooth device
		*/
		public BluetoothDevice getCompanionDevice() {
		return mCompanionDevice;
		}

		/**
		* Method to check whether it is a companion device
		*
		* @param address the address of the device
		* @return true if the address is a companion device, otherwise false
		*/
		public boolean isCompanionDevice(String address) {
		try {
		return isCompanionDevice(mAdapter.getRemoteDevice(address));
		} catch (IllegalArgumentException e) {
		return false;
		}
		}

		/**
		* Method to check whether it is a companion device
		*
		* @param device the Bluetooth device
		* @return true if the device is a companion device, otherwise false
		*/
		public boolean isCompanionDevice(BluetoothDevice device) {
		if (device == null) return false;
		return device.equals(mCompanionDevice);
		}

		/**
		* Method to reset the stored companion info
		*/
		public void factoryReset() {
		synchronized (mMetadataListeningDevices) {
		mCompanionDevice = null;
		mCompanionType = COMPANION_TYPE_NONE;

		SharedPreferences.Editor pref = getCompanionPreferences().edit();
		pref.remove(COMPANION_DEVICE_KEY);
		pref.remove(COMPANION_TYPE_KEY);
		pref.apply();
		}
		}

		/**
		* Gets the GATT connection parameters of the device
		*
		* @param address the address of the Bluetooth device
		* @param type type of the parameter, can be GATT_CONN_INTERVAL_MIN, GATT_CONN_INTERVAL_MAX
		* or GATT_CONN_LATENCY
		* @param priority the priority of the connection, can be
		* BluetoothGatt.CONNECTION_PRIORITY_HIGH, BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER or
		* BluetoothGatt.CONNECTION_PRIORITY_BALANCED
		* @return the connection parameter in integer
		*/
		public int getGattConnParameters(String address, int type, int priority) {
		int companionType = isCompanionDevice(address) ? mCompanionType : COMPANION_TYPE_NONE;
		int parameter;
		switch (companionType) {
		case COMPANION_TYPE_PRIMARY:
		parameter = getGattConnParameterPrimary(type, priority);
		break;
		case COMPANION_TYPE_SECONDARY:
		parameter = getGattConnParameterSecondary(type, priority);
		break;
		default:
		parameter = getGattConnParameterDefault(type, priority);
		break;
		}
		return parameter;
		}

		private int getGattConnParameterPrimary(int type, int priority) {
		switch (priority) {
		case BluetoothGatt.CONNECTION_PRIORITY_HIGH:
		return mGattConnHighPrimary[type];
		case BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER:
		return mGattConnLowPrimary[type];
		}
		return mGattConnBalancePrimary[type];
		}

		private int getGattConnParameterSecondary(int type, int priority) {
		switch (priority) {
		case BluetoothGatt.CONNECTION_PRIORITY_HIGH:
		return mGattConnHighSecondary[type];
		case BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER:
		return mGattConnLowSecondary[type];
		}
		return mGattConnBalanceSecondary[type];
		}

		private int getGattConnParameterDefault(int type, int mode) {
		switch (mode) {
		case BluetoothGatt.CONNECTION_PRIORITY_HIGH:
		return mGattConnHighDefault[type];
		case BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER:
		return mGattConnLowDefault[type];
		}
		return mGattConnBalanceDefault[type];
		}
		}

android/app/src/com/android/bluetooth/gatt/GattService.java

+19 −33

Original line number	Diff line number	Diff line
		@@ -79,6 +79,7 @@ import com.android.bluetooth.Utils;
		import com.android.bluetooth.btservice.AbstractionLayer;
		import com.android.bluetooth.btservice.AdapterService;
		import com.android.bluetooth.btservice.BluetoothAdapterProxy;
		import com.android.bluetooth.btservice.CompanionManager;
		import com.android.bluetooth.btservice.ProfileService;
		import com.android.bluetooth.util.NumberUtils;
		import com.android.internal.annotations.VisibleForTesting;
		@@ -3865,33 +3866,21 @@ public class GattService extends ProfileService {
		// Link supervision timeout is measured in N * 10ms
		int timeout = 500; // 5s

		switch (connectionPriority) {
		case BluetoothGatt.CONNECTION_PRIORITY_HIGH:
		minInterval = getResources().getInteger(R.integer.gatt_high_priority_min_interval);
		maxInterval = getResources().getInteger(R.integer.gatt_high_priority_max_interval);
		latency = getResources().getInteger(R.integer.gatt_high_priority_latency);
		break;

		case BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER:
		minInterval = getResources().getInteger(R.integer.gatt_low_power_min_interval);
		maxInterval = getResources().getInteger(R.integer.gatt_low_power_max_interval);
		latency = getResources().getInteger(R.integer.gatt_low_power_latency);
		break;
		CompanionManager manager =
		AdapterService.getAdapterService().getCompanionManager();

		default:
		// Using the values for CONNECTION_PRIORITY_BALANCED.
		minInterval =
		getResources().getInteger(R.integer.gatt_balanced_priority_min_interval);
		maxInterval =
		getResources().getInteger(R.integer.gatt_balanced_priority_max_interval);
		latency = getResources().getInteger(R.integer.gatt_balanced_priority_latency);
		break;
		}
		minInterval = manager.getGattConnParameters(
		address, CompanionManager.GATT_CONN_INTERVAL_MIN, connectionPriority);
		maxInterval = manager.getGattConnParameters(
		address, CompanionManager.GATT_CONN_INTERVAL_MAX, connectionPriority);
		latency = manager.getGattConnParameters(
		address, CompanionManager.GATT_CONN_LATENCY, connectionPriority);

		if (DBG) {
		Log.d(TAG, "connectionParameterUpdate() - address=" + address + " params="
		+ connectionPriority + " interval=" + minInterval + "/" + maxInterval);
		}
		+ connectionPriority + " interval=" + minInterval + "/" + maxInterval
		+ " timeout=" + timeout);

		gattConnectionParameterUpdateNative(clientIf, address, minInterval, maxInterval, latency,
		timeout, 0, 0);
		}
		@@ -3906,14 +3895,11 @@ public class GattService extends ProfileService {
		return;
		}

		if (DBG) {
		Log.d(TAG, "leConnectionUpdate() - address=" + address + ", intervals="
		+ minInterval + "/" + maxInterval + ", latency=" + peripheralLatency
		+ ", timeout=" + supervisionTimeout + "msec" + ", min_ce="
		+ minConnectionEventLen + ", max_ce=" + maxConnectionEventLen);


		}
		gattConnectionParameterUpdateNative(clientIf, address, minInterval, maxInterval,
		peripheralLatency, supervisionTimeout,
		minConnectionEventLen, maxConnectionEventLen);