| /****************************************************************************** |
| * |
| * 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.bc; |
| |
| import java.util.List; |
| import java.util.Arrays; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.util.Log; |
| import java.util.UUID; |
| import java.util.Collection; |
| import android.os.UserHandle; |
| |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| import java.nio.charset.StandardCharsets; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.util.Scanner; |
| import java.util.Map; |
| import java.util.HashMap; |
| import java.util.LinkedHashSet; |
| import java.util.Set; |
| import java.lang.String; |
| import java.lang.StringBuffer; |
| import java.lang.Integer; |
| |
| import java.nio.ByteBuffer; |
| import java.lang.Byte; |
| import java.util.stream.IntStream; |
| import java.util.NoSuchElementException; |
| |
| import android.bluetooth.le.ScanResult; |
| import android.bluetooth.le.ScanSettings; |
| import android.bluetooth.le.ScanFilter; |
| import android.bluetooth.le.ScanCallback; |
| import android.bluetooth.le.ScanRecord; |
| import android.bluetooth.le.BluetoothLeScanner; |
| import java.util.UUID; |
| import android.os.Handler; |
| import android.os.ParcelUuid; |
| import android.os.SystemProperties; |
| import android.os.RemoteException; |
| |
| import android.bluetooth.BleBroadcastSourceInfo; |
| import android.bluetooth.BleBroadcastSourceChannel; |
| //import android.bluetooth.BluetoothBroadcast; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import com.android.bluetooth.btservice.ServiceFactory; |
| ///*_BMS |
| import com.android.bluetooth.broadcast.BroadcastService; |
| //_BMS*/ |
| import android.bluetooth.BluetoothCodecConfig; |
| /*_PACS |
| import com.android.bluetooth.pacsclient.PacsClientService; |
| _PACS*/ |
| import android.bluetooth.IBleBroadcastAudioScanAssistCallback; |
| |
| /** |
| * Bass Utility functions |
| */ |
| |
| final class BassUtils { |
| private static final String TAG = "BassUtils"; |
| /*LE Scan related members*/ |
| private boolean mBroadcastersAround = false; |
| private BluetoothAdapter mBluetoothAdapter = null; |
| private BluetoothLeScanner mLeScanner = null; |
| private BCService mBCService = null; |
| |
| ///*_BMS |
| private BroadcastService mBAService = null; |
| //_BMS*/ |
| public static final String BAAS_UUID = "00001852-0000-1000-8000-00805F9B34FB"; |
| private boolean mIsLocalBMSNotified = false; |
| private ServiceFactory mFactory = new ServiceFactory(); |
| //Using ArrayList as KEY to hashmap. May be not risk |
| //in this case as It is used to track the callback to cancel Scanning later |
| private final Map<ArrayList<IBleBroadcastAudioScanAssistCallback>, ScanCallback> mLeAudioSourceScanCallbacks; |
| private final Map<BluetoothDevice, ScanCallback> mBassAutoAssist; |
| |
| private static final int AA_START_SCAN = 1; |
| private static final int AA_SCAN_SUCCESS = 2; |
| private static final int AA_SCAN_FAILURE = 3; |
| private static final int AA_SCAN_TIMEOUT = 4; |
| //timeout for internal scan |
| private static final int AA_SCAN_TIMEOUT_MS = 1000; |
| |
| /** |
| * Stanadard Codec param types |
| */ |
| static final int LOCATION = 3; |
| //sample rate |
| static final int SAMPLE_RATE = 1; |
| //frame duration |
| static final int FRAME_DURATION = 2; |
| //Octets per frame |
| static final int OCTETS_PER_FRAME = 8; |
| /*_PACS |
| private PacsClientService mPacsClientService = PacsClientService.getPacsClientService(); |
| _PACS*/ |
| BassUtils (BCService service) { |
| mBCService = service; |
| mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); |
| mLeScanner = mBluetoothAdapter.getBluetoothLeScanner(); |
| mLeAudioSourceScanCallbacks = new HashMap<ArrayList<IBleBroadcastAudioScanAssistCallback>, ScanCallback>(); |
| mBassAutoAssist = new HashMap<BluetoothDevice, ScanCallback>(); |
| ///*_BMS |
| mBAService = BroadcastService.getBroadcastService(); |
| //_BMS*/ |
| } |
| |
| private ScanCallback mPaSyncScanCallback = new ScanCallback() { |
| @Override |
| public void onScanResult(int callbackType, ScanResult result) { |
| log( "onScanResult:" + result); |
| } |
| }; |
| |
| void cleanUp () { |
| |
| if (mLeAudioSourceScanCallbacks != null) { |
| mLeAudioSourceScanCallbacks.clear(); |
| } |
| |
| if (mBassAutoAssist != null) { |
| mBassAutoAssist.clear(); |
| } |
| } |
| |
| boolean leScanControl(boolean on) { |
| log("leScanControl:" + on); |
| mLeScanner = mBluetoothAdapter.getBluetoothLeScanner(); |
| if (mLeScanner == null) { |
| Log.e(TAG, "LeScan handle not available"); |
| return false; |
| } |
| |
| if (on) { |
| mLeScanner.startScan(mPaSyncScanCallback); |
| } else { |
| mLeScanner.stopScan(mPaSyncScanCallback); |
| } |
| |
| return true; |
| } |
| |
| /* private helper to check if the Local BLE Broadcast happening Or not */ |
| public boolean isLocalLEAudioBroadcasting() { |
| boolean ret = false; |
| /*String localLeABroadcast = SystemProperties.get("persist.vendor.btstack.isLocalLeAB"); |
| if (!localLeABroadcast.isEmpty() && "true".equals(localLeABroadcast)) { |
| ret = true; |
| } |
| log("property isLocalLEAudioBroadcasting returning " + ret);*/ |
| ///*_Broadcast |
| if (mBAService == null) { |
| mBAService = BroadcastService.getBroadcastService(); |
| } |
| if (mBAService != null) { |
| ret = mBAService.isBroadcastActive(); |
| //ret = mBAService.isBroadcastStreaming(); |
| log("local broadcast streaming:" + ret); |
| } else { |
| log("BroadcastService is Null"); |
| } |
| //_Broadcast*/ |
| log("isLocalLEAudioBroadcasting returning " + ret); |
| return ret; |
| } |
| |
| Handler mAutoAssistScanHandler = new Handler() { |
| public void handleMessage(Message msg) { |
| super.handleMessage(msg); |
| switch (msg.what) { |
| case AA_START_SCAN: |
| BluetoothDevice dev = (BluetoothDevice) msg.obj; |
| Message m = obtainMessage(AA_SCAN_TIMEOUT); |
| m.obj = dev; |
| sendMessageDelayed(m, AA_SCAN_TIMEOUT_MS); |
| searchforLeAudioBroadcasters(dev, null); |
| break; |
| case AA_SCAN_SUCCESS: |
| //Able to find to desired desired Source Device |
| ScanResult scanRes = (ScanResult) msg.obj; |
| dev = scanRes.getDevice(); |
| stopSearchforLeAudioBroadcasters(dev,null); |
| mBCService.selectBroadcastSource(dev, scanRes, false, true); |
| break; |
| case AA_SCAN_FAILURE: |
| //Not able to find the given source |
| //ignore |
| break; |
| case AA_SCAN_TIMEOUT: |
| dev = (BluetoothDevice)msg.obj; |
| stopSearchforLeAudioBroadcasters(dev, null); |
| break; |
| } |
| } |
| }; |
| private void notifyLocalBroadcastSourceFound(ArrayList<IBleBroadcastAudioScanAssistCallback> cbs) { |
| BluetoothDevice localDev = |
| BluetoothAdapter.getDefaultAdapter().getRemoteDevice(mBluetoothAdapter.getAddress()); |
| String localName = BluetoothAdapter.getDefaultAdapter().getName(); |
| ScanRecord record = null; |
| if (localName != null) { |
| byte name_len = (byte)localName.length(); |
| byte[] bd_name = localName.getBytes(StandardCharsets.US_ASCII); |
| byte[] name_key = new byte[] {++name_len, 0x09 }; //0x09 TYPE:Name |
| byte[] scan_r = new byte[name_key.length + bd_name.length]; |
| System.arraycopy(name_key, 0, scan_r, 0, name_key.length); |
| System.arraycopy(bd_name, 0, scan_r, name_key.length, bd_name.length); |
| record = ScanRecord.parseFromBytes(scan_r); |
| log ("Local name populated in fake Scan res:" + record.getDeviceName()); |
| } |
| ScanResult scanRes = new ScanResult(localDev, |
| 1, 1, 1,2, 0, 0, 0, record, 0); |
| if (cbs != null) { |
| for (IBleBroadcastAudioScanAssistCallback cb : cbs) { |
| try { |
| cb.onBleBroadcastSourceFound(scanRes); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Exception while calling onBleBroadcastSourceFound"); |
| } |
| } |
| } |
| } |
| public boolean searchforLeAudioBroadcasters (BluetoothDevice srcDevice, |
| ArrayList<IBleBroadcastAudioScanAssistCallback> cbs |
| ) { |
| log( "searchforLeAudioBroadcasters: "); |
| BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner(); |
| mIsLocalBMSNotified = false; |
| if (scanner == null) { |
| Log.e(TAG, "startLeScan: cannot get BluetoothLeScanner"); |
| return false; |
| } |
| synchronized (mLeAudioSourceScanCallbacks) { |
| if (mLeAudioSourceScanCallbacks.containsKey(cbs)) { |
| Log.e(TAG, "LE Scan has already started"); |
| return false; |
| } |
| ScanCallback scanCallback = new ScanCallback() { |
| @Override |
| public void onScanResult(int callbackType, ScanResult result) { |
| log( "onScanResult:" + result); |
| if (callbackType != ScanSettings.CALLBACK_TYPE_ALL_MATCHES) { |
| // Should not happen. |
| Log.e(TAG, "LE Scan has already started"); |
| return; |
| } |
| ScanRecord scanRecord = result.getScanRecord(); |
| //int pInterval = result.getPeriodicAdvertisingInterval(); |
| if (scanRecord != null) { |
| Map<ParcelUuid, byte[]> listOfUuids = scanRecord.getServiceData(); |
| if (listOfUuids != null) { |
| //ParcelUuid bmsUuid = new ParcelUuid(BroadcastService.BAAS_UUID); |
| //boolean isBroadcastSource = listOfUuids.containsKey(bmsUuid); |
| boolean isBroadcastSource = listOfUuids.containsKey(ParcelUuid.fromString(BAAS_UUID)); |
| log( "isBroadcastSource:" + isBroadcastSource); |
| if (isBroadcastSource) { |
| log( "Broadcast Source Found:" + result.getDevice()); |
| if (cbs != null) { |
| for (IBleBroadcastAudioScanAssistCallback cb : cbs) { |
| try { |
| cb.onBleBroadcastSourceFound(result); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Exception while calling onBleBroadcastSourceFound"); |
| } |
| } |
| } else { |
| if (srcDevice.equals(result.getDevice())) { |
| log("matching src Device found"); |
| Message msg = mAutoAssistScanHandler.obtainMessage(AA_SCAN_SUCCESS); |
| msg.obj = result; |
| mAutoAssistScanHandler.sendMessage(msg); |
| } |
| } |
| } else { |
| log( "Broadcast Source UUID not preset, ignore"); |
| } |
| } else { |
| Log.e(TAG, "Ignore no UUID"); |
| return; |
| } |
| } else { |
| Log.e(TAG, "Scan record is null, ignoring this Scan res"); |
| return; |
| } |
| //Before starting LE Scan, Call local APIs to find out if the local device |
| //is Broadcaster, then generate callback for Local device |
| if (!mIsLocalBMSNotified && isLocalLEAudioBroadcasting()) { |
| //Create a DUMMY scan result for colocated case |
| notifyLocalBroadcastSourceFound(cbs); |
| mIsLocalBMSNotified = true; |
| } |
| } |
| |
| public void onScanFailed(int errorCode) { |
| Log.e(TAG, "Scan Failure:" + errorCode); |
| } |
| }; |
| if (mBluetoothAdapter != null) { |
| if (cbs != null) { |
| mLeAudioSourceScanCallbacks.put(cbs, scanCallback); |
| } else { |
| //internal auto assist trigger remember it |
| //based on device |
| mBassAutoAssist.put(srcDevice, scanCallback); |
| } |
| |
| ScanSettings settings = new ScanSettings.Builder().setCallbackType( |
| ScanSettings.CALLBACK_TYPE_ALL_MATCHES) |
| .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY) |
| .setLegacy(false) |
| .build(); |
| ScanFilter.Builder filterBuilder = new ScanFilter.Builder(); |
| ScanFilter srcFilter = filterBuilder.setServiceUuid( |
| ParcelUuid.fromString(BAAS_UUID)).build(); |
| List<ScanFilter> filters = new ArrayList<ScanFilter>(); |
| if (!mIsLocalBMSNotified && isLocalLEAudioBroadcasting()) { |
| //Create a DUMMY scan result for colocated case |
| notifyLocalBroadcastSourceFound(cbs); |
| mIsLocalBMSNotified = true; |
| } |
| scanner.startScan(filters, settings, scanCallback); |
| return true; |
| } else { |
| Log.e(TAG, "searchforLeAudioBroadcasters: Adapter is NULL"); |
| return false; |
| } |
| } |
| } |
| public boolean stopSearchforLeAudioBroadcasters(BluetoothDevice srcDev, |
| ArrayList<IBleBroadcastAudioScanAssistCallback> cbs) { |
| log( "stopSearchforLeAudioBroadcasters()"); |
| BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner(); |
| if (scanner == null) { |
| return false; |
| } |
| ScanCallback scanCallback = null; |
| if (cbs != null) { |
| scanCallback = mLeAudioSourceScanCallbacks.remove(cbs); |
| } else { |
| scanCallback = mLeAudioSourceScanCallbacks.remove(srcDev); |
| } |
| |
| if (scanCallback == null) { |
| log( "scan not started yet"); |
| return false; |
| } |
| scanner.stopScan(scanCallback); |
| return true; |
| } |
| |
| private int convertConfigurationSRToCapabilitySR(byte sampleRate) { |
| int ret = BluetoothCodecConfig.SAMPLE_RATE_NONE; |
| switch (sampleRate) { |
| case 1: |
| ret = BluetoothCodecConfig.SAMPLE_RATE_NONE; break; |
| case 2: |
| ret = BluetoothCodecConfig.SAMPLE_RATE_NONE; break; |
| case 3: |
| ret = BluetoothCodecConfig.SAMPLE_RATE_NONE; break; |
| case 4: |
| //ret = BluetoothCodecConfig.SAMPLE_RATE_32000; break; |
| case 5: |
| ret = BluetoothCodecConfig.SAMPLE_RATE_44100; break; |
| case 6: |
| ret = BluetoothCodecConfig.SAMPLE_RATE_48000; break; |
| } |
| log("convertConfigurationSRToCapabilitySR returns:" + ret); |
| return ret; |
| } |
| |
| private boolean isSampleRateSupported(BluetoothDevice device, byte sampleRate) { |
| boolean ret = false; |
| /*_PACS |
| BluetoothCodecConfig[] supportedConfigs = mPacsClientService.getSinkPacs(device); |
| int actualSampleRate = convertConfigurationSRToCapabilitySR(sampleRate); |
| |
| if (actualSampleRate == BluetoothCodecConfig.SAMPLE_RATE_NONE) { |
| return false; |
| } |
| |
| for (int i=0; i<supportedConfigs.length; i++) { |
| if (actualSampleRate == supportedConfigs[i].getSampleRate()) { |
| ret = true; |
| } |
| } |
| |
| log("isSampleRateSupported returns:" + ret); |
| _PACS*/ |
| return ret; |
| } |
| public List<BleBroadcastSourceChannel> selectBises(BluetoothDevice device, |
| BleBroadcastSourceInfo srcInfo, BaseData base) { |
| boolean noPref = SystemProperties.getBoolean("persist.vendor.service.bt.bass_no_pref", false); |
| if (noPref) { |
| log("No pref selected"); |
| return null; |
| } else { |
| /*_PACS |
| mPacsClientService = PacsClientService.getPacsClientService(); |
| List<BleBroadcastSourceChannel> bChannels = new ArrayList<BleBroadcastSourceChannel>(); |
| //if (mPacsClientService == null) { |
| log("selectBises: Pacs Service is null, pick BISes apropriately"); |
| //Pacs not available |
| if (base != null) { |
| bChannels = base.pickAllBroadcastChannels(); |
| } else { |
| bChannels = null; |
| } |
| return bChannels; |
| //} |
| if (mPacsClientService != null) { |
| int supportedLocations = 1/*mPacsClientService.getSinkLocations(device); |
| ArrayList<BaseData.BaseInformation> broadcastedCodecInfo = base.getBISIndexInfos(); |
| if (broadcastedCodecInfo != null) { |
| for (int i=0; i<broadcastedCodecInfo.size(); i++) { |
| HashMap<Integer, String> consolidatedUniqueCodecInfo = broadcastedCodecInfo.get(i).consolidatedUniqueCodecInfo; |
| byte index = broadcastedCodecInfo.get(i).index; |
| if (consolidatedUniqueCodecInfo != null) { |
| |
| |
| byte[] bisChannelLocation = consolidatedUniqueCodecInfo.get(LOCATION).getBytes(); |
| byte[] locationValue = new byte[4]; |
| System.arraycopy(bisChannelLocation, 2, locationValue, 0, 4); |
| log ("locationValue>>> "); |
| printByteArray(locationValue); |
| ByteBuffer wrapped = ByteBuffer.wrap(locationValue); |
| int bisLocation = wrapped.getInt(); |
| log("bisLocation: " + bisLocation); |
| int reversebisLoc = Integer.reverseBytes(bisLocation); |
| log("reversebisLoc: " + reversebisLoc); |
| |
| byte[] bisSampleRate = consolidatedUniqueCodecInfo.get(SAMPLE_RATE).getBytes(); |
| byte bisSR = bisSampleRate[2]; |
| |
| //using bitwise operand as Location can be bitmask |
| if (isSampleRateSupported(device, bisSR) && (reversebisLoc & supportedLocations) == supportedLocations) { |
| log("matching location: bisLocation " + reversebisLoc + ":: " + supportedLocations); |
| BleBroadcastSourceChannel bc = new BleBroadcastSourceChannel(index, String.valueOf(index), true); |
| bChannels.add(bc); |
| } |
| } |
| } |
| } |
| } |
| |
| if (bChannels != null && bChannels.size() == 0) { |
| log("selectBises: no channel are selected"); |
| bChannels = null; |
| |
| } |
| return bChannels; |
| _PACS*/ |
| } |
| return null; |
| } |
| |
| public void triggerAutoAssist (BleBroadcastSourceInfo srcInfo) { |
| //searchforLeAudioBroadcasters (srcInfo.getSourceDevice(), null, AUTO_ASSIST_SCAN_TIMEOUT); |
| BluetoothDevice dev = srcInfo.getSourceDevice(); |
| |
| Message msg = mAutoAssistScanHandler.obtainMessage(AA_START_SCAN); |
| msg.obj = srcInfo.getSourceDevice(); |
| mAutoAssistScanHandler.sendMessage(msg); |
| } |
| |
| static void log(String msg) { |
| if (BassClientStateMachine.BASS_DBG) { |
| Log.d(TAG, msg); |
| } |
| } |
| |
| static void printByteArray(byte[] array) { |
| log("Entire byte Array as string: " + Arrays.toString(array)); |
| log("printitng byte by bte"); |
| for (int i=0; i<array.length; i++) { |
| log( "array[" + i + "] :" + Byte.toUnsignedInt(array[i])); |
| } |
| } |
| } |
