| /* |
| * Copyright (c) 2020, The Linux Foundation. All rights reserved. |
| */ |
| |
| /* |
| * 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.pc; |
| |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothCodecConfig; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothUuid; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.ParcelUuid; |
| import android.os.SystemProperties; |
| import android.os.UserManager; |
| 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 com.android.bluetooth.btservice.ServiceFactory; |
| import com.android.internal.annotations.VisibleForTesting; |
| |
| import java.util.Map; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Objects; |
| |
| public class PCService extends ProfileService{ |
| private static final String TAG = "PCService"; |
| private static final boolean DBG = true; |
| private static final int MAX_PACS_STATE_MACHINES = 50; |
| |
| private HandlerThread mStateMachinesThread; |
| private final HashMap<BluetoothDevice, PacsClientStateMachine> mStateMachines = |
| new HashMap<>(); |
| private BroadcastReceiver mBondStateChangedReceiver; |
| |
| private AdapterService mAdapterService; |
| private PacsClientNativeInterface mNativeInterface; |
| private static PCService sInstance = null; |
| |
| public static final String ACTION_CONNECTION_STATE_CHANGED = |
| "com.android.bluetooth.pacs.action.CONNECTION_STATE_CHANGED"; |
| |
| /** |
| * Get the PCService instance. Returns null if the service hasn't been initialized. |
| */ |
| public static PCService get() { |
| return sInstance; |
| } |
| |
| @Override |
| protected IProfileServiceBinder initBinder() { |
| return null; |
| } |
| |
| @Override |
| protected void create() { |
| if (DBG) { |
| Log.d(TAG, "create()"); |
| } |
| } |
| |
| protected boolean start() { |
| |
| if (DBG) { |
| Log.d(TAG, "start()"); |
| } |
| if (sInstance != null) { |
| Log.w(TAG, "PCService is already running"); |
| return true; |
| } |
| |
| mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(), |
| "AdapterService cannot be null when PCService starts"); |
| mNativeInterface = Objects.requireNonNull(PacsClientNativeInterface.getInstance(), |
| "PacsClientNativeInterface cannot be null when PCService starts"); |
| |
| // Start handler thread for state machines |
| mStateMachines.clear(); |
| mStateMachinesThread = new HandlerThread("PCService.StateMachines"); |
| mStateMachinesThread.start(); |
| mNativeInterface.init(); |
| sInstance = this; |
| |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); |
| mBondStateChangedReceiver = new BondStateChangedReceiver(); |
| registerReceiver(mBondStateChangedReceiver, filter); |
| |
| return true; |
| } |
| |
| @Override |
| protected boolean stop() { |
| if (DBG) { |
| Log.d(TAG, "stop()"); |
| } |
| if (sInstance == null) { |
| Log.w(TAG, "stop() called before start()"); |
| return true; |
| } |
| |
| unregisterReceiver(mBondStateChangedReceiver); |
| |
| // Mark service as stopped |
| sInstance = null; |
| |
| // Destroy state machines and stop handler thread |
| synchronized (mStateMachines) { |
| for (PacsClientStateMachine sm : mStateMachines.values()) { |
| sm.doQuit(); |
| sm.cleanup(); |
| } |
| mStateMachines.clear(); |
| } |
| |
| if (mStateMachinesThread != null) { |
| mStateMachinesThread.quitSafely(); |
| mStateMachinesThread = null; |
| } |
| |
| // Cleanup native interface |
| mNativeInterface.cleanup(); |
| mNativeInterface = null; |
| |
| // Clear AdapterService |
| mAdapterService = null; |
| return true; |
| } |
| |
| @Override |
| protected void cleanup() { |
| if (DBG) { |
| Log.d(TAG, "cleanup()"); |
| } |
| } |
| |
| /** |
| * Get the PCService instance |
| * @return PCService instance |
| */ |
| public static synchronized PCService getPCService() { |
| if (sInstance == null) { |
| Log.w(TAG, "getPCService(): service is NULL"); |
| return null; |
| } |
| |
| return sInstance; |
| } |
| |
| /** |
| * Connects the pacs profile to the passed in device |
| * |
| * @param device is the device with which we will connect the pacs profile |
| * @return true if pacs profile successfully connected, false otherwise |
| */ |
| |
| public boolean connect(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "connect(): " + device); |
| } |
| if (device == null) { |
| return false; |
| } |
| |
| synchronized (mStateMachines) { |
| PacsClientStateMachine smConnect = getOrCreateStateMachine(device); |
| if (smConnect == null) { |
| Log.e(TAG, "Cannot connect to " + device + " : no state machine"); |
| return false; |
| } |
| smConnect.sendMessage(PacsClientStateMachine.CONNECT); |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Disconnects pacs profile for the passed in device |
| * |
| * @param device is the device with which we want to disconnected the pacs profile |
| * @return true if pacs profile successfully disconnected, false otherwise |
| */ |
| |
| public boolean disconnect(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "disconnect(): " + device); |
| } |
| if (device == null) { |
| return false; |
| } |
| synchronized (mStateMachines) { |
| PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.w(TAG, "disconnect: device " + device + " not ever connected/connecting"); |
| return false; |
| } |
| int connectionState = stateMachine.getConnectionState(); |
| if (connectionState != BluetoothProfile.STATE_CONNECTED |
| && connectionState != BluetoothProfile.STATE_CONNECTING) { |
| Log.w(TAG, "disconnect: device " + device |
| + " not connected/connecting, connectionState=" + connectionState); |
| return false; |
| } |
| stateMachine.sendMessage(PacsClientStateMachine.DISCONNECT); |
| } |
| return true; |
| } |
| |
| /** |
| * start pacs disocvery for the passed in device |
| * |
| * @param device is the device with which we want to dicscoer the pacs |
| * @return true if pacs discovery is successfull, false otherwise |
| */ |
| |
| public boolean startPacsDiscovery(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| Log.i(TAG, "startPacsDiscovery: device=" + device + ", " + Utils.getUidPidString()); |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.w(TAG, "startPacsDiscovery: device " + device + " was never connected/connecting"); |
| return false; |
| } |
| if (stateMachine.getConnectionState() != BluetoothProfile.STATE_CONNECTED) { |
| Log.w(TAG, "startPacsDiscovery: profile not connected"); |
| return false; |
| } |
| stateMachine.sendMessage(PacsClientStateMachine.START_DISCOVERY); |
| } |
| return true; |
| } |
| |
| /** |
| * get sink pacs for the passed in device |
| * |
| * @param device is the device with which we want to get sink pacs |
| * @return sink pacs |
| */ |
| |
| public BluetoothCodecConfig[] getSinkPacs(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get Sink Pacs"); |
| return null; |
| } |
| return stateMachine.getSinkPacs(); |
| } |
| } |
| |
| /** |
| * get src pacs for the passed in device |
| * |
| * @param device is the device with which we want to get src pacs |
| * @return src pacs |
| */ |
| |
| public BluetoothCodecConfig[] getSrcPacs(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get Src Pacs"); |
| return null; |
| } |
| return stateMachine.getSinkPacs(); |
| } |
| } |
| |
| /** |
| * get sink locations for the passed in device |
| * |
| * @param device is the device with which we want to get sink location |
| * @return sink locations |
| */ |
| |
| public int getSinklocations(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get sink locations"); |
| return -1; |
| } |
| return stateMachine.getSinklocations(); |
| } |
| } |
| |
| /** |
| * get src locations for the passed in device |
| * |
| * @param device is the device with which we want to get src location |
| * @return src locations |
| */ |
| |
| public int getSrclocations(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get src locations"); |
| return -1; |
| } |
| return stateMachine.getSrclocations(); |
| } |
| } |
| |
| /** |
| * get available contexts for the passed in device |
| * |
| * @param device is the device with which we want to get available contexts |
| * @return avaialable contexts |
| */ |
| |
| public int getAvailableContexts(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get available contexts"); |
| return -1; |
| } |
| return stateMachine.getAvailableContexts(); |
| } |
| } |
| |
| /** |
| * get supported contexts for the passed in device |
| * |
| * @param device is the device with which we want to get supported contexts |
| * @return supported contexts |
| */ |
| |
| public int getSupportedContexts(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| final PacsClientStateMachine stateMachine = mStateMachines.get(device); |
| if (stateMachine == null) { |
| Log.e(TAG, "Failed to get supported contexts"); |
| return -1; |
| } |
| return stateMachine.getSupportedContexts(); |
| } |
| } |
| |
| /** |
| * Get the current connection state of the profile |
| * |
| * @param device is the remote bluetooth device |
| * @return {@link BluetoothProfile#STATE_DISCONNECTED} if this profile is disconnected, |
| * {@link BluetoothProfile#STATE_CONNECTING} if this profile is being connected, |
| * {@link BluetoothProfile#STATE_CONNECTED} if this profile is connected, or |
| * {@link BluetoothProfile#STATE_DISCONNECTING} if this profile is being disconnected |
| */ |
| public int getConnectionState(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| PacsClientStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return BluetoothProfile.STATE_DISCONNECTED; |
| } |
| return sm.getConnectionState(); |
| } |
| } |
| |
| @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) |
| public boolean okToConnect(BluetoothDevice device) { |
| |
| int bondState = mAdapterService.getBondState(device); |
| if (bondState != BluetoothDevice.BOND_BONDED) { |
| Log.w(TAG, "okToConnect: return false, bondState=" + bondState); |
| return false; |
| } |
| return true; |
| } |
| |
| void messageFromNative(PacsClientStackEvent stackEvent) { |
| Objects.requireNonNull(stackEvent.device, |
| "Device should never be null, event: " + stackEvent); |
| |
| synchronized (mStateMachines) { |
| BluetoothDevice device = stackEvent.device; |
| PacsClientStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| if (stackEvent.type == PacsClientStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) { |
| switch (stackEvent.valueInt1) { |
| case PacsClientStackEvent.CONNECTION_STATE_CONNECTED: |
| case PacsClientStackEvent.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(PacsClientStateMachine.STACK_EVENT, stackEvent); |
| } |
| } |
| |
| void onConnectionStateChangedFromStateMachine(BluetoothDevice device, |
| int newState, int prevState) { |
| Log.d(TAG, "onConnectionStateChangedFromStateMachine for device: " + device |
| + " newState: " + newState); |
| |
| synchronized (mStateMachines) { |
| if (newState == BluetoothProfile.STATE_DISCONNECTED) { |
| int bondState = mAdapterService.getBondState(device); |
| if (bondState == BluetoothDevice.BOND_NONE) { |
| removeStateMachine(device); |
| } |
| } else if (newState == BluetoothProfile.STATE_CONNECTED) { |
| Log.d(TAG, "PacsClient get connected with renderer device: " + device); |
| } |
| } |
| } |
| |
| 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) { |
| PacsClientStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return; |
| } |
| if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) { |
| return; |
| } |
| removeStateMachine(device); |
| } |
| } |
| |
| private void removeStateMachine(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| PacsClientStateMachine 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 PacsClientStateMachine getOrCreateStateMachine(BluetoothDevice device) { |
| if (device == null) { |
| Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null"); |
| return null; |
| } |
| synchronized (mStateMachines) { |
| PacsClientStateMachine sm = mStateMachines.get(device); |
| if (sm != null) { |
| return sm; |
| } |
| if (mStateMachines.size() >= MAX_PACS_STATE_MACHINES) { |
| Log.e(TAG, "Maximum number of PACS state machines reached: " |
| + MAX_PACS_STATE_MACHINES); |
| return null; |
| } |
| if (DBG) { |
| Log.d(TAG, "Creating a new state machine for " + device); |
| } |
| sm = PacsClientStateMachine.make(device, this, |
| mNativeInterface, mStateMachinesThread.getLooper()); |
| mStateMachines.put(device, sm); |
| return sm; |
| } |
| } |
| |
| } |
| |
