/* * 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.hearingaid; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothHearingAid; import android.bluetooth.BluetoothProfile; import android.bluetooth.BluetoothUuid; import android.bluetooth.IBluetoothHearingAid; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.media.AudioManager; import android.os.HandlerThread; import android.os.ParcelUuid; import android.provider.Settings; import android.support.annotation.VisibleForTesting; import android.util.Log; import com.android.bluetooth.BluetoothMetricsProto; import com.android.bluetooth.Utils; import com.android.bluetooth.btservice.AdapterService; import com.android.bluetooth.btservice.MetricsLogger; import com.android.bluetooth.btservice.ProfileService; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; /** * Provides Bluetooth HearingAid profile, as a service in the Bluetooth application. * @hide */ public class HearingAidService extends ProfileService { private static final boolean DBG = false; private static final String TAG = "HearingAidService"; // Upper limit of all HearingAid devices: Bonded or Connected private static final int MAX_HEARING_AID_STATE_MACHINES = 10; private static HearingAidService sHearingAidService; private AdapterService mAdapterService; private HandlerThread mStateMachinesThread; private BluetoothDevice mPreviousAudioDevice; @VisibleForTesting HearingAidNativeInterface mHearingAidNativeInterface; @VisibleForTesting AudioManager mAudioManager; private final Map mStateMachines = new HashMap<>(); private final Map mDeviceHiSyncIdMap = new ConcurrentHashMap<>(); private final Map mDeviceCapabilitiesMap = new HashMap<>(); private long mActiveDeviceHiSyncId = BluetoothHearingAid.HI_SYNC_ID_INVALID; private BroadcastReceiver mBondStateChangedReceiver; private BroadcastReceiver mConnectionStateChangedReceiver; @Override protected IProfileServiceBinder initBinder() { return new BluetoothHearingAidBinder(this); } @Override protected void create() { if (DBG) { Log.d(TAG, "create()"); } } @Override protected boolean start() { if (DBG) { Log.d(TAG, "start()"); } if (sHearingAidService != null) { throw new IllegalStateException("start() called twice"); } // Get AdapterService, HearingAidNativeInterface, AudioManager. // None of them can be null. mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(), "AdapterService cannot be null when HearingAidService starts"); mHearingAidNativeInterface = Objects.requireNonNull(HearingAidNativeInterface.getInstance(), "HearingAidNativeInterface cannot be null when HearingAidService starts"); mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); Objects.requireNonNull(mAudioManager, "AudioManager cannot be null when HearingAidService starts"); // Start handler thread for state machines mStateMachines.clear(); mStateMachinesThread = new HandlerThread("HearingAidService.StateMachines"); mStateMachinesThread.start(); // Clear HiSyncId map and capabilities map mDeviceHiSyncIdMap.clear(); mDeviceCapabilitiesMap.clear(); // Setup broadcast receivers IntentFilter filter = new IntentFilter(); filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); mBondStateChangedReceiver = new BondStateChangedReceiver(); registerReceiver(mBondStateChangedReceiver, filter); filter = new IntentFilter(); filter.addAction(BluetoothHearingAid.ACTION_CONNECTION_STATE_CHANGED); mConnectionStateChangedReceiver = new ConnectionStateChangedReceiver(); registerReceiver(mConnectionStateChangedReceiver, filter); // Mark service as started setHearingAidService(this); // Initialize native interface mHearingAidNativeInterface.init(); return true; } @Override protected boolean stop() { if (DBG) { Log.d(TAG, "stop()"); } if (sHearingAidService == null) { Log.w(TAG, "stop() called before start()"); return true; } // Cleanup native interface mHearingAidNativeInterface.cleanup(); mHearingAidNativeInterface = null; // Mark service as stopped setHearingAidService(null); // Unregister broadcast receivers unregisterReceiver(mBondStateChangedReceiver); mBondStateChangedReceiver = null; unregisterReceiver(mConnectionStateChangedReceiver); mConnectionStateChangedReceiver = null; // Destroy state machines and stop handler thread synchronized (mStateMachines) { for (HearingAidStateMachine sm : mStateMachines.values()) { sm.doQuit(); sm.cleanup(); } mStateMachines.clear(); } // Clear HiSyncId map and capabilities map mDeviceHiSyncIdMap.clear(); mDeviceCapabilitiesMap.clear(); if (mStateMachinesThread != null) { mStateMachinesThread.quitSafely(); mStateMachinesThread = null; } // Clear AdapterService, HearingAidNativeInterface mAudioManager = null; mHearingAidNativeInterface = null; mAdapterService = null; return true; } @Override protected void cleanup() { if (DBG) { Log.d(TAG, "cleanup()"); } } /** * Get the HearingAidService instance * @return HearingAidService instance */ public static synchronized HearingAidService getHearingAidService() { if (sHearingAidService == null) { Log.w(TAG, "getHearingAidService(): service is NULL"); return null; } if (!sHearingAidService.isAvailable()) { Log.w(TAG, "getHearingAidService(): service is not available"); return null; } return sHearingAidService; } private static synchronized void setHearingAidService(HearingAidService instance) { if (DBG) { Log.d(TAG, "setHearingAidService(): set to: " + instance); } sHearingAidService = instance; } boolean connect(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission"); if (DBG) { Log.d(TAG, "connect(): " + device); } if (device == null) { return false; } if (getPriority(device) == BluetoothProfile.PRIORITY_OFF) { return false; } ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device); if (!BluetoothUuid.isUuidPresent(featureUuids, BluetoothUuid.HearingAid)) { Log.e(TAG, "Cannot connect to " + device + " : Remote does not have Hearing Aid UUID"); return false; } long hiSyncId = mDeviceHiSyncIdMap.getOrDefault(device, BluetoothHearingAid.HI_SYNC_ID_INVALID); if (hiSyncId != mActiveDeviceHiSyncId && hiSyncId != BluetoothHearingAid.HI_SYNC_ID_INVALID && mActiveDeviceHiSyncId != BluetoothHearingAid.HI_SYNC_ID_INVALID) { for (BluetoothDevice connectedDevice : getConnectedDevices()) { disconnect(connectedDevice); } } synchronized (mStateMachines) { HearingAidStateMachine smConnect = getOrCreateStateMachine(device); if (smConnect == null) { Log.e(TAG, "Cannot connect to " + device + " : no state machine"); } smConnect.sendMessage(HearingAidStateMachine.CONNECT); } for (BluetoothDevice storedDevice : mDeviceHiSyncIdMap.keySet()) { if (device.equals(storedDevice)) { continue; } if (mDeviceHiSyncIdMap.getOrDefault(storedDevice, BluetoothHearingAid.HI_SYNC_ID_INVALID) == hiSyncId) { synchronized (mStateMachines) { HearingAidStateMachine sm = getOrCreateStateMachine(storedDevice); if (sm == null) { Log.e(TAG, "Ignored connect request for " + device + " : no state machine"); continue; } sm.sendMessage(HearingAidStateMachine.CONNECT); } if (hiSyncId == BluetoothHearingAid.HI_SYNC_ID_INVALID && !device.equals(storedDevice)) { break; } } } return true; } boolean disconnect(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission"); if (DBG) { Log.d(TAG, "disconnect(): " + device); } if (device == null) { return false; } long hiSyncId = mDeviceHiSyncIdMap.getOrDefault(device, BluetoothHearingAid.HI_SYNC_ID_INVALID); for (BluetoothDevice storedDevice : mDeviceHiSyncIdMap.keySet()) { if (mDeviceHiSyncIdMap.getOrDefault(storedDevice, BluetoothHearingAid.HI_SYNC_ID_INVALID) == hiSyncId) { synchronized (mStateMachines) { HearingAidStateMachine sm = mStateMachines.get(storedDevice); if (sm == null) { Log.e(TAG, "Ignored disconnect request for " + device + " : no state machine"); continue; } sm.sendMessage(HearingAidStateMachine.DISCONNECT); } if (hiSyncId == BluetoothHearingAid.HI_SYNC_ID_INVALID && !device.equals(storedDevice)) { break; } } } return true; } List getConnectedDevices() { enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); synchronized (mStateMachines) { List devices = new ArrayList<>(); for (HearingAidStateMachine sm : mStateMachines.values()) { if (sm.isConnected()) { devices.add(sm.getDevice()); } } return devices; } } /** * Check whether 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(otherwise = VisibleForTesting.PACKAGE_PRIVATE) public boolean okToConnect(BluetoothDevice device) { // Check if this is an incoming connection in Quiet mode. if (mAdapterService.isQuietModeEnabled()) { Log.e(TAG, "okToConnect: cannot connect to " + device + " : quiet mode enabled"); return false; } // Check priority and accept or reject the connection. // Note: Logic can be simplified, but keeping it this way for readability int priority = getPriority(device); int bondState = mAdapterService.getBondState(device); // If priority is undefined, it is likely that service discovery has not completed and peer // initiated the connection. Allow this connection only if the device is bonded or bonding boolean serviceDiscoveryPending = (priority == BluetoothProfile.PRIORITY_UNDEFINED) && (bondState == BluetoothDevice.BOND_BONDING || bondState == BluetoothDevice.BOND_BONDED); // Also allow connection when device is bonded/bonding and priority is ON/AUTO_CONNECT. boolean isEnabled = (priority == BluetoothProfile.PRIORITY_ON || priority == BluetoothProfile.PRIORITY_AUTO_CONNECT) && (bondState == BluetoothDevice.BOND_BONDED || bondState == BluetoothDevice.BOND_BONDING); if (!serviceDiscoveryPending && !isEnabled) { // Otherwise, reject the connection if no service discovery is pending and priority is // neither PRIORITY_ON nor PRIORITY_AUTO_CONNECT Log.w(TAG, "okToConnect: return false, priority=" + priority + ", bondState=" + bondState); return false; } return true; } List getDevicesMatchingConnectionStates(int[] states) { enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); ArrayList devices = new ArrayList<>(); if (states == null) { return devices; } final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices(); if (bondedDevices == null) { return devices; } synchronized (mStateMachines) { for (BluetoothDevice device : bondedDevices) { final ParcelUuid[] featureUuids = device.getUuids(); if (!BluetoothUuid.isUuidPresent(featureUuids, BluetoothUuid.HearingAid)) { continue; } int connectionState = BluetoothProfile.STATE_DISCONNECTED; HearingAidStateMachine 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 getDevices() { List devices = new ArrayList<>(); synchronized (mStateMachines) { for (HearingAidStateMachine sm : mStateMachines.values()) { devices.add(sm.getDevice()); } return devices; } } int getConnectionState(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); synchronized (mStateMachines) { HearingAidStateMachine sm = mStateMachines.get(device); if (sm == null) { return BluetoothProfile.STATE_DISCONNECTED; } return sm.getConnectionState(); } } /** * Set the priority of the Hearing Aid profile. * * @param device the remote device * @param priority the priority of the profile * @return true on success, otherwise false */ public boolean setPriority(BluetoothDevice device, int priority) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); Settings.Global.putInt(getContentResolver(), Settings.Global.getBluetoothHearingAidPriorityKey(device.getAddress()), priority); if (DBG) { Log.d(TAG, "Saved priority " + device + " = " + priority); } return true; } public int getPriority(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); int priority = Settings.Global.getInt(getContentResolver(), Settings.Global.getBluetoothHearingAidPriorityKey(device.getAddress()), BluetoothProfile.PRIORITY_UNDEFINED); return priority; } void setVolume(int volume) { mHearingAidNativeInterface.setVolume(volume); } long getHiSyncId(BluetoothDevice device) { if (device == null) { return BluetoothHearingAid.HI_SYNC_ID_INVALID; } return mDeviceHiSyncIdMap.getOrDefault(device, BluetoothHearingAid.HI_SYNC_ID_INVALID); } int getCapabilities(BluetoothDevice device) { return mDeviceCapabilitiesMap.getOrDefault(device, -1); } /** * Set the active device. * @param device the new active device * @return true on success, otherwise false */ public boolean setActiveDevice(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission"); if (DBG) { Log.d(TAG, "setActiveDevice:" + device); } synchronized (mStateMachines) { if (device == null) { if (mActiveDeviceHiSyncId != BluetoothHearingAid.HI_SYNC_ID_INVALID) { reportActiveDevice(null); mActiveDeviceHiSyncId = BluetoothHearingAid.HI_SYNC_ID_INVALID; } return true; } if (getConnectionState(device) != BluetoothProfile.STATE_CONNECTED) { Log.e(TAG, "setActiveDevice(" + device + "): failed because device not connected"); return false; } Long deviceHiSyncId = mDeviceHiSyncIdMap.getOrDefault(device, BluetoothHearingAid.HI_SYNC_ID_INVALID); if (deviceHiSyncId != mActiveDeviceHiSyncId) { mActiveDeviceHiSyncId = deviceHiSyncId; reportActiveDevice(device); } } return true; } /** * Get the connected physical Hearing Aid devices that are active * * @return the list of active devices. The first element is the left active * device; the second element is the right active device. If either or both side * is not active, it will be null on that position */ List getActiveDevices() { if (DBG) { Log.d(TAG, "getActiveDevices"); } ArrayList activeDevices = new ArrayList<>(); activeDevices.add(null); activeDevices.add(null); synchronized (mStateMachines) { if (mActiveDeviceHiSyncId == BluetoothHearingAid.HI_SYNC_ID_INVALID) { return activeDevices; } for (BluetoothDevice device : mDeviceHiSyncIdMap.keySet()) { if (getConnectionState(device) != BluetoothProfile.STATE_CONNECTED) { continue; } if (mDeviceHiSyncIdMap.get(device) == mActiveDeviceHiSyncId) { int deviceSide = getCapabilities(device) & 1; if (deviceSide == BluetoothHearingAid.SIDE_RIGHT) { activeDevices.set(1, device); } else { activeDevices.set(0, device); } } } } return activeDevices; } void messageFromNative(HearingAidStackEvent stackEvent) { Objects.requireNonNull(stackEvent.device, "Device should never be null, event: " + stackEvent); if (stackEvent.type == HearingAidStackEvent.EVENT_TYPE_DEVICE_AVAILABLE) { BluetoothDevice device = stackEvent.device; int capabilities = stackEvent.valueInt1; long hiSyncId = stackEvent.valueLong2; if (DBG) { Log.d(TAG, "Device available: device=" + device + " capabilities=" + capabilities + " hiSyncId=" + hiSyncId); } mDeviceCapabilitiesMap.put(device, capabilities); mDeviceHiSyncIdMap.put(device, hiSyncId); return; } synchronized (mStateMachines) { BluetoothDevice device = stackEvent.device; HearingAidStateMachine sm = mStateMachines.get(device); if (sm == null) { if (stackEvent.type == HearingAidStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) { switch (stackEvent.valueInt1) { case HearingAidStackEvent.CONNECTION_STATE_CONNECTED: case HearingAidStackEvent.CONNECTION_STATE_CONNECTING: sm = getOrCreateStateMachine(device); break; default: break; } } } if (sm == null) { Log.e(TAG, "Cannot process stack event: no state machine: " + stackEvent); return; } sm.sendMessage(HearingAidStateMachine.STACK_EVENT, stackEvent); } } private HearingAidStateMachine getOrCreateStateMachine(BluetoothDevice device) { if (device == null) { Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null"); return null; } synchronized (mStateMachines) { HearingAidStateMachine sm = mStateMachines.get(device); if (sm != null) { return sm; } // Limit the maximum number of state machines to avoid DoS attack if (mStateMachines.size() >= MAX_HEARING_AID_STATE_MACHINES) { Log.e(TAG, "Maximum number of HearingAid state machines reached: " + MAX_HEARING_AID_STATE_MACHINES); return null; } if (DBG) { Log.d(TAG, "Creating a new state machine for " + device); } sm = HearingAidStateMachine.make(device, this, mHearingAidNativeInterface, mStateMachinesThread.getLooper()); mStateMachines.put(device, sm); return sm; } } /** * Report the active device change to the active device manager and the media framework. * @param device the new active device; or null if no active device */ private void reportActiveDevice(BluetoothDevice device) { if (DBG) { Log.d(TAG, "reportActiveDevice(" + device + ")"); } Intent intent = new Intent(BluetoothHearingAid.ACTION_ACTIVE_DEVICE_CHANGED); intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device); intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND); sendBroadcast(intent, ProfileService.BLUETOOTH_PERM); if (device == null) { if (DBG) { Log.d(TAG, "Set Hearing Aid audio to disconnected"); } mAudioManager.setHearingAidDeviceConnectionState(mPreviousAudioDevice, BluetoothProfile.STATE_DISCONNECTED); mPreviousAudioDevice = null; } else { if (DBG) { Log.d(TAG, "Set Hearing Aid audio to connected"); } if (mPreviousAudioDevice != null) { mAudioManager.setHearingAidDeviceConnectionState(mPreviousAudioDevice, BluetoothProfile.STATE_DISCONNECTED); } mAudioManager.setHearingAidDeviceConnectionState(device, BluetoothProfile.STATE_CONNECTED); mPreviousAudioDevice = device; } } // 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"); bondStateChanged(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}. */ @VisibleForTesting void bondStateChanged(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) { HearingAidStateMachine sm = mStateMachines.get(device); if (sm == null) { return; } if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) { return; } removeStateMachine(device); } } private void removeStateMachine(BluetoothDevice device) { synchronized (mStateMachines) { HearingAidStateMachine sm = mStateMachines.get(device); if (sm == null) { Log.w(TAG, "removeStateMachine: device " + device + " does not have a state machine"); return; } Log.i(TAG, "removeStateMachine: removing state machine for device: " + device); sm.doQuit(); sm.cleanup(); mStateMachines.remove(device); } } private List getConnectedPeerDevices(long hiSyncId) { List result = new ArrayList<>(); for (BluetoothDevice peerDevice : getConnectedDevices()) { if (getHiSyncId(peerDevice) == hiSyncId) { result.add(peerDevice); } } return result; } @VisibleForTesting synchronized void connectionStateChanged(BluetoothDevice device, int fromState, int toState) { if ((device == null) || (fromState == toState)) { Log.e(TAG, "connectionStateChanged: unexpected invocation. device=" + device + " fromState=" + fromState + " toState=" + toState); return; } if (toState == BluetoothProfile.STATE_CONNECTED) { long myHiSyncId = getHiSyncId(device); if (myHiSyncId == BluetoothHearingAid.HI_SYNC_ID_INVALID || getConnectedPeerDevices(myHiSyncId).size() == 1) { // Log hearing aid connection event if we are the first device in a set // Or when the hiSyncId has not been found MetricsLogger.logProfileConnectionEvent( BluetoothMetricsProto.ProfileId.HEARING_AID); } setActiveDevice(device); } if (fromState == BluetoothProfile.STATE_CONNECTED && getConnectedDevices().isEmpty()) { setActiveDevice(null); } // Check if the device is disconnected - if unbond, 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 unbond. Remove state machine"); } removeStateMachine(device); } } } private class ConnectionStateChangedReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { if (!BluetoothHearingAid.ACTION_CONNECTION_STATE_CHANGED.equals(intent.getAction())) { return; } BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); int toState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1); int fromState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1); connectionStateChanged(device, fromState, toState); } } /** * Binder object: must be a static class or memory leak may occur */ @VisibleForTesting static class BluetoothHearingAidBinder extends IBluetoothHearingAid.Stub implements IProfileServiceBinder { private HearingAidService mService; private HearingAidService getService() { if (!Utils.checkCaller()) { Log.w(TAG, "HearingAid call not allowed for non-active user"); return null; } if (mService != null && mService.isAvailable()) { return mService; } return null; } BluetoothHearingAidBinder(HearingAidService svc) { mService = svc; } @Override public void cleanup() { mService = null; } @Override public boolean connect(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return false; } return service.connect(device); } @Override public boolean disconnect(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return false; } return service.disconnect(device); } @Override public List getConnectedDevices() { HearingAidService service = getService(); if (service == null) { return new ArrayList<>(); } return service.getConnectedDevices(); } @Override public List getDevicesMatchingConnectionStates(int[] states) { HearingAidService service = getService(); if (service == null) { return new ArrayList<>(); } return service.getDevicesMatchingConnectionStates(states); } @Override public int getConnectionState(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return BluetoothProfile.STATE_DISCONNECTED; } return service.getConnectionState(device); } @Override public boolean setActiveDevice(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return false; } return service.setActiveDevice(device); } @Override public List getActiveDevices() { HearingAidService service = getService(); if (service == null) { return new ArrayList<>(); } return service.getActiveDevices(); } @Override public boolean setPriority(BluetoothDevice device, int priority) { HearingAidService service = getService(); if (service == null) { return false; } return service.setPriority(device, priority); } @Override public int getPriority(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return BluetoothProfile.PRIORITY_UNDEFINED; } return service.getPriority(device); } @Override public void setVolume(int volume) { HearingAidService service = getService(); if (service == null) { return; } service.setVolume(volume); } @Override public void adjustVolume(int direction) { // TODO: Remove me? } @Override public int getVolume() { // TODO: Remove me? return 0; } @Override public long getHiSyncId(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return BluetoothHearingAid.HI_SYNC_ID_INVALID; } return service.getHiSyncId(device); } @Override public int getDeviceSide(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return BluetoothHearingAid.SIDE_RIGHT; } return service.getCapabilities(device) & 1; } @Override public int getDeviceMode(BluetoothDevice device) { HearingAidService service = getService(); if (service == null) { return BluetoothHearingAid.MODE_BINAURAL; } return service.getCapabilities(device) >> 1 & 1; } } @Override public void dump(StringBuilder sb) { super.dump(sb); for (HearingAidStateMachine sm : mStateMachines.values()) { sm.dump(sb); } } }