| /****************************************************************************** |
| * |
| * Copyright 2021 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.acm; |
| |
| import static android.Manifest.permission.BLUETOOTH_CONNECT; |
| |
| import static com.android.bluetooth.Utils.enforceBluetoothPrivilegedPermission; |
| |
| import android.bluetooth.BluetoothA2dp; |
| import android.bluetooth.BluetoothA2dp.OptionalCodecsPreferenceStatus; |
| import android.bluetooth.BluetoothA2dp.OptionalCodecsSupportStatus; |
| import android.bluetooth.BluetoothCodecConfig; |
| import android.bluetooth.BluetoothCodecStatus; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothUuid; |
| 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.Handler; |
| import android.os.Binder; |
| import android.os.IBinder; |
| import android.os.ParcelUuid; |
| import android.util.Log; |
| import android.os.Message; |
| import android.bluetooth.BluetoothGroupCallback; |
| import com.android.bluetooth.groupclient.GroupService; |
| import android.bluetooth.DeviceGroup; |
| import android.bluetooth.BluetoothDeviceGroup; |
| import com.android.bluetooth.apm.ActiveDeviceManagerService; |
| import com.android.bluetooth.apm.VolumeManager; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| import android.os.SystemProperties; |
| import com.android.bluetooth.BluetoothMetricsProto; |
| import com.android.bluetooth.BluetoothStatsLog; |
| import com.android.bluetooth.Utils; |
| import android.bluetooth.BluetoothAdapter; |
| import com.android.bluetooth.apm.ApmConst; |
| 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.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.util.ArrayUtils; |
| import java.util.Iterator; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.HashMap; |
| import java.util.Objects; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentMap; |
| import java.util.concurrent.locks.ReentrantReadWriteLock; |
| import com.android.bluetooth.vcp.VcpController; |
| /** |
| * Provides Bluetooth ACM profile, as a service in the Bluetooth application. |
| * @hide |
| */ |
| public class AcmService extends ProfileService { |
| private static final boolean DBG = true; |
| private static final String TAG = "AcmService"; |
| private String mAcmName; |
| public static final int ACM_AUDIO_UNICAST = 25; |
| public static final int INVALID_SET_ID = 0x10; |
| private static AcmService sAcmService; |
| private BluetoothAdapter mAdapter; |
| private AdapterService mAdapterService; |
| private HandlerThread mStateMachinesThread; |
| private static final int LOCK_RELEASED = 0; // (LOCK Released successfully) |
| private static final int LOCK_RELEASED_TIMEOUT = 1; // (LOCK Released by timeout) |
| private static final int ALL_LOCKS_ACQUIRED = 2; // (LOCK Acquired for all requested set members) |
| private static final int SOME_LOCKS_ACQUIRED_REASON_TIMEOUT = 3; // (Request timeout for some set members) |
| private static final int SOME_LOCKS_ACQUIRED_REASON_DISC = 4; // (Some of the set members were disconnected) |
| private static final int LOCK_DENIED = 5; // (Denied by one of the set members) |
| private static final int INVALID_REQUEST_PARAMS = 6; // (Upper layer provided invalid parameters) |
| private static final int LOCK_RELEASE_NOT_ALLOWED = 7; // (Response from remote (PTS)) |
| private static final int INVALID_VALUE = 8; |
| @VisibleForTesting |
| AcmNativeInterface mAcmNativeInterface; |
| @VisibleForTesting |
| ServiceFactory mFactory = new ServiceFactory(); |
| |
| static final int CONTEXT_TYPE_UNKNOWN = 0; |
| static final int CONTEXT_TYPE_MUSIC = 1; |
| static final int CONTEXT_TYPE_VOICE = 2; |
| static final int CONTEXT_TYPE_MUSIC_VOICE = 3; |
| static final int CONTEXT_TYPE_BROADCAST_AUDIO = 6; |
| |
| private AcmCodecConfig mAcmCodecConfig; |
| private final Object mAudioManagerLock = new Object(); |
| private final Object mBtLeaLock = new Object(); |
| private final Object mBtAcmLock = new Object(); |
| private String mLeaChannelMode = "stereo"; |
| private AudioManager mAudioManager; |
| @GuardedBy("mStateMachines") |
| private BluetoothDevice mGroupBdAddress = null; |
| private BluetoothDevice mActiveDevice = null; |
| private BluetoothDevice mActiveDeviceVoice = null; |
| private int mActiveDeviceProfile = 0; |
| private int mActiveDeviceVoiceProfile = 0; |
| private final ConcurrentMap<BluetoothDevice, AcmStateMachine> mStateMachines = |
| new ConcurrentHashMap<>(); |
| private HashMap<BluetoothDevice, BluetoothAcmDevice> mAcmDevices = |
| new HashMap<BluetoothDevice, BluetoothAcmDevice>(); |
| |
| // Upper limit of all ACM devices: Bonded or Connected |
| private static final int MAX_ACM_STATE_MACHINES = 50; |
| // Upper limit of all ACM devices that are Connected or Connecting |
| private int mMaxConnectedAudioDevices = 1; |
| CsipManager mCsipManager = null; |
| boolean mIsCsipRegistered = false; |
| boolean mShoPend = false; |
| boolean mVoiceShoPend = false; |
| //volume |
| private int mAudioStreamMax; |
| private int mActiveDeviceLocalMediaVol; |
| private int mActiveDeviceLocalVoiceVol; |
| private boolean mActiveDeviceIsMuted; |
| private static final int VCP_MAX_VOL = 255; |
| private VcpController mVcpController; |
| |
| private BroadcastReceiver mBondStateChangedReceiver; |
| private final ReentrantReadWriteLock mAcmNativeInterfaceLock = new ReentrantReadWriteLock(); |
| public int mCsipAppId = -1; |
| |
| private static final int SET_EBMONO_CFG = 1; |
| private static final int SET_EBSTEREO_CFG = 2; |
| private static final int MonoCfg_Timeout = 3000; |
| private static final int StereoCfg_Timeout = 3000; |
| private Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) |
| { |
| synchronized(mBtLeaLock) { |
| switch (msg.what) { |
| case SET_EBMONO_CFG: |
| Log.d(TAG, "setparameters to Mono"); |
| synchronized (mAudioManagerLock) { |
| if(mAudioManager != null) |
| mAudioManager.setParameters("LEAMono=true"); |
| } |
| mLeaChannelMode = "mono"; |
| break; |
| case SET_EBSTEREO_CFG: |
| Log.d(TAG, "setparameters to stereo"); |
| synchronized (mAudioManagerLock) { |
| if(mAudioManager != null) |
| mAudioManager.setParameters("LEAMono=false"); |
| } |
| mLeaChannelMode = "stereo"; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| }; |
| |
| @Override |
| protected void create() { |
| Log.i(TAG, "create()"); |
| } |
| |
| @Override |
| protected boolean start() { |
| Log.i(TAG, "start()"); |
| String propValue; |
| |
| if (sAcmService != null) { |
| Log.w(TAG, "AcmService is already running"); |
| return true; |
| } |
| |
| // Step 1: Get AdapterService, AcmNativeInterface. |
| // None of them can be null. |
| mAdapter = BluetoothAdapter.getDefaultAdapter(); |
| mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(), |
| "AdapterService cannot be null when AcmService starts"); |
| mAcmNativeInterface = Objects.requireNonNull(AcmNativeInterface.getInstance(), |
| "AcmNativeInterface cannot be null when AcmService starts"); |
| |
| mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(), |
| "AdapterService cannot be null when StreamAudioService starts"); |
| |
| Log.i(TAG, "mAdapterService.isHostAdvAudioUnicastFeatureSupported() returned " |
| + mAdapterService.isHostAdvAudioUnicastFeatureSupported()); |
| Log.i(TAG, "mAdapterService.isHostAdvAudioStereoRecordingFeatureSupported() returned " |
| + mAdapterService.isHostAdvAudioStereoRecordingFeatureSupported()); |
| Log.i(TAG, "mAdapterService.isAdvUnicastAudioFeatEnabled() returned " |
| + mAdapterService.isAdvUnicastAudioFeatEnabled()); |
| |
| // SOC supports unicast, host supports unicast and stereo recording |
| if (mAdapterService.isHostAdvAudioUnicastFeatureSupported() && |
| mAdapterService.isHostAdvAudioStereoRecordingFeatureSupported() && |
| mAdapterService.isAdvUnicastAudioFeatEnabled()) { |
| |
| Log.i(TAG, "SOC supports unicast, host supports unicast, stereo recording"); |
| // set properties only if they are not set to allow user enable/disable |
| // the features explicitly |
| propValue = SystemProperties.get("persist.vendor.service.bt.bap.enable_ucast"); |
| |
| if (propValue == null || propValue.length() == 0 || !propValue.equals("false")) { |
| SystemProperties.set("persist.vendor.service.bt.bap.enable_ucast", "true"); |
| } else { |
| Log.i(TAG, "persist.vendor.service.bt.bap.enable_ucast is already set to " |
| + propValue); |
| } |
| |
| propValue = SystemProperties.get("persist.vendor.service.bt.recording_supported"); |
| if (propValue == null || propValue.length() == 0 || !propValue.equals("false")) { |
| SystemProperties.set("persist.vendor.service.bt.recording_supported", "true"); |
| Log.i(TAG, "persist.vendor.service.bt.recording_supported set to true"); |
| } else { |
| Log.i(TAG, "persist.vendor.service.bt.recording_supported is already set to " |
| + propValue); |
| } |
| } |
| |
| Log.i(TAG, "mAdapterService.isHostQHSFeatureSupported() returned " |
| + mAdapterService.isHostQHSFeatureSupported()); |
| |
| // SOC supports unicast, host supports unicast and QHS |
| if (mAdapterService.isHostAdvAudioUnicastFeatureSupported() && |
| mAdapterService.isHostQHSFeatureSupported() && |
| mAdapterService.isAdvUnicastAudioFeatEnabled()) { |
| |
| Log.i(TAG, "SOC supports unicast, host supports unicast, QHS"); |
| // set properties only if they are not set to allow user enable/disable |
| // the features explicitly |
| propValue = SystemProperties.get("persist.vendor.btstack.qhs_enable"); |
| |
| if (propValue == null || propValue.length() == 0 || !propValue.equals("false")) { |
| SystemProperties.set("persist.vendor.btstack.qhs_enable", "true"); |
| } else { |
| Log.i(TAG, "persist.vendor.service.bt.bap.enable_ucast is already set to " |
| + propValue); |
| } |
| } |
| |
| Log.i(TAG, "isHostAdvAudioLC3QFeatureSupported(): " |
| + mAdapterService.isHostAdvAudioLC3QFeatureSupported()); |
| |
| // SOC supports unicast, host supports unicast and LC3Q |
| if (mAdapterService.isHostAdvAudioUnicastFeatureSupported() && |
| mAdapterService.isHostAdvAudioLC3QFeatureSupported() && |
| mAdapterService.isAdvUnicastAudioFeatEnabled()) { |
| |
| Log.i(TAG, "host supports LC3Q"); |
| // set properties only if they are not set to allow user enable/disable |
| // the features explicitly |
| propValue = SystemProperties.get("persist.vendor.service.bt.is_lc3q_supported"); |
| |
| if (propValue == null || propValue.length() == 0 || !propValue.equals("false")) { |
| SystemProperties.set("persist.vendor.service.bt.is_lc3q_supported", "true"); |
| } else { |
| Log.i(TAG, "persist.vendor.service.bt.is_lc3q_supported is already set to " |
| + propValue); |
| } |
| } |
| |
| // Step 2: Get maximum number of connected audio devices |
| mMaxConnectedAudioDevices = mAdapterService.getMaxConnectedAudioDevices(); |
| Log.i(TAG, "Max connected audio devices set to " + mMaxConnectedAudioDevices); |
| |
| |
| String LeaChannelMode = SystemProperties.get("persist.vendor.btstack.Lea.defaultchannelmode"); |
| if (!LeaChannelMode.isEmpty() && "mono".equals(LeaChannelMode)) { |
| mLeaChannelMode = "mono"; |
| } |
| Log.d(TAG, "Default LEA ChannelMode: " + LeaChannelMode); |
| // Step 3: Start handler thread for state machines |
| mStateMachines.clear(); |
| mStateMachinesThread = new HandlerThread("AcmService.StateMachines"); |
| mStateMachinesThread.start(); |
| |
| // Step 4: Setup codec config |
| mAcmCodecConfig = new AcmCodecConfig(this, mAcmNativeInterface); |
| |
| if (mAdapterService.isAdvUnicastAudioFeatEnabled()) { |
| Log.d(TAG, "Initialize AcmNativeInterface"); |
| // Step 5: Initialize native interface |
| mAcmNativeInterface.init(mMaxConnectedAudioDevices, |
| mAcmCodecConfig.codecConfigPriorities()); |
| } |
| |
| // Step 6: Setup broadcast receivers |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); |
| mBondStateChangedReceiver = new BondStateChangedReceiver(); |
| registerReceiver(mBondStateChangedReceiver, filter); |
| synchronized (mAudioManagerLock) { |
| mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); |
| Objects.requireNonNull(mAudioManager, |
| "AudioManager cannot be null when AcmService starts"); |
| mAudioStreamMax = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); |
| } |
| // Step 7: Mark service as started |
| setAcmService(this); |
| |
| //step 8: Register CSIP module |
| mCsipManager = new CsipManager(); |
| |
| //step 9: Get Vcp Controller |
| mVcpController = VcpController.make(this); |
| Objects.requireNonNull(mVcpController, "mVcpController cannot be null when AcmService starts"); |
| return true; |
| } |
| |
| @Override |
| protected boolean stop() { |
| Log.i(TAG, "stop()"); |
| if (sAcmService == null) { |
| Log.w(TAG, "stop() called before start()"); |
| return true; |
| } |
| |
| // Step 9: do quit Vcp Controller |
| if (mVcpController != null) { |
| mVcpController.doQuit(); |
| } |
| |
| // Step 8: Mark service as stopped |
| setAcmService(null); |
| |
| unregisterReceiver(mBondStateChangedReceiver); |
| mBondStateChangedReceiver = null; |
| // Step 6: Cleanup native interface |
| mAcmNativeInterface.cleanup(); |
| mAcmNativeInterface = null; |
| |
| // Step 5: Clear codec config |
| mAcmCodecConfig = null; |
| |
| // Step 4: Destroy state machines and stop handler thread |
| synchronized (mStateMachines) { |
| for (AcmStateMachine sm : mStateMachines.values()) { |
| sm.doQuit(); |
| sm.cleanup(); |
| } |
| mStateMachines.clear(); |
| } |
| mStateMachinesThread.quitSafely(); |
| mStateMachinesThread = null; |
| |
| // Step 2: Reset maximum number of connected audio devices |
| mMaxConnectedAudioDevices = 1; |
| |
| // Step 1: Clear AdapterService, AcmNativeInterface, AudioManager |
| mAcmNativeInterface = null; |
| mAdapterService = null; |
| if (mAcmDevices != null) |
| mAcmDevices.clear(); |
| |
| mCsipManager.unregisterCsip(); |
| mCsipManager = null; |
| return true; |
| } |
| |
| @Override |
| protected void cleanup() { |
| Log.i(TAG, "cleanup()"); |
| } |
| |
| @Override |
| protected IProfileServiceBinder initBinder() { |
| return new AcmBinder(this); |
| } |
| |
| private class BluetoothAcmDevice { |
| private BluetoothDevice mGrpDevice; // group bd address |
| private int mState; |
| private int msetID; |
| |
| BluetoothAcmDevice(BluetoothDevice device, int state, int setID) { |
| mGrpDevice = device; |
| mState = state; |
| msetID = setID; |
| } |
| } |
| |
| private BluetoothDevice getAddressFromString(String address) { |
| return mAdapter.getRemoteDevice(address); |
| } |
| |
| public BluetoothDevice makeGroupBdAddress(BluetoothDevice device, int state, int setid) { |
| Log.i(TAG, " Set id : " + setid + " Num of connected acm devices: " + mAcmDevices.size()); |
| boolean setIdMatched = false; |
| if (setid == INVALID_SET_ID) { |
| Log.d(TAG, "Device is not part of any group"); |
| BluetoothAcmDevice acmDevice = new BluetoothAcmDevice(device, state, setid); |
| mAcmDevices.put(device, acmDevice); |
| mGroupBdAddress = acmDevice.mGrpDevice; |
| return mGroupBdAddress; |
| } |
| // BluetoothDevice bdaddr = null; |
| if (mAcmDevices == null) { |
| Log.d(TAG, "Hash Map is NULL"); |
| return mGroupBdAddress; |
| } |
| if (mAcmDevices.containsKey(device)) { |
| Log.d(TAG, "Device is available in Hash Map"); |
| BluetoothAcmDevice acmDevice = mAcmDevices.get(device); |
| mGroupBdAddress = acmDevice.mGrpDevice; |
| return mGroupBdAddress; |
| } |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if (d.msetID == setid) { |
| setIdMatched = true; |
| Log.d(TAG, "Device is part of same set ID"); |
| BluetoothAcmDevice acmDevice = new BluetoothAcmDevice(d.mGrpDevice, state, setid); |
| mAcmDevices.put(device, acmDevice); |
| mGroupBdAddress = acmDevice.mGrpDevice; |
| break; |
| } |
| } |
| } |
| if (!setIdMatched) { |
| Log.d(TAG, "create new group or device is not part of existing set ID"); |
| String address = "9E:8B:00:00:00:0"; |
| BluetoothDevice bdaddr = getAddressFromString(address + setid); |
| BluetoothAcmDevice acmDevice = new BluetoothAcmDevice(bdaddr, state, setid); |
| mAcmDevices.put(device, acmDevice); |
| mGroupBdAddress = bdaddr; |
| } |
| return mGroupBdAddress; |
| } |
| |
| public void handleAcmDeviceStateChange(BluetoothDevice device, int state, int setid) { |
| Log.d(TAG, "handleAcmDeviceStateChange: device: " + device + ", state: " + state |
| + " Set id : " + setid); |
| Log.i(TAG, " Num of connected ACM devices: " + mAcmDevices.size()); |
| boolean update = false; |
| if (device == null || mAcmDevices.size() == 0) |
| return; |
| BluetoothAcmDevice acmDevice = mAcmDevices.get(device); |
| //check if current active group address is same as this device group address |
| if (acmDevice != null && mGroupBdAddress != acmDevice.mGrpDevice) { |
| Log.d(TAG, "Inactive device is disconnected"); |
| update = true; |
| } |
| if (state == BluetoothProfile.STATE_DISCONNECTED) { |
| Log.d(TAG, "Remove Device from hash map"); |
| mAcmDevices.remove(device); |
| } else { |
| acmDevice.mState = state; |
| Log.d(TAG, "Update state"); |
| } |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if (d.msetID == setid) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| update = true; |
| Log.d(TAG, "Atleast one member is connected"); |
| break; |
| } |
| } |
| } |
| if (!update) { |
| /*if (!mAcmNativeInterface.setActiveDevice(null, 0)) {//send unknown context type |
| Log.w(TAG, "setActiveDevice(null): Cannot remove active device in native layer"); |
| }*/ |
| } |
| } |
| |
| public static synchronized AcmService getAcmService() { |
| if (sAcmService == null) { |
| Log.w(TAG, "getAcmService(): service is null"); |
| return null; |
| } |
| if (!sAcmService.isAvailable()) { |
| Log.w(TAG, "getAcmService(): service is not available"); |
| return null; |
| } |
| return sAcmService; |
| } |
| |
| private static synchronized void setAcmService(AcmService instance) { |
| if (DBG) { |
| Log.d(TAG, "setAcmService(): set to: " + instance); |
| } |
| sAcmService = instance; |
| } |
| |
| public boolean connect(BluetoothDevice device, int contextType, |
| int profileType, int preferredContext) { |
| |
| if (DBG) { |
| Log.d(TAG, "connect(): " + device + " contextType: " + contextType |
| + " profileType: " + profileType + " preferredContext: " + preferredContext); |
| } |
| if (device.getAddress().contains("9E:8B:00:00:00")) { |
| Log.d(TAG, "Connect request for group"); |
| byte[] addrByte = Utils.getByteAddress(device); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> d = mCsipManager.getSetMembers(set_id); |
| if (d == null) { |
| Log.d(TAG, "No set member found"); |
| return false; |
| } |
| Iterator<BluetoothDevice> members = d.iterator(); |
| if (members != null) { |
| while (members.hasNext()) { |
| BluetoothDevice addr = members.next(); |
| Log.d(TAG, "connect member: " + addr); |
| synchronized (mStateMachines) { |
| if (!connectionAllowedCheckMaxDevices(addr)) { |
| // when mMaxConnectedAudioDevices is one, disconnect current device first. |
| if (mMaxConnectedAudioDevices == 1) { |
| List<BluetoothDevice> sinks = getDevicesMatchingConnectionStates( |
| new int[] {BluetoothProfile.STATE_CONNECTED, |
| BluetoothProfile.STATE_CONNECTING, |
| BluetoothProfile.STATE_DISCONNECTING}); |
| for (BluetoothDevice sink : sinks) { |
| if (sink.equals(addr)) { |
| Log.w(TAG, "Connecting to device " + addr + " : disconnect skipped"); |
| continue; |
| } |
| disconnect(sink, contextType); |
| } |
| } else { |
| Log.e(TAG, "Cannot connect to " + addr + " : too many connected devices"); |
| return false; |
| } |
| } |
| AcmStateMachine smConnect = getOrCreateStateMachine(addr); |
| if (smConnect == null) { |
| Log.e(TAG, "Cannot connect to " + addr + " : no state machine"); |
| return false; |
| } |
| Message msg = smConnect.obtainMessage(AcmStateMachine.CONNECT); |
| msg.obj = preferredContext; |
| msg.arg1 = contextType; |
| msg.arg2 = profileType; |
| smConnect.sendMessage(msg); |
| } |
| } |
| } |
| return true; |
| } |
| synchronized (mStateMachines) { |
| if (!connectionAllowedCheckMaxDevices(device)) { |
| // when mMaxConnectedAudioDevices is one, disconnect current device first. |
| if (mMaxConnectedAudioDevices == 1) { |
| List<BluetoothDevice> sinks = getDevicesMatchingConnectionStates( |
| new int[] {BluetoothProfile.STATE_CONNECTED, |
| BluetoothProfile.STATE_CONNECTING, |
| BluetoothProfile.STATE_DISCONNECTING}); |
| for (BluetoothDevice sink : sinks) { |
| if (sink.equals(device)) { |
| Log.w(TAG, "Connecting to device " + device + " : disconnect skipped"); |
| continue; |
| } |
| disconnect(sink, contextType); |
| } |
| } else { |
| Log.e(TAG, "Cannot connect to " + device + " : too many connected devices"); |
| return false; |
| } |
| } |
| AcmStateMachine smConnect = getOrCreateStateMachine(device); |
| if (smConnect == null) { |
| Log.e(TAG, "Cannot connect to " + device + " : no state machine"); |
| return false; |
| } |
| Message msg = smConnect.obtainMessage(AcmStateMachine.CONNECT); |
| msg.obj = preferredContext; |
| msg.arg1 = contextType; |
| msg.arg2 = profileType; |
| smConnect.sendMessage(msg); |
| return true; |
| } |
| } |
| |
| /** |
| * Disconnects Acm for the remote bluetooth device |
| * |
| * @param device is the device with which we would like to disconnect acm |
| * @return true if profile disconnected, false if device not connected over acm |
| */ |
| public boolean disconnect(BluetoothDevice device, int contextType) { |
| |
| if (DBG) { |
| Log.d(TAG, "disconnect(): " + device); |
| } |
| |
| if (device.getAddress().contains("9E:8B:00:00:00")) { |
| Log.d(TAG, "Disonnect request for group"); |
| byte[] addrByte = Utils.getByteAddress(device); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> d = mCsipManager.getSetMembers(set_id); |
| if (d == null) { |
| Log.d(TAG, "No set member found"); |
| return false; |
| } |
| Iterator<BluetoothDevice> members = d.iterator(); |
| if (members != null) { |
| while (members.hasNext()) { |
| BluetoothDevice addr = members.next(); |
| Log.d(TAG, "disconnect member: " + device); |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(addr); |
| if (sm == null) { |
| Log.e(TAG, "Ignored disconnect request for " + addr + " : no state machine"); |
| return false; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.DISCONNECT); |
| msg.obj = contextType; |
| sm.sendMessage(msg); |
| } |
| } |
| return true; |
| } |
| } |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| Log.e(TAG, "Ignored disconnect request for " + device + " : no state machine"); |
| return false; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.DISCONNECT); |
| msg.obj = contextType; |
| sm.sendMessage(msg); |
| return true; |
| } |
| } |
| |
| public List<BluetoothDevice> getConnectedDevices() { |
| |
| synchronized (mStateMachines) { |
| List<BluetoothDevice> devices = new ArrayList<>(); |
| for (AcmStateMachine sm : mStateMachines.values()) { |
| if (sm.isConnected()) { |
| devices.add(sm.getDevice()); |
| } |
| } |
| return devices; |
| } |
| } |
| |
| //check if it can be a list ? |
| public BluetoothDevice getCsipLockRequestedDevice() { |
| |
| synchronized (mStateMachines) { |
| BluetoothDevice device = null; |
| for (AcmStateMachine sm : mStateMachines.values()) { |
| if (sm.isCsipLockRequested()) { |
| device = sm.getDevice(); |
| } |
| } |
| return device; |
| } |
| } |
| |
| public boolean IsLockSupportAvailable(BluetoothDevice device) { |
| boolean isLockSupported = false; |
| /*int setId = mSetCoordinator.getRemoteSetId(device, ACM_UUID); |
| DeviceGroup set = mSetCoordinator.getDeviceGroup(setId); |
| isLockSupported = set.mLockSupport;*/ |
| //isLockSupported = mAdapterService.isCsipLockSupport(device); |
| Log.d(TAG, "Exclusive Access SupportAvaible for:" + device + "returns " + isLockSupported); |
| return isLockSupported; |
| } |
| |
| /** |
| * Check whether can connect to a peer device. |
| * The check considers the maximum number of connected peers. |
| * |
| * @param device the peer device to connect to |
| * @return true if connection is allowed, otherwise false |
| */ |
| private boolean connectionAllowedCheckMaxDevices(BluetoothDevice device) { |
| int connected = 0; |
| // Count devices that are in the process of connecting or already connected |
| synchronized (mStateMachines) { |
| for (AcmStateMachine sm : mStateMachines.values()) { |
| switch (sm.getConnectionState()) { |
| case BluetoothProfile.STATE_CONNECTING: |
| case BluetoothProfile.STATE_CONNECTED: |
| if (Objects.equals(device, sm.getDevice())) { |
| return true; // Already connected or accounted for |
| } |
| connected++; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| return (connected < mMaxConnectedAudioDevices); |
| } |
| |
| List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { |
| |
| List<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) { |
| /*if (!ArrayUtils.contains(mAdapterService.getRemoteUuids(device), |
| BluetoothUuid.ACM_SINK)) { |
| continue; |
| }*/ |
| int connectionState = BluetoothProfile.STATE_DISCONNECTED; |
| AcmStateMachine 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 (AcmStateMachine sm : mStateMachines.values()) { |
| devices.add(sm.getDevice()); |
| } |
| return devices; |
| } |
| } |
| |
| public int getConnectionState(BluetoothDevice device) { |
| |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return BluetoothProfile.STATE_DISCONNECTED; |
| } |
| return sm.getConnectionState(); |
| } |
| } |
| |
| public int getCsipConnectionState(BluetoothDevice device) { |
| |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return BluetoothProfile.STATE_DISCONNECTED; |
| } |
| return sm.getCsipConnectionState(); |
| } |
| } |
| |
| // Handle messages from native (JNI) to Java |
| void messageFromNative(AcmStackEvent stackEvent) { |
| Objects.requireNonNull(stackEvent.device, |
| "Device should never be null, event: " + stackEvent); |
| synchronized (mStateMachines) { |
| BluetoothDevice device = stackEvent.device; |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| if (stackEvent.type == AcmStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) { |
| switch (stackEvent.valueInt1) { |
| case AcmStackEvent.CONNECTION_STATE_CONNECTED: |
| case AcmStackEvent.CONNECTION_STATE_CONNECTING: |
| // Create a new state machine only when connecting to a device |
| if (!connectionAllowedCheckMaxDevices(device)) { |
| Log.e(TAG, "Cannot connect to " + device |
| + " : too many connected devices"); |
| return; |
| } |
| sm = getOrCreateStateMachine(device); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (sm == null) { |
| Log.e(TAG, "Cannot process stack event: no state machine: " + stackEvent); |
| return; |
| } |
| sm.sendMessage(AcmStateMachine.STACK_EVENT, stackEvent); |
| } |
| } |
| |
| private AcmStateMachine getOrCreateStateMachine(BluetoothDevice device) { |
| if (device == null) { |
| Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null"); |
| return null; |
| } |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm != null) { |
| return sm; |
| } |
| // Limit the maximum number of state machines to avoid DoS attack |
| if (mStateMachines.size() >= MAX_ACM_STATE_MACHINES) { |
| Log.e(TAG, "Maximum number of ACM state machines reached: " |
| + MAX_ACM_STATE_MACHINES); |
| return null; |
| } |
| if (DBG) { |
| Log.d(TAG, "Creating a new state machine for " + device); |
| } |
| sm = AcmStateMachine.make(device, this, mAcmNativeInterface, |
| mStateMachinesThread.getLooper()); |
| mStateMachines.put(device, sm); |
| return sm; |
| } |
| } |
| |
| 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) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return; |
| } |
| if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) { |
| return; |
| } |
| } |
| removeStateMachine(device); |
| } |
| |
| private void removeStateMachine(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| AcmStateMachine 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); |
| mAcmDevices.remove(device); |
| } |
| } |
| |
| void updateLeaChannelMode(int state, BluetoothDevice device) { |
| BluetoothDevice peerLeaDevice = null; |
| peerLeaDevice = getLeaPeerDevice(device); |
| if (peerLeaDevice == null) { |
| Log.d(TAG, "updateLeaChannelMode: peer device is NULL"); |
| return; |
| } |
| Log.d(TAG, "LeaChannelMode: " + mLeaChannelMode + "state: " + state); |
| synchronized(mBtLeaLock) { |
| if ("mono".equals(mLeaChannelMode)) { |
| if ((state == BluetoothA2dp.STATE_PLAYING) && (peerLeaDevice!= null) |
| && peerLeaDevice.isConnected() && isAcmPlayingMusic(peerLeaDevice)) { |
| Log.d(TAG, "updateLeaChannelMode: send delay message to set stereo "); |
| Message msg = mHandler.obtainMessage(SET_EBSTEREO_CFG); |
| mHandler.sendMessageDelayed(msg, StereoCfg_Timeout); |
| } else if (state == BluetoothA2dp.STATE_PLAYING) { |
| Log.d(TAG, "updateLeaChannelMode: setparameters to Mono"); |
| synchronized (mAudioManagerLock) { |
| if (mAudioManager != null) { |
| Log.d(TAG, "updateLeaChannelMode: Acquired mVariableLock"); |
| mAudioManager.setParameters("LeaChannelConfig=mono"); |
| } |
| } |
| Log.d(TAG, "updateLeaChannelMode: Released mVariableLock"); |
| } |
| if ((state == BluetoothA2dp.STATE_NOT_PLAYING) && |
| isAcmPlayingMusic(peerLeaDevice)) { |
| if (mHandler.hasMessages(StereoCfg_Timeout)) { |
| Log.d(TAG, "updateLeaChannelMode:remove delay message for stereo"); |
| mHandler.removeMessages(StereoCfg_Timeout); |
| } |
| } |
| } else if ("stereo".equals(mLeaChannelMode)) { |
| if ((state == BluetoothA2dp.STATE_PLAYING) && |
| (getConnectionState(peerLeaDevice) != BluetoothProfile.STATE_CONNECTED |
| || !isAcmPlayingMusic(peerLeaDevice))) { |
| Log.d(TAG, "updateLeaChannelMode: send delay message to set mono"); |
| Message msg = mHandler.obtainMessage(SET_EBMONO_CFG); |
| mHandler.sendMessageDelayed(msg, MonoCfg_Timeout); |
| } |
| if ((state == BluetoothA2dp.STATE_PLAYING) && isAcmPlayingMusic(peerLeaDevice)) { |
| if (mHandler.hasMessages(SET_EBMONO_CFG)) { |
| Log.d(TAG, "updateLeaChannelMode: remove delay message to set mono"); |
| mHandler.removeMessages(SET_EBMONO_CFG); |
| } |
| } |
| if ((state == BluetoothA2dp.STATE_NOT_PLAYING) && isAcmPlayingMusic(peerLeaDevice)) { |
| Log.d(TAG, "setparameters to Mono"); |
| synchronized (mAudioManagerLock) { |
| if (mAudioManager != null) |
| mAudioManager.setParameters("LeaChannelConfig=mono"); |
| } |
| mLeaChannelMode = "mono"; |
| } |
| } |
| } |
| } |
| |
| private BluetoothDevice getLeaPeerDevice(BluetoothDevice device) { |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return null; |
| } |
| return sm.getPeerDevice(); |
| } |
| } |
| |
| public boolean isPeerDeviceConnected(BluetoothDevice device, int setid) { |
| boolean isConnected = false; |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if ((d.msetID == setid) && !Objects.equals(dm, device)) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| isConnected = true; |
| Log.d(TAG, "At least one member is in connected state"); |
| break; |
| } |
| } |
| } |
| } |
| return isConnected; |
| } |
| |
| public boolean isPeerDeviceStreamingMusic(BluetoothDevice device, int setid) { |
| boolean isStreaming = false; |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if ((d.msetID == setid) && !Objects.equals(dm, device)) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| synchronized (mBtAcmLock) { |
| AcmStateMachine sm = mStateMachines.get(dm); |
| if (sm == null) { |
| return false; |
| } |
| if (sm.isMusicPlaying()) { |
| isStreaming = true; |
| Log.d(TAG, "At least one member is streaming for music"); |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| return isStreaming; |
| } |
| |
| public boolean isShoPendingStop() { |
| Log.d(TAG, "isShoPendingStop " + mShoPend); |
| return mShoPend; |
| } |
| |
| public void resetShoPendingStop() { |
| mShoPend = false; |
| } |
| |
| public boolean isVoiceShoPendingStop() { |
| Log.d(TAG, "isVoiceShoPendingStop " + mVoiceShoPend); |
| return mVoiceShoPend; |
| } |
| |
| public void resetVoiceShoPendingStop() { |
| mVoiceShoPend = false; |
| } |
| |
| public BluetoothDevice getVoiceActiveDevice() { |
| return mActiveDeviceVoice; |
| } |
| |
| public void removePeersFromBgWl(BluetoothDevice device, int setid) { |
| synchronized (mStateMachines) { |
| BluetoothDevice d = null; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(setid); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| d = i.next(); |
| if (!(Objects.equals(d, device))) { |
| Log.d(TAG, "Device: " + d); |
| AcmStateMachine sm = mStateMachines.get(d); |
| if (sm == null) { |
| return; |
| } |
| sm.removeDevicefromBgWL(); |
| } |
| } |
| } |
| } |
| } |
| |
| public boolean isAcmPlayingMusic(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "isAcmPlayingMusic(" + device + ")"); |
| } |
| synchronized (mBtAcmLock) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return false; |
| } |
| return sm.isMusicPlaying(); |
| } |
| } |
| |
| public boolean isAcmPlayingVoice(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "isAcmPlayingVoice(" + device + ")"); |
| } |
| synchronized (mBtAcmLock) { |
| AcmStateMachine sm = mStateMachines.get(device); |
| if (sm == null) { |
| return false; |
| } |
| return sm.isVoicePlaying(); |
| } |
| } |
| |
| public BluetoothDevice getGroup(BluetoothDevice device) { |
| Log.d(TAG, "Get group address for (" + device + ")"); |
| if (device.getAddress().contains("9E:8B:00:00:00")) { |
| Log.d(TAG, "Called for group address"); |
| return device; |
| } |
| BluetoothDevice dm = null; |
| |
| if (mAcmDevices != null) { |
| Log.d(TAG, "Hash Map is not NULL"); |
| BluetoothAcmDevice d = mAcmDevices.get(device); |
| if (d != null) |
| dm = d.mGrpDevice; |
| } |
| if (dm == null) { |
| Log.d(TAG, "Group address is NULL, make New"); |
| int Id = mCsipManager.getCsipSetId(device, null /*ACM_UUID*/); //TODO: UUID what to set ? |
| dm = makeGroupBdAddress(device, BluetoothProfile.STATE_DISCONNECTED, Id); |
| } |
| return dm; |
| } |
| |
| public int setActiveDevice(BluetoothDevice device, int contextType, int profileType, boolean playReq) { |
| |
| Log.d(TAG, "setActiveDevice: " + device + " contextType: " + contextType + " profileType: " + profileType + |
| " play req: " + playReq + " mActiveDeviceProfile: " + mActiveDeviceProfile+ " mActiveDeviceVoiceProfile: " + mActiveDeviceVoiceProfile); |
| |
| if (Objects.equals(device, mActiveDevice) && contextType == CONTEXT_TYPE_MUSIC && (mActiveDeviceProfile == profileType)) { |
| Log.e(TAG, "setActiveDevice(" + device + "): already set to active for media and profileType same as active profile"); |
| return ActiveDeviceManagerService.ALREADY_ACTIVE; |
| } |
| if (Objects.equals(device, mActiveDeviceVoice) && contextType == CONTEXT_TYPE_VOICE && (mActiveDeviceVoiceProfile == profileType)) { |
| Log.e(TAG, "setActiveDevice(" + device + "): already set to active for voice and profileType same as active profile"); |
| return ActiveDeviceManagerService.ALREADY_ACTIVE; |
| } |
| if (contextType == CONTEXT_TYPE_MUSIC) { |
| mShoPend = false; |
| if ((device == null) && (mActiveDevice != null)) { |
| if (mActiveDevice.getAddress().contains("9E:8B:00:00:00")) { |
| byte[] addrByte = Utils.getByteAddress(mActiveDevice); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(set_id); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| Log.d(TAG, "isAcmPlayingMusic(addr) " + isAcmPlayingMusic(addr)); |
| if (isAcmPlayingMusic(addr)) { |
| mShoPend = true; |
| break; |
| } |
| } |
| } |
| } else { |
| Log.d(TAG, "TWM active device"); |
| mShoPend = isAcmPlayingMusic(mActiveDevice); |
| } |
| } |
| Log.d(TAG, "mShoPend " + mShoPend); |
| } else if (contextType == CONTEXT_TYPE_VOICE) { |
| mVoiceShoPend = false; |
| if (mActiveDeviceVoice != null) { |
| if (mActiveDeviceVoice.getAddress().contains("9E:8B:00:00:00")) { |
| byte[] addrByte = Utils.getByteAddress(mActiveDeviceVoice); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(set_id); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| Log.d(TAG, "isAcmPlayingVoice(addr) " + isAcmPlayingVoice(addr)); |
| if (isAcmPlayingVoice(addr)) { |
| mVoiceShoPend = true; |
| break; |
| } |
| } |
| } |
| } else { |
| Log.d(TAG, "TWM active device"); |
| mVoiceShoPend = isAcmPlayingVoice(mActiveDeviceVoice); |
| } |
| } |
| Log.d(TAG, "mVoiceShoPend " + mVoiceShoPend); |
| } |
| Log.d(TAG, "old mActiveDevice: " + mActiveDevice + " & old mActiveDeviceVoice: " + mActiveDeviceVoice); |
| |
| if (setActiveDeviceAcm(device, contextType, profileType)) { |
| if (contextType == CONTEXT_TYPE_MUSIC) { |
| mActiveDevice = device; |
| mActiveDeviceProfile = profileType; |
| } else if (contextType == CONTEXT_TYPE_VOICE) { |
| mActiveDeviceVoice = device; |
| mActiveDeviceVoiceProfile = profileType; |
| } |
| Log.d(TAG, "new mActiveDevice: " + mActiveDevice + " & new mActiveDeviceVoice: " + mActiveDeviceVoice); |
| if(!playReq) { |
| if (mShoPend || mVoiceShoPend) { |
| Log.d(TAG, "setActiveDevice(" + device + "): returns with status " + ActiveDeviceManagerService.SHO_PENDING); |
| return ActiveDeviceManagerService.SHO_PENDING; |
| } else { |
| Log.d(TAG, "setActiveDevice(" + device + "): returns with status " + ActiveDeviceManagerService.SHO_SUCCESS); |
| return ActiveDeviceManagerService.SHO_SUCCESS; |
| } |
| } else { |
| Log.d(TAG, "setActiveDevice(" + device + "): returns with status " + ActiveDeviceManagerService.SHO_PENDING); |
| return ActiveDeviceManagerService.SHO_PENDING; |
| } |
| } |
| Log.d(TAG, "setActiveDevice(" + device + "): returns with status " + ActiveDeviceManagerService.SHO_FAILED); |
| mShoPend = false; |
| mVoiceShoPend = false; |
| return ActiveDeviceManagerService.SHO_FAILED; |
| } |
| |
| private boolean setActiveDeviceAcm(BluetoothDevice device, int contextType, int profileType) { |
| Log.d(TAG, "setActiveDeviceAcm: " + device); |
| try { |
| mAcmNativeInterfaceLock.readLock().lock(); |
| if (mAcmNativeInterface != null && !mAcmNativeInterface.setActiveDevice(device, profileType)) { |
| Log.e(TAG, "setActiveDevice(" + device + "): Cannot set as active in native layer"); |
| return false; |
| } |
| } finally { |
| mAcmNativeInterfaceLock.readLock().unlock(); |
| } |
| Log.d(TAG, "setActiveDeviceAcm(" + device + "): returns true"); |
| return true; |
| } |
| |
| public void setCodecConfigPreference(BluetoothDevice device, |
| BluetoothCodecConfig codecConfig, int contextType) { |
| |
| if (DBG) { |
| Log.d(TAG, "setCodecConfigPreference(" + device + "): " |
| + Objects.toString(codecConfig)); |
| } |
| mAcmCodecConfig.setCodecConfigPreference(device, codecConfig, contextType); |
| } |
| |
| public void ChangeCodecConfigPreference(BluetoothDevice device, |
| String mesg) { |
| |
| if (DBG) { |
| Log.d(TAG, "ChangeCodecConfigPreference " + device + "string: " + mesg); |
| } |
| if (device == null) |
| return; |
| mAcmName = mesg; |
| synchronized (mStateMachines) { |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if (Objects.equals(device, d.mGrpDevice)) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| AcmStateMachine sm = getOrCreateStateMachine(dm); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CODEC_CONFIG_CHANGED); |
| msg.obj = d.msetID; |
| sm.sendMessage(msg); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| public boolean StartStream(BluetoothDevice device, int contextType) { |
| if (DBG) { |
| Log.d(TAG, "startStream for " + device+ " context type: " + contextType); |
| } |
| if (device == null) |
| return false; |
| synchronized (mStateMachines) { |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if (Objects.equals(device, d.mGrpDevice)) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| AcmStateMachine sm = getOrCreateStateMachine(dm); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.START_STREAM); |
| msg.obj = contextType; |
| sm.sendMessage(msg); |
| } |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| public boolean StopStream(BluetoothDevice device, int contextType) { |
| if (DBG) { |
| Log.d(TAG, "stopStream for " + device+ " context type: " + contextType); |
| } |
| if (device == null) |
| return false; |
| synchronized (mStateMachines) { |
| if (mAcmDevices.size() != 0) { |
| for (BluetoothDevice dm : mAcmDevices.keySet()) { |
| BluetoothAcmDevice d = mAcmDevices.get(dm); |
| if (Objects.equals(device, d.mGrpDevice)) { |
| if (d.mState == BluetoothProfile.STATE_CONNECTED) { |
| AcmStateMachine sm = getOrCreateStateMachine(dm); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.STOP_STREAM); |
| msg.obj = contextType; |
| sm.sendMessage(msg); |
| } |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| public void setAbsoluteVolume(BluetoothDevice grpAddr, int volumeLevel, int audioType) { |
| //Convert volume level to VCP level before sending. |
| int vcpVolume = convertToVcpVolume(volumeLevel); |
| BluetoothDevice activeDevice = null; |
| Log.d(TAG, "AudioVolumeLevel " + volumeLevel + " vcpVolume " + vcpVolume); |
| |
| if (audioType == ApmConst.AudioFeatures.MEDIA_AUDIO || |
| audioType == ApmConst.AudioFeatures.CALL_AUDIO) { |
| ActiveDeviceManagerService activeDeviceManager = |
| ActiveDeviceManagerService.get(this); |
| activeDevice = activeDeviceManager.getActiveDevice(audioType); |
| Log.d(TAG, "activeDevice " + activeDevice + " grpAddr " + grpAddr |
| + " audioType " + audioType); |
| if (!grpAddr.equals(activeDevice)) { |
| Log.e(TAG, "Ignore setAbsoluteVolume for inactive device"); |
| return; |
| } |
| } else if (audioType == ApmConst.AudioFeatures.BROADCAST_AUDIO) { |
| Log.d(TAG, "No active device, grpAddr " + grpAddr + " is broadcast device or group"); |
| } else { |
| Log.e(TAG, "Invalid audio type for set volume, ignore this request"); |
| return; |
| } |
| |
| if (audioType == ApmConst.AudioFeatures.MEDIA_AUDIO) { |
| mActiveDeviceLocalMediaVol = volumeLevel; |
| } else if (audioType == ApmConst.AudioFeatures.CALL_AUDIO) { |
| mActiveDeviceLocalVoiceVol = volumeLevel; |
| } |
| |
| if (grpAddr.getAddress().contains("9E:8B:00:00:00")) { |
| Log.d(TAG, "setAbsoluteVolume for group addr, send abs vol to all members"); |
| byte[] addrByte = Utils.getByteAddress(grpAddr); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(set_id); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| Log.d(TAG, "send vol to member: " + addr); |
| mVcpController.setAbsoluteVolume(addr, vcpVolume, audioType); |
| } |
| } |
| } else { |
| Log.d(TAG, "setAbsoluteVolume for single addr, send abs vol to " + grpAddr); |
| mVcpController.setAbsoluteVolume(grpAddr, vcpVolume, audioType); |
| } |
| } |
| |
| public void setMute(BluetoothDevice grpAddr, boolean enableMute) { |
| if (mActiveDevice == null) { |
| Log.d(TAG, "No active device set, this grpAddr " + grpAddr + " is broadcast group"); |
| } else { |
| Log.d(TAG, "mActiveDevice " + mActiveDevice + " grpAddr " + grpAddr); |
| } |
| |
| if (grpAddr.getAddress().contains("9E:8B:00:00:00")) { |
| Log.d(TAG, "setMute for group addr, send mute/unmute to all members"); |
| byte[] addrByte = Utils.getByteAddress(grpAddr); |
| int set_id = addrByte[5]; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(set_id); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| Log.d(TAG, "send setMute to member: " + addr); |
| mVcpController.setMute(addr, enableMute); |
| } |
| } |
| } else { |
| Log.d(TAG, "setMute for single addr, send mute/unmute to " + grpAddr); |
| mVcpController.setMute(grpAddr, enableMute); |
| } |
| } |
| |
| public void onVolumeStateChanged(BluetoothDevice device, int vol, int audioType) { |
| VolumeManager service = VolumeManager.get(); |
| //Get or Make group address |
| BluetoothDevice grpDev = getGroup(device); |
| |
| if (audioType == ApmConst.AudioFeatures.BROADCAST_AUDIO) { |
| Log.d(TAG, "volume notification for Broadcast audio"); |
| } else if (audioType == ApmConst.AudioFeatures.MEDIA_AUDIO) { |
| Log.d(TAG, "volume notification for Media audio"); |
| } else if (audioType == ApmConst.AudioFeatures.CALL_AUDIO) { |
| Log.d(TAG, "volume notification for Call audio"); |
| } else { |
| // remote volume change case |
| Log.d(TAG, "Volume change from remote: " + device + " vcp vol " + vol); |
| audioType = service.getActiveAudioType(device); |
| } |
| |
| //Convert vol |
| int audioVolume = convertToAudioStreamVolume(vol); |
| Log.d(TAG, "vcp vol " + vol + " audioVolume " + audioVolume); |
| |
| if (audioType == ApmConst.AudioFeatures.BROADCAST_AUDIO) { |
| Log.d(TAG, "update volume to APM for Broadcast audio"); |
| service.onVolumeChange(grpDev, audioVolume, audioType); |
| } else if (audioType == ApmConst.AudioFeatures.MEDIA_AUDIO) { |
| //Check if new vol is diff than active group vol |
| Log.d(TAG, "new vol: " + audioVolume + " mActiveDeviceLocalMediaVol: " + mActiveDeviceLocalMediaVol); |
| if (mActiveDeviceLocalMediaVol != audioVolume) { |
| Log.d(TAG, "new vol is different than mActiveDeviceLocalMediaVol update APM"); |
| service.onVolumeChange(grpDev, audioVolume, audioType); |
| mActiveDeviceLocalMediaVol = audioVolume; |
| } else { |
| Log.d(TAG, "local active media vol same as device new vol, ignore sending to APM"); |
| } |
| } else if (audioType == ApmConst.AudioFeatures.CALL_AUDIO) { |
| Log.d(TAG, "new vol: " + audioVolume + " mActiveDeviceLocalVoiceVol: " + mActiveDeviceLocalVoiceVol); |
| if (mActiveDeviceLocalVoiceVol != audioVolume) { |
| Log.d(TAG, "new vol is different than mActiveDeviceLocalVoiceVol update APM"); |
| service.onVolumeChange(grpDev, audioVolume, audioType); |
| mActiveDeviceLocalVoiceVol = audioVolume; |
| } else { |
| Log.d(TAG, "local active call vol same as device new vol, ignore sending to APM"); |
| } |
| } else { |
| Log.d(TAG, "No audio is streaming and is inactive device, ignore sending to APM"); |
| } |
| |
| //Check if this device is group device, then take lock (ignored for now) and update vol to other members as well. |
| applyVolToOtherMembers(device, mCsipManager.getCsipSetId(device, null /*ACM_UUID*/), vol, audioType); |
| } |
| |
| public void onMuteStatusChanged(BluetoothDevice device, boolean isMuted) { |
| VolumeManager service = VolumeManager.get(); |
| //Get or Make group address |
| BluetoothDevice grpDev = getGroup(device); |
| //default context type |
| int c_type = CONTEXT_TYPE_UNKNOWN; |
| |
| Log.d(TAG, "isMuted " + isMuted + " mActiveDeviceIsMuted " + mActiveDeviceIsMuted); |
| |
| if (!mVcpController.isBroadcastDevice(device) && ((mActiveDevice == null) || (mActiveDevice != grpDev))) { |
| Log.d(TAG, "unicast-mode, either Active device null or muteStatus changed for inactive device -- return"); |
| return; |
| } |
| |
| if ((mActiveDevice == null) || (mActiveDevice != grpDev)) { |
| Log.d(TAG, "No Active device or device is not active, seems in Broadcast mode"); |
| c_type = CONTEXT_TYPE_BROADCAST_AUDIO; |
| } else { |
| Log.d(TAG, "mActiveDevice " + mActiveDevice + " grpDev " + grpDev + " device " + device); |
| c_type = CONTEXT_TYPE_MUSIC; |
| } |
| |
| //Check if new mute state is diff than active group mute state |
| if (mActiveDeviceIsMuted != isMuted) { |
| Log.d(TAG, "new mute state is different than mActiveDeviceIsMuted update APM"); |
| service.onMuteStatusChange(grpDev, isMuted, CONTEXT_TYPE_MUSIC); |
| mActiveDeviceIsMuted = isMuted; |
| } else { |
| Log.d(TAG, "local active device mute state same as device new mute state, ignore sending to APM, but send to other members"); |
| } |
| |
| //Check if this device is group device, then take lock(ignored for now) and update mute state to other members as well. |
| applyMuteStateToOtherMembers(device, mCsipManager.getCsipSetId(device, null /*ACM_UUID*/), isMuted); |
| } |
| |
| public void setAbsVolSupport(BluetoothDevice device, boolean isAbsVolSupported, int initialVol) { |
| VolumeManager service = VolumeManager.get(); |
| //Get or Make group address |
| BluetoothDevice grpDev = getGroup(device); |
| if (grpDev == null) { |
| Log.d(TAG, "Group not created, return"); |
| return; |
| } |
| if ((mVcpController.getConnectionState(device) == BluetoothProfile.STATE_CONNECTED) && isAbsVolSupported) { |
| if (!isVcpPeerDeviceConnected(device, mCsipManager.getCsipSetId(device, null /*ACM_UUID*/))) { |
| Log.d(TAG, "VCP Peer device not connected, this is 1st member, update support to APM "); |
| //get current vol from VCP and send to APM during connection. |
| Log.d(TAG, "VCP initialVol " + initialVol + " when connected device " + device); |
| Log.d(TAG, "Update APM with connection vol " + convertToAudioStreamVolume(initialVol)); |
| service.setAbsoluteVolumeSupport(grpDev, isAbsVolSupported, convertToAudioStreamVolume(initialVol), ApmConst.AudioProfiles.VCP); |
| |
| //get current mute state from VCP and sent to APM during connection. |
| Log.d(TAG, "VCP mute state " + mVcpController.isMute(device) + " when connected device " + device); |
| service.onMuteStatusChange(grpDev, mVcpController.isMute(device), CONTEXT_TYPE_MUSIC); |
| } else { |
| Log.d(TAG, "VCP Peer device connected, this is not 1st member, skip update to APM"); |
| } |
| } else if ((mVcpController.getConnectionState(device) == BluetoothProfile.STATE_DISCONNECTED) && !isAbsVolSupported) { |
| if (isVcpPeerDeviceConnected(device, mCsipManager.getCsipSetId(device, null /*ACM_UUID*/))) { |
| Log.d(TAG, "VCP Peer device connected, this is not last member, skip update to APM "); |
| } else { |
| Log.d(TAG, "VCP Peer device not connected, this is last member, update to APM"); |
| service.setAbsoluteVolumeSupport(grpDev, isAbsVolSupported, ApmConst.AudioProfiles.VCP); |
| } |
| } |
| } |
| |
| public boolean isVcpPeerDeviceConnected(BluetoothDevice device, int setid) { |
| boolean isVcpPeerConnected = false; |
| if (setid == INVALID_SET_ID) |
| return isVcpPeerConnected; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(setid); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return isVcpPeerConnected; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| if (!Objects.equals(addr, device) && (mVcpController.getConnectionState(addr) == BluetoothProfile.STATE_CONNECTED)) { |
| isVcpPeerConnected = true; |
| Log.d(TAG, "At least one other vcp member is in connected state"); |
| break; |
| } |
| } |
| } |
| return isVcpPeerConnected; |
| } |
| |
| private int convertToAudioStreamVolume(int volume) { |
| // Rescale volume to match AudioSystem's volume |
| return (int) Math.round((double) volume * mAudioStreamMax / VCP_MAX_VOL); |
| } |
| |
| private int convertToVcpVolume(int volume) { |
| return (int) Math.ceil((double) volume * VCP_MAX_VOL / mAudioStreamMax); |
| } |
| |
| private void applyVolToOtherMembers(BluetoothDevice device, int setid, int volume, int audioType) { |
| if (setid == INVALID_SET_ID) |
| return; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(setid); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| if (!Objects.equals(addr, device)) { |
| Log.d(TAG, "send vol changed to addr " + addr); |
| mVcpController.setAbsoluteVolume(addr, volume, audioType); |
| } |
| } |
| } |
| } |
| |
| private void applyMuteStateToOtherMembers(BluetoothDevice device, int setid, boolean muteState) { |
| if (setid == INVALID_SET_ID) |
| return; |
| List<BluetoothDevice> members = mCsipManager.getSetMembers(setid); |
| if (members == null) { |
| Log.d(TAG, "No set member found"); |
| return; |
| } |
| Iterator<BluetoothDevice> i = members.iterator(); |
| if (i != null) { |
| while (i.hasNext()) { |
| BluetoothDevice addr = i.next(); |
| if (!Objects.equals(addr, device)) { |
| Log.d(TAG, "send mute state to addr " + addr); |
| mVcpController.setMute(addr, muteState); |
| } |
| } |
| } |
| } |
| |
| public int getVcpConnState(BluetoothDevice device) { |
| return mVcpController.getConnectionState(device); |
| } |
| |
| public int getVcpConnMode(BluetoothDevice device) { |
| return mVcpController.getConnectionMode(device); |
| } |
| |
| public boolean isVcpMute(BluetoothDevice device) { |
| return mVcpController.isMute(device); |
| } |
| |
| public String getAcmName() { |
| return mAcmName; |
| } |
| |
| private static class AcmBinder extends Binder implements IProfileServiceBinder { |
| AcmBinder(AcmService service) { |
| } |
| @Override |
| public void cleanup() { |
| } |
| } |
| |
| private BluetoothGroupCallback mBluetoothGroupCallback = new BluetoothGroupCallback() { |
| public void onGroupClientAppRegistered(int status, int appId) { |
| Log.d(TAG, "onGroupClientAppRegistered, status: " + status + "appId: " + appId); |
| if (status == 0) { |
| mCsipManager.updateAppId(appId); |
| mIsCsipRegistered = true; |
| } else { |
| Log.e(TAG, "DeviceGroup registeration failed, status:" + status); |
| } |
| } |
| |
| public void onConnectionStateChanged (int state, BluetoothDevice device) { |
| Log.d(TAG, "onConnectionStateChanged: Device: " + device + "state: " + state); |
| //notify statemachine about device connection state |
| synchronized (mStateMachines) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_CONNECTION_STATE_CHANGED); |
| msg.obj = state; |
| sm.sendMessage(msg); |
| } |
| } |
| |
| public void onExclusiveAccessChanged (int setId, int value, int status, |
| List<BluetoothDevice> devices) { |
| Log.d(TAG, "onExclusiveAccessChanged: setId" + setId + devices + "status:" + status); |
| |
| //notify the statemachine about CSIP Lock status |
| switch (status) { |
| case ALL_LOCKS_ACQUIRED: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_LOCKED); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| break; |
| } |
| |
| case SOME_LOCKS_ACQUIRED_REASON_TIMEOUT: //check if need to handle separately |
| case SOME_LOCKS_ACQUIRED_REASON_DISC: { |
| BluetoothDevice mDevice = getCsipLockRequestedDevice(); |
| if (devices.contains(mDevice)) { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_PARTIAL_LOCK); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } else { |
| Log.d(TAG, "Exclusive access requested device is not present in list, release access for all devices"); |
| mCsipManager.setLock(setId, devices, mCsipManager.UNLOCK); |
| } |
| } break; |
| |
| case LOCK_DENIED: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_DENIED); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } break; |
| |
| case LOCK_RELEASED: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_RELEASED); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } break; |
| |
| case LOCK_RELEASED_TIMEOUT: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_RELEASED); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } break; |
| |
| /*case INVALID_REQUEST_PARAMS: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_INVALID_PARAM); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } break;*/ |
| |
| /*case LOCK_RELEASE_NOT_ALLOWED: { |
| synchronized (mStateMachines) { |
| for (BluetoothDevice device : devices) { |
| AcmStateMachine sm = getOrCreateStateMachine(device); |
| if (sm == null) { |
| //TODO:handle this case |
| continue; |
| } |
| Message msg = sm.obtainMessage(AcmStateMachine.CSIP_LOCK_STATUS_RELEASE); |
| msg.obj = setId; |
| msg.arg1 = value; |
| sm.sendMessage(msg); |
| } |
| } |
| } break;*/ |
| |
| case INVALID_VALUE: |
| break; |
| } |
| } |
| |
| //public void onSetMemberFound (int setId, BluetoothDevice device) { } |
| |
| //public void onSetDiscoveryStatusChanged (int setId, int status, int reason) { } |
| |
| //public void onLockAvailable (int setId, BluetoothDevice device) { } |
| |
| //public void onNewSetFound (int setId, BluetoothDevice device, UUID uuid) { } |
| |
| //public void onLockStatusFetched (int setId, int lockStatus) { } |
| }; |
| |
| public CsipManager getCsipManager(){ |
| return mCsipManager; |
| } |
| |
| class CsipManager { |
| public int LOCK = 0; |
| public int UNLOCK = 0; |
| |
| int mCsipAppid; |
| |
| CsipManager() { |
| LOCK = BluetoothDeviceGroup.ACCESS_GRANTED; |
| UNLOCK = BluetoothDeviceGroup.ACCESS_RELEASED; |
| |
| registerCsip(); |
| } |
| |
| CsipManager(BluetoothGroupCallback callbacks) { |
| LOCK = BluetoothDeviceGroup.ACCESS_GRANTED; |
| UNLOCK = BluetoothDeviceGroup.ACCESS_RELEASED; |
| |
| registerCsip(callbacks); |
| } |
| |
| void updateAppId(int id) { |
| mCsipAppid = id; |
| } |
| |
| int getAppId() { |
| return mCsipAppid; |
| } |
| |
| void registerCsip() { |
| GroupService mGroupService = GroupService.getGroupService(); |
| if(mGroupService != null) { |
| Log.i(TAG, "mGroupService is not null, register"); |
| mGroupService.registerGroupClientModule(mBluetoothGroupCallback); |
| } |
| } |
| |
| void registerCsip(BluetoothGroupCallback callbacks) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| if(mGroupService != null) { |
| Log.i(TAG, "mGroupService is not null, register " + callbacks); |
| mGroupService.registerGroupClientModule(callbacks); |
| } |
| } |
| |
| void unregisterCsip() { |
| GroupService mGroupService = GroupService.getGroupService(); |
| if (mGroupService != null) |
| mGroupService.unregisterGroupClientModule(mCsipAppid); |
| } |
| |
| void connectCsip(BluetoothDevice device) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| mGroupService.connect(mCsipAppid, device); |
| } |
| |
| void disconnectCsip(BluetoothDevice device) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| mGroupService.disconnect(mCsipAppid, device); |
| } |
| |
| void setLock(int setId, List<BluetoothDevice> devices, int lockVal) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| mGroupService.setLockValue(mCsipAppid, setId, devices, lockVal); |
| } |
| |
| DeviceGroup getCsipSet(int setId) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| return mGroupService.getCoordinatedSet(setId); |
| } |
| |
| List<BluetoothDevice> getSetMembers(int setId) { |
| DeviceGroup set = getCsipSet(setId); |
| if(set != null) |
| return set.getDeviceGroupMembers(); |
| return null; |
| } |
| |
| int getCsipSetId(BluetoothDevice device, ParcelUuid uuid) { |
| GroupService mGroupService = GroupService.getGroupService(); |
| return mGroupService.getRemoteDeviceGroupId(device, uuid); |
| //return -1; |
| } |
| } |
| } |
