Merge "bas: add Battery service profile support" am: 8e0ad51615 (242e9db1) · Commits · e / os / android_packages_modules_Bluetooth

android/app/AndroidManifest.xml

+9 −0

Original line number	Diff line number	Diff line
		@@ -497,5 +497,14 @@
		<action android:name="android.telecom.InCallService"/>
		</intent-filter>
		</service>
		<service
		android:process="@string/process"
		android:name=".bas.BatteryService"
		android:enabled="@bool/profile_supported_battery"
		android:exported = "true">
		<intent-filter>
		<action android:name="android.bluetooth.IBluetoothBattery" />
		</intent-filter>
		</service>
		</application>
		</manifest>

android/app/res/values/config.xml

+1 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@
		<bool name="profile_supported_le_call_control">true</bool>
		<bool name="profile_supported_hap_client">true</bool>
		<bool name="profile_supported_bass_client">false</bool>
		<bool name="profile_supported_battery">true</bool>

		<!-- If true, we will require location to be enabled on the device to
		fire Bluetooth LE scan result callbacks in addition to having one

android/app/src/com/android/bluetooth/bas/BatteryService.java

0 → 100644

+652 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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.bas;

		import static android.Manifest.permission.BLUETOOTH_CONNECT;

		import static com.android.bluetooth.Utils.enforceBluetoothPrivilegedPermission;

		import android.annotation.RequiresPermission;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothProfile;
		import android.bluetooth.BluetoothUuid;
		import android.bluetooth.IBluetoothBattery;
		import android.content.AttributionSource;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.os.HandlerThread;
		import android.os.ParcelUuid;
		import android.util.Log;

		import com.android.bluetooth.Utils;
		import com.android.bluetooth.btservice.AdapterService;
		import com.android.bluetooth.btservice.ProfileService;
		import com.android.internal.annotations.VisibleForTesting;
		import com.android.modules.utils.SynchronousResultReceiver;

		import java.lang.ref.WeakReference;
		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;
		import java.util.Objects;

		/**
		* A profile service that connects to the Battery service (BAS) of BLE devices
		*/
		public class BatteryService extends ProfileService {
		private static final boolean DBG = false;
		private static final String TAG = "BatteryService";

		// Timeout for state machine thread join, to prevent potential ANR.
		private static final int SM_THREAD_JOIN_TIMEOUT_MS = 1_000;

		private static final int MAX_BATTERY_STATE_MACHINES = 10;
		private static BatteryService sBatteryService;

		private AdapterService mAdapterService;
		private HandlerThread mStateMachinesThread;
		private final Map<BluetoothDevice, BatteryStateMachine> mStateMachines = new HashMap<>();

		private BroadcastReceiver mBondStateChangedReceiver;

		@Override
		protected IProfileServiceBinder initBinder() {
		return new BluetoothBatteryBinder(this);
		}

		@Override
		protected void create() {
		if (DBG) {
		Log.d(TAG, "create()");
		}
		}

		@Override
		protected boolean start() {
		if (DBG) {
		Log.d(TAG, "start()");
		}
		if (sBatteryService != null) {
		throw new IllegalStateException("start() called twice");
		}

		mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
		"AdapterService cannot be null when BatteryService starts");

		mStateMachines.clear();
		mStateMachinesThread = new HandlerThread("BatteryService.StateMachines");
		mStateMachinesThread.start();

		// Setup broadcast receivers
		IntentFilter filter = new IntentFilter();
		filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
		mBondStateChangedReceiver = new BondStateChangedReceiver();
		registerReceiver(mBondStateChangedReceiver, filter);

		setBatteryService(this);

		return true;
		}

		@Override
		protected boolean stop() {
		if (DBG) {
		Log.d(TAG, "stop()");
		}
		if (sBatteryService == null) {
		Log.w(TAG, "stop() called before start()");
		return true;
		}

		setBatteryService(null);
		// Unregister broadcast receivers
		unregisterReceiver(mBondStateChangedReceiver);
		mBondStateChangedReceiver = null;

		// Destroy state machines and stop handler thread
		synchronized (mStateMachines) {
		for (BatteryStateMachine sm : mStateMachines.values()) {
		sm.doQuit();
		sm.cleanup();
		}
		mStateMachines.clear();
		}


		if (mStateMachinesThread != null) {
		try {
		mStateMachinesThread.quitSafely();
		mStateMachinesThread.join(SM_THREAD_JOIN_TIMEOUT_MS);
		mStateMachinesThread = null;
		} catch (InterruptedException e) {
		// Do not rethrow as we are shutting down anyway
		}
		}

		mAdapterService = null;

		return true;
		}

		@Override
		protected void cleanup() {
		if (DBG) {
		Log.d(TAG, "cleanup()");
		}
		}

		/**
		* Gets the BatteryService instance
		*/
		public static synchronized BatteryService getBatteryService() {
		if (sBatteryService == null) {
		Log.w(TAG, "getBatteryService(): service is NULL");
		return null;
		}

		if (!sBatteryService.isAvailable()) {
		Log.w(TAG, "getBatteryService(): service is not available");
		return null;
		}
		return sBatteryService;
		}

		private static synchronized void setBatteryService(BatteryService instance) {
		if (DBG) {
		Log.d(TAG, "setBatteryService(): set to: " + instance);
		}
		sBatteryService = instance;
		}

		/**
		* Connects to the battery service of the given device.
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		public boolean connect(BluetoothDevice device) {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		if (DBG) {
		Log.d(TAG, "connect(): " + device);
		}
		if (device == null) {
		Log.w(TAG, "Ignore connecting to null device");
		return false;
		}

		if (getConnectionPolicy(device) == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {
		Log.w(TAG, "Cannot connect to " + device + " : policy forbidden");
		return false;
		}
		ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device);
		if (!Utils.arrayContains(featureUuids, BluetoothUuid.BATTERY)) {
		Log.e(TAG, "Cannot connect to " + device
		+ " : Remote does not have Battery UUID");
		return false;
		}

		synchronized (mStateMachines) {
		BatteryStateMachine sm = getOrCreateStateMachine(device);
		if (sm == null) {
		Log.e(TAG, "Cannot connect to " + device + " : no state machine");
		}
		sm.sendMessage(BatteryStateMachine.CONNECT);
		}

		return true;
		}

		/**
		* Disconnects from the battery service of the given device.
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		public boolean disconnect(BluetoothDevice device) {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		if (DBG) {
		Log.d(TAG, "disconnect(): " + device);
		}
		if (device == null) {
		Log.w(TAG, "Ignore disconnecting to null device");
		return false;
		}
		synchronized (mStateMachines) {
		BatteryStateMachine sm = getOrCreateStateMachine(device);
		if (sm != null) {
		sm.sendMessage(BatteryStateMachine.DISCONNECT);
		}
		}

		return true;
		}

		/**
		* Gets devices that battery service is connected.
		* @return
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		public List<BluetoothDevice> getConnectedDevices() {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		synchronized (mStateMachines) {
		List<BluetoothDevice> devices = new ArrayList<>();
		for (BatteryStateMachine sm : mStateMachines.values()) {
		if (sm.isConnected()) {
		devices.add(sm.getDevice());
		}
		}
		return devices;
		}
		}

		/**
		* Check whether it can connect to a peer device.
		* The check considers a number of factors during the evaluation.
		*
		* @param device the peer device to connect to
		* @return true if connection is allowed, otherwise false
		*/
		@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
		public boolean canConnect(BluetoothDevice device) {
		// Check connectionPolicy and accept or reject the connection.
		int connectionPolicy = getConnectionPolicy(device);
		int bondState = mAdapterService.getBondState(device);
		// Allow this connection only if the device is bonded. Any attempt to connect while
		// bonding would potentially lead to an unauthorized connection.
		if (bondState != BluetoothDevice.BOND_BONDED) {
		Log.w(TAG, "canConnect: return false, bondState=" + bondState);
		return false;
		} else if (connectionPolicy != BluetoothProfile.CONNECTION_POLICY_UNKNOWN
		&& connectionPolicy != BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
		// Otherwise, reject the connection if connectionPolicy is not valid.
		Log.w(TAG, "canConnect: return false, connectionPolicy=" + connectionPolicy);
		return false;
		}
		return true;
		}

		/**
		* Called when the connection state of a state machine is changed
		*/
		@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
		public void handleConnectionStateChanged(BatteryStateMachine sm,
		int fromState, int toState) {
		BluetoothDevice device = sm.getDevice();
		if ((sm == null) \|\| (fromState == toState)) {
		Log.e(TAG, "connectionStateChanged: unexpected invocation. device=" + device
		+ " fromState=" + fromState + " toState=" + toState);
		return;
		}

		// Check if the device is disconnected - if unbonded, remove the state machine
		if (toState == BluetoothProfile.STATE_DISCONNECTED) {
		int bondState = mAdapterService.getBondState(device);
		if (bondState == BluetoothDevice.BOND_NONE) {
		if (DBG) {
		Log.d(TAG, device + " is unbonded. Remove state machine");
		}
		removeStateMachine(device);
		}
		}
		}

		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		ArrayList<BluetoothDevice> devices = new ArrayList<>();
		if (states == null) {
		return devices;
		}
		final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices();
		if (bondedDevices == null) {
		return devices;
		}
		synchronized (mStateMachines) {
		for (BluetoothDevice device : bondedDevices) {
		int connectionState = BluetoothProfile.STATE_DISCONNECTED;
		BatteryStateMachine sm = mStateMachines.get(device);
		if (sm != null) {
		connectionState = sm.getConnectionState();
		}
		for (int state : states) {
		if (connectionState == state) {
		devices.add(device);
		break;
		}
		}
		}
		return devices;
		}
		}

		/**
		* Get the list of devices that have state machines.
		*
		* @return the list of devices that have state machines
		*/
		@VisibleForTesting
		List<BluetoothDevice> getDevices() {
		List<BluetoothDevice> devices = new ArrayList<>();
		synchronized (mStateMachines) {
		for (BatteryStateMachine sm : mStateMachines.values()) {
		devices.add(sm.getDevice());
		}
		return devices;
		}
		}

		/**
		* Gets the connection state of the given device's battery service
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
		public int getConnectionState(BluetoothDevice device) {
		enforceCallingOrSelfPermission(BLUETOOTH_CONNECT,
		"Need BLUETOOTH_CONNECT permission");
		synchronized (mStateMachines) {
		BatteryStateMachine sm = mStateMachines.get(device);
		if (sm == null) {
		return BluetoothProfile.STATE_DISCONNECTED;
		}
		return sm.getConnectionState();
		}
		}

		/**
		* Set connection policy of the profile and connects it if connectionPolicy is
		* {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED} or disconnects if connectionPolicy is
		* {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN}
		*
		* <p> The device should already be paired.
		* Connection policy can be one of:
		* {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED},
		* {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN},
		* {@link BluetoothProfile#CONNECTION_POLICY_UNKNOWN}
		*
		* @param device the remote device
		* @param connectionPolicy is the connection policy to set to for this profile
		* @return true on success, otherwise false
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		if (DBG) {
		Log.d(TAG, "Saved connectionPolicy " + device + " = " + connectionPolicy);
		}
		mAdapterService.getDatabase()
		.setProfileConnectionPolicy(device, BluetoothProfile.BATTERY,
		connectionPolicy);
		if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
		connect(device);
		} else if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {
		disconnect(device);
		}
		return true;
		}

		/**
		* Gets the connection policy for the battery service of the given device.
		*/
		@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
		public int getConnectionPolicy(BluetoothDevice device) {
		enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED,
		"Need BLUETOOTH_PRIVILEGED permission");
		return mAdapterService.getDatabase()
		.getProfileConnectionPolicy(device, BluetoothProfile.BATTERY);
		}

		void handleBatteryChanged(BluetoothDevice device, int batteryLevel) {
		mAdapterService.setBatteryLevel(device, batteryLevel);
		}

		private BatteryStateMachine getOrCreateStateMachine(BluetoothDevice device) {
		if (device == null) {
		Log.e(TAG, "getOrCreateGatt failed: device cannot be null");
		return null;
		}
		synchronized (mStateMachines) {
		BatteryStateMachine sm = mStateMachines.get(device);
		if (sm != null) {
		return sm;
		}
		// Limit the maximum number of state machines to avoid DoS attack
		if (mStateMachines.size() >= MAX_BATTERY_STATE_MACHINES) {
		Log.e(TAG, "Maximum number of Battery state machines reached: "
		+ MAX_BATTERY_STATE_MACHINES);
		return null;
		}
		if (DBG) {
		Log.d(TAG, "Creating a new state machine for " + device);
		}
		sm = BatteryStateMachine.make(device, this, mStateMachinesThread.getLooper());
		mStateMachines.put(device, sm);
		return sm;
		}
		}

		// Remove state machine if the bonding for a device is removed
		private class BondStateChangedReceiver extends BroadcastReceiver {
		@Override
		public void onReceive(Context context, Intent intent) {
		if (!BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())) {
		return;
		}
		int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
		BluetoothDevice.ERROR);
		BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
		Objects.requireNonNull(device, "ACTION_BOND_STATE_CHANGED with no EXTRA_DEVICE");
		handleBondStateChanged(device, state);
		}
		}

		/**
		* Process a change in the bonding state for a device.
		*
		* @param device the device whose bonding state has changed
		* @param bondState the new bond state for the device. Possible values are:
		* {@link BluetoothDevice#BOND_NONE},
		* {@link BluetoothDevice#BOND_BONDING},
		* {@link BluetoothDevice#BOND_BONDED},
		* {@link BluetoothDevice#ERROR}.
		*/
		@VisibleForTesting
		void handleBondStateChanged(BluetoothDevice device, int bondState) {
		if (DBG) {
		Log.d(TAG, "Bond state changed for device: " + device + " state: " + bondState);
		}
		// Remove state machine if the bonding for a device is removed
		if (bondState != BluetoothDevice.BOND_NONE) {
		return;
		}

		synchronized (mStateMachines) {
		BatteryStateMachine sm = mStateMachines.get(device);
		if (sm == null) {
		return;
		}
		if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) {
		return;
		}
		removeStateMachine(device);
		}
		}

		private void removeStateMachine(BluetoothDevice device) {
		if (device == null) {
		Log.e(TAG, "removeStateMachine failed: device cannot be null");
		return;
		}
		synchronized (mStateMachines) {
		BatteryStateMachine sm = mStateMachines.remove(device);
		if (sm == null) {
		Log.w(TAG, "removeStateMachine: device " + device
		+ " does not have a state machine");
		return;
		}
		Log.i(TAG, "removeGatt: removing bluetooth gatt for device: " + device);
		sm.doQuit();
		sm.cleanup();
		}
		}

		/**
		* Binder object: must be a static class or memory leak may occur
		*/
		@VisibleForTesting
		static class BluetoothBatteryBinder extends IBluetoothBattery.Stub
		implements IProfileServiceBinder {
		private final WeakReference<BatteryService> mServiceRef;

		@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
		private BatteryService getService(AttributionSource source) {
		BatteryService service = mServiceRef.get();

		if (!Utils.checkCallerIsSystemOrActiveUser(TAG)
		\|\| !Utils.checkServiceAvailable(service, TAG)
		\|\| !Utils.checkConnectPermissionForDataDelivery(service, source, TAG)) {
		return null;
		}
		return service;
		}

		BluetoothBatteryBinder(BatteryService svc) {
		mServiceRef = new WeakReference<>(svc);
		}

		@Override
		public void cleanup() {
		mServiceRef.clear();
		}

		@Override
		public void connect(BluetoothDevice device, AttributionSource source,
		SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		boolean result = false;
		if (service != null) {
		result = service.connect(device);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void disconnect(BluetoothDevice device, AttributionSource source,
		SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		boolean result = false;
		if (service != null) {
		result = service.disconnect(device);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void getConnectedDevices(AttributionSource source,
		SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		List<BluetoothDevice> result = new ArrayList<>();
		if (service != null) {
		enforceBluetoothPrivilegedPermission(service);
		result = service.getConnectedDevices();
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void getDevicesMatchingConnectionStates(int[] states,
		AttributionSource source, SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		List<BluetoothDevice> result = new ArrayList<>();
		if (service != null) {
		result = service.getDevicesMatchingConnectionStates(states);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void getConnectionState(BluetoothDevice device, AttributionSource source,
		SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		int result = BluetoothProfile.STATE_DISCONNECTED;
		if (service != null) {
		result = service.getConnectionState(device);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void setConnectionPolicy(BluetoothDevice device, int connectionPolicy,
		AttributionSource source, SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		boolean result = false;
		if (service != null) {
		result = service.setConnectionPolicy(device, connectionPolicy);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}

		@Override
		public void getConnectionPolicy(BluetoothDevice device, AttributionSource source,
		SynchronousResultReceiver receiver) {
		try {
		BatteryService service = getService(source);
		int result = BluetoothProfile.CONNECTION_POLICY_UNKNOWN;
		if (service != null) {
		result = service.getConnectionPolicy(device);
		}
		receiver.send(result);
		} catch (RuntimeException e) {
		receiver.propagateException(e);
		}
		}
		}

		@Override
		public void dump(StringBuilder sb) {
		super.dump(sb);
		for (BatteryStateMachine sm : mStateMachines.values()) {
		sm.dump(sb);
		}
		}
		}