| /****************************************************************************** |
| * |
| * 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.apm; |
| |
| import static android.Manifest.permission.BLUETOOTH_CONNECT; |
| |
| import android.bluetooth.BluetoothDevice; |
| import com.android.bluetooth.hfp.HeadsetService; |
| import com.android.bluetooth.hfp.HeadsetA2dpSync; |
| import com.android.bluetooth.apm.ApmConst; |
| import com.android.bluetooth.apm.MediaAudio; |
| import com.android.bluetooth.apm.CallControl; |
| import android.media.AudioManager; |
| import com.android.bluetooth.apm.ActiveDeviceManagerService; |
| import com.android.bluetooth.btservice.AdapterService; |
| import com.android.bluetooth.btservice.ProfileService; |
| import com.android.bluetooth.btservice.AdapterService; |
| import android.bluetooth.BluetoothHeadset; |
| import android.bluetooth.BluetoothProfile; |
| import com.android.bluetooth.Utils; |
| import android.content.Context; |
| import java.lang.Integer; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import android.util.Log; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentMap; |
| import android.content.Intent; |
| import android.os.UserHandle; |
| |
| public class CallAudio { |
| |
| private static CallAudio mCallAudio; |
| private static final String TAG = "APM: CallAudio"; |
| Map<String, CallDevice> mCallDevicesMap; |
| private Context mContext; |
| private AudioManager mAudioManager; |
| private ActiveDeviceManagerService mActiveDeviceManager; |
| private AdapterService mAdapterService; |
| public static final String BLUETOOTH_PERM = android.Manifest.permission.BLUETOOTH; |
| public static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN; |
| public static final String BLUETOOTH_PRIVILEGED = |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED; |
| private static final int MAX_DEVICES = 200; |
| public boolean mVirtualCallStarted; |
| private CallControl mCallControl = null; |
| |
| private CallAudio(Context context) { |
| Log.d(TAG, "Initialization"); |
| mContext = context; |
| mCallDevicesMap = new ConcurrentHashMap<String, CallDevice>(); |
| mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); |
| mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| mAdapterService = AdapterService.getAdapterService(); |
| mCallControl = CallControl.get(); |
| } |
| |
| public static CallAudio init(Context context) { |
| if(mCallAudio == null) { |
| mCallAudio = new CallAudio(context); |
| CallAudioIntf.init(mCallAudio); |
| } |
| return mCallAudio; |
| } |
| |
| public static CallAudio get() { |
| return mCallAudio; |
| } |
| |
| public boolean connect(BluetoothDevice device) { |
| Log.i(TAG, "connect: " + device); |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); |
| if(device == null) |
| return false; |
| boolean status; |
| if (getConnectionPolicy(device) == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) { |
| Log.e(TAG, "Cannot connect to " + device + " : CONNECTION_POLICY_FORBIDDEN"); |
| return false; |
| } |
| |
| DeviceProfileMap dMap = DeviceProfileMap.getDeviceProfileMapInstance(); |
| if (dMap == null) |
| return false; |
| |
| int profileID = dMap.getSupportedProfile(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| if (profileID == ApmConst.AudioProfiles.NONE) { |
| Log.e(TAG, "Can Not connect to " + device + ". Device does not support call service."); |
| return false; |
| } |
| |
| CallDevice mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if(mCallDevice == null) { |
| if(mCallDevicesMap.size() >= MAX_DEVICES) |
| return false; |
| mCallDevice = new CallDevice(device, profileID); |
| mCallDevicesMap.put(device.getAddress(), mCallDevice); |
| } else if(mCallDevice.deviceConnStatus != BluetoothProfile.STATE_DISCONNECTED) { |
| Log.i(TAG, "Device already connected"); |
| return false; |
| } |
| |
| if((ApmConst.AudioProfiles.HFP & profileID) == ApmConst.AudioProfiles.HFP) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if (service == null) { |
| return false; |
| } |
| service.connectHfp(device); |
| } |
| |
| StreamAudioService mStreamService = StreamAudioService.getStreamAudioService(); |
| if(mStreamService != null && |
| (ApmConst.AudioProfiles.BAP_CALL & profileID) == ApmConst.AudioProfiles.BAP_CALL) { |
| mStreamService.connectLeStream(device, profileID); |
| } |
| return true; |
| } |
| |
| public boolean connect(BluetoothDevice device, Boolean allProfiles) { |
| if(allProfiles) { |
| DeviceProfileMap dMap = DeviceProfileMap.getDeviceProfileMapInstance(); |
| if (dMap == null) |
| return false; |
| |
| int profileID = dMap.getSupportedProfile(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| if((ApmConst.AudioProfiles.HFP & profileID) == ApmConst.AudioProfiles.HFP) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if (service == null) { |
| return false; |
| } |
| return service.connectHfp(device); |
| } else { |
| /*Common connect for LE Media and Call handled from StreamAudioService*/ |
| return true; |
| } |
| } |
| |
| return connect(device); |
| } |
| |
| public boolean disconnect(BluetoothDevice device) { |
| Log.i(TAG, " disconnect: " + device); |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission"); |
| CallDevice mCallDevice; |
| |
| if(device == null) |
| return false; |
| |
| mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if(mCallDevice == null) { |
| Log.e(TAG, "Ignore: Device " + device + " not present in list"); |
| return false; |
| } |
| |
| if (mCallDevice.profileConnStatus[CallDevice.SCO_STREAM] != BluetoothProfile.STATE_DISCONNECTED) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if(service != null) { |
| service.disconnectHfp(device); |
| } |
| } |
| |
| if (mCallDevice.profileConnStatus[CallDevice.LE_STREAM] != BluetoothProfile.STATE_DISCONNECTED) { |
| StreamAudioService service = StreamAudioService.getStreamAudioService(); |
| if(service != null) { |
| service.disconnectLeStream(device, true, false); |
| } |
| } |
| |
| return true; |
| } |
| |
| public boolean disconnect(BluetoothDevice device, Boolean allProfiles) { |
| if(allProfiles) { |
| CallDevice mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if(mCallDevice == null) { |
| Log.e(TAG, "Ignore: Device " + device + " not present in list"); |
| return false; |
| } |
| if(mCallDevice.profileConnStatus[CallDevice.SCO_STREAM] != BluetoothProfile.STATE_DISCONNECTED) { |
| return disconnect(device); |
| } else { |
| /*Common connect for LE Media and Call handled from StreamAudioService*/ |
| return true; |
| } |
| } |
| |
| return disconnect(device); |
| } |
| |
| public boolean startScoUsingVirtualVoiceCall() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); |
| Log.d(TAG, "startScoUsingVirtualVoiceCall"); |
| BluetoothDevice mActivedevice = null; |
| int profile; |
| mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| if(mActiveDeviceManager != null) { |
| mActivedevice = mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO); |
| if(mActivedevice == null) { |
| Log.e(TAG, "startScoUsingVirtualVoiceCall failed. Active Device is null"); |
| return false; |
| } |
| } else { |
| return false; |
| } |
| |
| checkA2dpState(); |
| |
| profile = mActiveDeviceManager.getActiveProfile(ApmConst.AudioFeatures.CALL_AUDIO); |
| switch(profile) { |
| case ApmConst.AudioProfiles.HFP: |
| HeadsetService headsetService = HeadsetService.getHeadsetService(); |
| if(headsetService != null) { |
| if(headsetService.startScoUsingVirtualVoiceCall()) { |
| mVirtualCallStarted = true; |
| return true; |
| } |
| } |
| break; |
| case ApmConst.AudioProfiles.BAP_CALL: |
| case ApmConst.AudioProfiles.TMAP_CALL: |
| StreamAudioService mStreamAudioService = StreamAudioService.getStreamAudioService(); |
| if(mStreamAudioService != null) { |
| if(mStreamAudioService.startStream(mActivedevice)) { |
| mVirtualCallStarted = true; |
| mCallControl = CallControl.get(); |
| if (mCallControl != null) { |
| mCallControl.setVirtualCallActive(true); |
| } |
| return true; |
| } |
| } |
| break; |
| default: |
| Log.e(TAG, "Unhandled profile"); |
| break; |
| } |
| |
| Log.e(TAG, "startScoUsingVirtualVoiceCall failed. Device: " + mActivedevice); |
| if(ApmConst.AudioProfiles.HFP != profile) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if(service != null) { |
| service.getHfpA2DPSyncInterface().releaseA2DP(null); |
| } |
| } |
| return false; |
| } |
| |
| public boolean stopScoUsingVirtualVoiceCall() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); |
| Log.d(TAG, "stopScoUsingVirtualVoiceCall"); |
| BluetoothDevice mActivedevice = null; |
| int profile; |
| mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| if(mActiveDeviceManager != null) { |
| mActivedevice = mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO); |
| if(mActivedevice == null) { |
| Log.e(TAG, "stopScoUsingVirtualVoiceCall failed. Active Device is null"); |
| return false; |
| } |
| } else { |
| return false; |
| } |
| |
| profile = mActiveDeviceManager.getActiveProfile(ApmConst.AudioFeatures.CALL_AUDIO); |
| switch(profile) { |
| case ApmConst.AudioProfiles.HFP: |
| HeadsetService headsetService = HeadsetService.getHeadsetService(); |
| if(headsetService != null) { |
| mVirtualCallStarted = false; |
| return headsetService.stopScoUsingVirtualVoiceCall(); |
| } |
| break; |
| case ApmConst.AudioProfiles.BAP_CALL: |
| case ApmConst.AudioProfiles.TMAP_CALL: |
| StreamAudioService mStreamAudioService = StreamAudioService.getStreamAudioService(); |
| if(mStreamAudioService != null) { |
| mVirtualCallStarted = false; |
| mCallControl = CallControl.get(); |
| if (mCallControl != null) { |
| mCallControl.setVirtualCallActive(false); |
| } |
| return mStreamAudioService.stopStream(mActivedevice); |
| } |
| break; |
| default: |
| Log.e(TAG, "Unhandled profile"); |
| break; |
| } |
| |
| Log.e(TAG, "stopScoUsingVirtualVoiceCall failed. Device: " + mActivedevice); |
| return false; |
| } |
| |
| void remoteDisconnectVirtualVoiceCall(BluetoothDevice device) { |
| if(device == null) |
| return; |
| ActiveDeviceManagerService mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| if(device.equals(mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO)) && |
| mActiveDeviceManager.isStableState(ApmConst.AudioFeatures.CALL_AUDIO)) { |
| stopScoUsingVirtualVoiceCall(); |
| } |
| } |
| |
| int getProfile(BluetoothDevice mDevice) { |
| DeviceProfileMap dMap = DeviceProfileMap.getDeviceProfileMapInstance(); |
| int profileID = dMap.getProfile(mDevice, ApmConst.AudioFeatures.CALL_AUDIO); |
| Log.d(TAG," getProfile for device " + mDevice + " profileID " + profileID); |
| return profileID; |
| } |
| |
| void checkA2dpState() { |
| MediaAudio sMediaAudio = MediaAudio.get(); |
| BluetoothDevice sMediaActivedevice = |
| mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.MEDIA_AUDIO); |
| //if(sMediaAudio.isA2dpPlaying(sMediaActivedevice)) { |
| Log.d(TAG," suspendA2DP isA2dpPlaying true " + " for device " + sMediaActivedevice); |
| int profileID = mActiveDeviceManager.getActiveProfile( |
| ApmConst.AudioFeatures.CALL_AUDIO); |
| if(ApmConst.AudioProfiles.HFP != profileID) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if(service != null) { |
| service.getHfpA2DPSyncInterface().suspendA2DP( |
| HeadsetA2dpSync.A2DP_SUSPENDED_BY_CS_CALL, null); |
| } |
| } |
| //} |
| } |
| |
| public boolean connectAudio() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); |
| BluetoothDevice mActivedevice = null; |
| boolean status = false; |
| |
| mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| if(mActiveDeviceManager != null) { |
| mActivedevice = mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO); |
| } |
| Log.i(TAG, "connectAudio: device=" + mActivedevice + ", " + Utils.getUidPidString()); |
| |
| int profileID = mActiveDeviceManager.getActiveProfile(ApmConst.AudioFeatures.CALL_AUDIO); |
| checkA2dpState(); |
| |
| if(ApmConst.AudioProfiles.HFP == profileID) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if (service == null) { |
| status = false; |
| } |
| status = service.connectAudio(mActivedevice); |
| } else if(ApmConst.AudioProfiles.BAP_CALL == profileID) { |
| StreamAudioService service = StreamAudioService.getStreamAudioService(); |
| if(service != null) { |
| status = service.startStream(mActivedevice); |
| } |
| } else { |
| Log.e(TAG, "Unhandled connect audio request for profile: " + profileID); |
| status = false; |
| } |
| |
| if(status == false) { |
| Log.e(TAG, "failed connect audio request for device: " + mActivedevice); |
| if(ApmConst.AudioProfiles.HFP != profileID) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if(service != null) { |
| service.getHfpA2DPSyncInterface().releaseA2DP(null); |
| } |
| } |
| } |
| |
| return status; |
| } |
| |
| public boolean disconnectAudio() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); |
| BluetoothDevice mActivedevice = null; |
| boolean mStatus = false; |
| |
| if(mActiveDeviceManager != null) { |
| mActivedevice = mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO); |
| } |
| Log.i(TAG, "disconnectAudio: device=" + mActivedevice + ", " + Utils.getUidPidString()); |
| |
| int profileID = mActiveDeviceManager.getActiveProfile(ApmConst.AudioFeatures.CALL_AUDIO); |
| |
| if(ApmConst.AudioProfiles.HFP == profileID) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if (service == null) { |
| mStatus = false; |
| } |
| mStatus = service.disconnectAudio(); |
| } else if(ApmConst.AudioProfiles.BAP_CALL == profileID) { |
| StreamAudioService service = StreamAudioService.getStreamAudioService(); |
| if(service != null) { |
| mStatus = service.stopStream(mActivedevice); |
| } |
| } else { |
| Log.e(TAG, "Unhandled disconnectAudio request for profile: " + profileID); |
| mStatus = true; |
| } |
| |
| if(ApmConst.AudioProfiles.HFP != profileID) { |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| if(service != null) { |
| service.getHfpA2DPSyncInterface().releaseA2DP(null); |
| } |
| } |
| return mStatus; |
| } |
| |
| public boolean setConnectionPolicy(BluetoothDevice device, Integer connectionPolicy) { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED, |
| "Need BLUETOOTH_PRIVILEGED permission"); |
| boolean mStatus; |
| |
| Log.d(TAG, "setConnectionPolicy: device=" + device |
| + ", connectionPolicy=" + connectionPolicy + ", " + Utils.getUidPidString()); |
| |
| mStatus = mAdapterService.getDatabase() |
| .setProfileConnectionPolicy(device, BluetoothProfile.HEADSET, connectionPolicy); |
| |
| if (mStatus && |
| connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) { |
| connect(device); |
| } else if (mStatus && |
| connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) { |
| disconnect(device); |
| } |
| return mStatus; |
| } |
| |
| public int getConnectionPolicy(BluetoothDevice device) { |
| if(mAdapterService != null) { |
| int connPolicy; |
| connPolicy = mAdapterService.getDatabase() |
| .getProfileConnectionPolicy(device, BluetoothProfile.HEADSET); |
| Log.d(TAG, "getConnectionPolicy: device=" + device |
| + ", connectionPolicy=" + connPolicy); |
| return connPolicy; |
| } else { |
| return BluetoothProfile.CONNECTION_POLICY_UNKNOWN; |
| |
| } |
| } |
| |
| public int getAudioState(BluetoothDevice device) { |
| if(device == null) |
| return BluetoothHeadset.STATE_AUDIO_DISCONNECTED; |
| CallDevice mCallDevice; |
| mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if (mCallDevice == null) { |
| Log.w(TAG, "getAudioState: device " + device + " was never connected/connecting"); |
| return BluetoothHeadset.STATE_AUDIO_DISCONNECTED; |
| } |
| return mCallDevice.scoStatus; |
| } |
| |
| private List<BluetoothDevice> getNonIdleAudioDevices() { |
| if(mCallDevicesMap.size() == 0) { |
| return new ArrayList<>(0); |
| } |
| |
| ArrayList<BluetoothDevice> devices = new ArrayList<>(); |
| for (CallDevice mCallDevice : mCallDevicesMap.values()) { |
| if (mCallDevice.scoStatus != BluetoothHeadset.STATE_AUDIO_DISCONNECTED) { |
| devices.add(mCallDevice.mDevice); |
| } |
| } |
| return devices; |
| } |
| |
| public boolean isAudioOn() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| int numConnectedAudioDevices = getNonIdleAudioDevices().size(); |
| Log.d(TAG," isAudioOn: The number of audio connected devices " |
| + numConnectedAudioDevices); |
| return numConnectedAudioDevices > 0; |
| } |
| |
| public List<BluetoothDevice> getConnectedDevices() { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Log.i(TAG, "getConnectedDevices: "); |
| if(mCallDevicesMap.size() == 0) { |
| Log.i(TAG, "no device is Connected:"); |
| return new ArrayList<>(0); |
| } |
| |
| List<BluetoothDevice> connectedDevices = new ArrayList<>(); |
| for(CallDevice mCallDevice : mCallDevicesMap.values()) { |
| if(mCallDevice.deviceConnStatus == BluetoothProfile.STATE_CONNECTED) { |
| connectedDevices.add(mCallDevice.mDevice); |
| } |
| } |
| Log.i(TAG, "ConnectedDevices: = " + connectedDevices.size()); |
| return connectedDevices; |
| } |
| |
| public int getConnectionState(BluetoothDevice device) { |
| mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| if(device == null) |
| return BluetoothProfile.STATE_DISCONNECTED; |
| CallDevice mCallDevice; |
| mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if(mCallDevice != null) |
| return mCallDevice.deviceConnStatus; |
| |
| return BluetoothProfile.STATE_DISCONNECTED; |
| } |
| |
| public boolean isVoiceOrCallActive() { |
| boolean isVoiceActive = isAudioOn() || mVirtualCallStarted; |
| HeadsetService mHeadsetService = HeadsetService.getHeadsetService(); |
| if(mHeadsetService != null) { |
| isVoiceActive = isVoiceActive || mHeadsetService.isScoOrCallActive(); |
| } |
| return isVoiceActive; |
| } |
| |
| private void broadcastConnStateChange(BluetoothDevice device, int fromState, int toState) { |
| Log.d(TAG,"broadcastConnectionState " + device + ": " + fromState + "->" + toState); |
| HeadsetService mHeadsetService = HeadsetService.getHeadsetService(); |
| if(mHeadsetService == null) { |
| Log.w(TAG,"broadcastConnectionState: HeadsetService not initialized. Return!"); |
| return; |
| } |
| |
| Intent intent = new Intent(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED); |
| intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, fromState); |
| intent.putExtra(BluetoothProfile.EXTRA_STATE, toState); |
| intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device); |
| intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND); |
| mHeadsetService.sendBroadcastAsUser(intent, UserHandle.ALL, |
| BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions()); |
| } |
| |
| private void broadcastAudioState(BluetoothDevice device, int fromState, int toState) { |
| Log.d(TAG,"broadcastAudioState " + device + ": " + fromState + "->" + toState); |
| HeadsetService mHeadsetService = HeadsetService.getHeadsetService(); |
| if(mHeadsetService == null) { |
| Log.d(TAG,"broadcastAudioState: HeadsetService not initialized. Return!"); |
| return; |
| } |
| |
| Intent intent = new Intent(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED); |
| intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, fromState); |
| intent.putExtra(BluetoothProfile.EXTRA_STATE, toState); |
| intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device); |
| mHeadsetService.sendBroadcastAsUser(intent, UserHandle.ALL, |
| BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions()); |
| } |
| |
| public void onConnStateChange(BluetoothDevice device, Integer state, Integer profile) { |
| int prevState; |
| Log.w(TAG, "onConnStateChange: profile: " + profile + " state: " |
| + state + " for device " + device); |
| if(device == null) |
| return; |
| CallDevice mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| |
| if(mCallDevice == null) { |
| if(state == BluetoothProfile.STATE_DISCONNECTED) |
| return; |
| if(mCallDevicesMap.size() >= MAX_DEVICES) { |
| return; |
| } |
| mCallDevice = new CallDevice(device, profile, state); |
| mCallDevicesMap.put(device.getAddress(), mCallDevice); |
| broadcastConnStateChange(device, BluetoothProfile.STATE_DISCONNECTED, state); |
| return; |
| } |
| |
| int profileIndex = mCallDevice.getProfileIndex(profile); |
| DeviceProfileMap dMap = DeviceProfileMap.getDeviceProfileMapInstance(); |
| prevState = mCallDevice.deviceConnStatus; |
| mCallDevice.profileConnStatus[profileIndex] = state; |
| |
| if(state == BluetoothProfile.STATE_DISCONNECTED) { |
| dMap.profileConnectionUpdate(device, ApmConst.AudioFeatures.CALL_AUDIO, profile, false); |
| } |
| |
| int otherProfileConnectionState = mCallDevice.profileConnStatus[(profileIndex+1)%2]; |
| Log.w(TAG, " otherProfileConnectionState: " + otherProfileConnectionState); |
| |
| switch(otherProfileConnectionState) { |
| /*Send Broadcast based on state of other profile*/ |
| case BluetoothProfile.STATE_DISCONNECTED: |
| broadcastConnStateChange(device, prevState, state); |
| mCallDevice.deviceConnStatus = state; |
| if(state == BluetoothProfile.STATE_CONNECTED) { |
| int supportedProfiles = dMap.getSupportedProfile(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| if(profile == ApmConst.AudioProfiles.HFP && |
| (supportedProfiles & ApmConst.AudioProfiles.BAP_CALL) == ApmConst.AudioProfiles.BAP_CALL) { |
| Log.w(TAG, "Connect LE Voice after HFP auto connect from remote"); |
| StreamAudioService mStreamService = StreamAudioService.getStreamAudioService(); |
| if(mStreamService != null) { |
| mStreamService.connectLeStream(device, ApmConst.AudioProfiles.BAP_CALL); |
| } |
| } else { |
| ActiveDeviceManagerService mActiveDeviceManager = ActiveDeviceManagerService.get(); |
| mActiveDeviceManager.setActiveDevice(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| } |
| } |
| break; |
| case BluetoothProfile.STATE_CONNECTING: |
| int preferredProfile = dMap.getProfile(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| boolean isPreferredProfile = (preferredProfile == profile); |
| if(state == BluetoothProfile.STATE_CONNECTED && isPreferredProfile) { |
| broadcastConnStateChange(device, prevState, state); |
| mCallDevice.deviceConnStatus = state; |
| } |
| break; |
| case BluetoothProfile.STATE_DISCONNECTING: |
| if(state == BluetoothProfile.STATE_CONNECTING || |
| state == BluetoothProfile.STATE_CONNECTED) { |
| broadcastConnStateChange(device, prevState, state); |
| mCallDevice.deviceConnStatus = state; |
| } |
| break; |
| case BluetoothProfile.STATE_CONNECTED: |
| if(state == BluetoothProfile.STATE_CONNECTED) { |
| if(prevState != state) { |
| broadcastConnStateChange(device, prevState, state); |
| mCallDevice.deviceConnStatus = state; |
| } |
| ActiveDeviceManagerService mActiveDeviceManager = |
| ActiveDeviceManagerService.get(); |
| mActiveDeviceManager.setActiveDevice(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| } else if(state == BluetoothProfile.STATE_DISCONNECTED) { |
| if(prevState != BluetoothProfile.STATE_CONNECTED) { |
| broadcastConnStateChange(device, prevState, BluetoothProfile.STATE_CONNECTED); |
| mCallDevice.deviceConnStatus = BluetoothProfile.STATE_CONNECTED; |
| } else { |
| ActiveDeviceManagerService mActiveDeviceManager = |
| ActiveDeviceManagerService.get(); |
| if(device.equals(mActiveDeviceManager.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO))) { |
| mActiveDeviceManager.setActiveDevice(device, ApmConst.AudioFeatures.CALL_AUDIO); |
| } |
| } |
| } |
| break; |
| } |
| |
| if(state == BluetoothProfile.STATE_CONNECTED) { |
| dMap.profileConnectionUpdate(device, ApmConst.AudioFeatures.CALL_AUDIO, profile, true); |
| } |
| } |
| |
| public void onAudioStateChange(BluetoothDevice device, Integer state) { |
| int prevStatus; |
| if(device == null) |
| return; |
| CallDevice mCallDevice = mCallDevicesMap.get(device.getAddress()); |
| if(mCallDevice == null) { |
| return; |
| } |
| |
| if(mCallDevice.scoStatus == state) |
| return; |
| |
| HeadsetService service = HeadsetService.getHeadsetService(); |
| int profileID = mActiveDeviceManager.getActiveProfile( |
| ApmConst.AudioFeatures.CALL_AUDIO); |
| BluetoothDevice mActivedevice = mActiveDeviceManager.getActiveDevice( |
| ApmConst.AudioFeatures.CALL_AUDIO); |
| if (service != null) { |
| if(!(service.shouldCallAudioBeActive() || mVirtualCallStarted)) { |
| if(ApmConst.AudioProfiles.BAP_CALL == profileID) { |
| StreamAudioService mStreamAudioService = |
| StreamAudioService.getStreamAudioService(); |
| if(mStreamAudioService != null) { |
| Log.w(TAG, "Call not active, disconnect stream"); |
| mStreamAudioService.stopStream(mActivedevice); |
| } |
| } |
| } |
| } |
| |
| prevStatus = mCallDevice.scoStatus; |
| mCallDevice.scoStatus = state; |
| VolumeManager mVolumeManager = VolumeManager.get(); |
| mVolumeManager.updateStreamState(device, state, ApmConst.AudioFeatures.CALL_AUDIO); |
| broadcastAudioState(device, prevStatus, state); |
| if(state == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) { |
| if(ApmConst.AudioProfiles.HFP != profileID) { |
| if(service != null) { |
| service.getHfpA2DPSyncInterface().releaseA2DP(null); |
| } |
| } |
| //mAudioManager.setBluetoothScoOn(false); |
| } /*else { |
| mAudioManager.setBluetoothScoOn(true); |
| }*/ |
| } |
| |
| public void setAudioParam(String param) { |
| mAudioManager.setParameters(param); |
| } |
| |
| public void setBluetoothScoOn(boolean on) { |
| mAudioManager.setBluetoothScoOn(on); |
| } |
| |
| public AudioManager getAudioManager() { |
| return mAudioManager; |
| } |
| |
| class CallDevice { |
| BluetoothDevice mDevice; |
| int[] profileConnStatus = new int[2]; |
| int deviceConnStatus; |
| int scoStatus; |
| |
| public static final int SCO_STREAM = 0; |
| public static final int LE_STREAM = 1; |
| |
| CallDevice(BluetoothDevice device, int profile, int state) { |
| mDevice = device; |
| if(profile == ApmConst.AudioProfiles.HFP) { |
| profileConnStatus[SCO_STREAM] = state; |
| profileConnStatus[LE_STREAM] = BluetoothProfile.STATE_DISCONNECTED; |
| } else { |
| profileConnStatus[LE_STREAM] = state; |
| profileConnStatus[SCO_STREAM] = BluetoothProfile.STATE_DISCONNECTED; |
| } |
| deviceConnStatus = state; |
| scoStatus = BluetoothHeadset.STATE_AUDIO_DISCONNECTED;; |
| } |
| |
| CallDevice(BluetoothDevice device, int profile) { |
| this(device, profile, BluetoothProfile.STATE_DISCONNECTED); |
| } |
| |
| public int getProfileIndex(int profile) { |
| if(profile == ApmConst.AudioProfiles.HFP) |
| return SCO_STREAM; |
| else |
| return LE_STREAM; |
| } |
| } |
| } |
| |
