Google Git
Sign in
android / platform / system / bt / ea7ab70a711e642653dd5922b83aa04a53af9e0e / . / le_audio / packages / apps / Bluetooth / src / com / android / bluetooth / bassclient / BassClientStateMachine.java
blob: b35cfa9eb14f83f55ad39f2aa14e0aa924897565 [file] [log] [blame]
/*
* Copyright (c) 2020 The Linux Foundation. All rights reserved.
*
* Copyright 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Bluetooth Bassclient StateMachine. There is one instance per remote device.
* - "Disconnected" and "Connected" are steady states.
* - "Connecting" and "Disconnecting" are transient states until the
* connection / disconnection is completed.
* - "ConnectedProcessing" is an intermediate state to ensure, there is only
* one Gatt transaction from the profile at any point of time
*
*
* (Disconnected)
* | ^
* CONNECT | | DISCONNECTED
* V |
* (Connecting)<--->(Disconnecting)
* | ^
* CONNECTED | | DISCONNECT
* V |
* (Connected)
* | ^
* GATT_TXN | | GATT_TXN_DONE/GATT_TXN_TIMEOUT
* V |
* (ConnectedProcessing)
* NOTES:
* - If state machine is in "Connecting" state and the remote device sends
* DISCONNECT request, the state machine transitions to "Disconnecting" state.
* - Similarly, if the state machine is in "Disconnecting" state and the remote device
* sends CONNECT request, the state machine transitions to "Connecting" state.
* - Whenever there is any Gatt Write/read, State machine will moved "ConnectedProcessing" and
* all other requests (add, update, remove source) operations will be deferred in "ConnectedProcessing" state
* - Once the gatt transaction is done (or after a specified timeout of no response), State machine will
* move back to "Connected" and try to process the deferred requests as needed
*
* DISCONNECT
* (Connecting) ---------------> (Disconnecting)
* <---------------
* CONNECT
*
*/
package com.android.bluetooth.bc;
import static android.Manifest.permission.BLUETOOTH_CONNECT;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothUuid;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanRecord;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothSyncHelper;
import android.bluetooth.BleBroadcastSourceInfo;
import android.bluetooth.BleBroadcastSourceChannel;
import android.bluetooth.BleBroadcastAudioScanAssistManager;
import android.bluetooth.IBleBroadcastAudioScanAssistCallback;
import android.bluetooth.BleBroadcastAudioScanAssistCallback;
import com.android.bluetooth.Utils;
//CSIP related imports
///*_CSIP
import com.android.bluetooth.groupclient.GroupService;
import android.bluetooth.BluetoothGroupCallback;
import android.bluetooth.DeviceGroup;
//_CSIP*/
///*_VCP
import android.bluetooth.BluetoothVcp;
import com.android.bluetooth.vcp.VcpController;
//_VCP*/
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.PeriodicAdvertisingCallback;
import android.bluetooth.le.PeriodicAdvertisingManager;
import android.bluetooth.le.PeriodicAdvertisingReport;
import android.bluetooth.IBluetoothManager;
import android.os.ServiceManager;
import android.os.IBinder;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Iterator;
import android.content.Intent;
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 java.lang.IllegalArgumentException;
import com.android.bluetooth.btservice.ProfileService;
/*_PACS
import com.android.bluetooth.pacsclient.PacsClientService;
_PACS*/
import com.android.bluetooth.btservice.ServiceFactory;
///*_BMS
import com.android.bluetooth.broadcast.BroadcastService;
//_BMS*/
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
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 android.os.SystemProperties;
import android.os.ParcelUuid;
final class BassClientStateMachine extends StateMachine {
private static final String TAG = "BassClientStateMachine";
public static final boolean BASS_DBG = true;
//public static final boolean BASS_DBG = Log.isLoggable(TAG, Log.DEBUG);
private boolean mIsWhitelist = false;
static final int BCAST_RECEIVER_STATE_LENGTH = 15;
static final int CONNECT = 1;
static final int DISCONNECT = 2;
static final int CONNECTION_STATE_CHANGED = 3;
static final int GATT_TXN_PROCESSED = 4;
static final int READ_BASS_CHARACTERISTICS= 5;
static final int START_SCAN_OFFLOAD = 6;
static final int STOP_SCAN_OFFLOAD = 7;
static final int SELECT_BCAST_SOURCE = 8;
static final int ADD_BCAST_SOURCE = 9;
static final int UPDATE_BCAST_SOURCE = 10;
static final int SET_BCAST_CODE = 11;
static final int REMOVE_BCAST_SOURCE = 12;
static final int GATT_TXN_TIMEOUT = 13;
static final int PSYNC_ACTIVE_TIMEOUT = 14;
public static final int CSIP_CONNECTION_STATE_CHANGED = 15;
static final int CONNECT_TIMEOUT = 16;
//30 secs time out for all gatt writes
static final int GATT_TXN_TIMEOUT_MS = 30000;
//3 min time out for keeping PSYNC active
static final int PSYNC_ACTIVE_TIMEOUT_MS = 3*60000;
//2 secs time out achieving psync
static final int PSYNC_TIMEOUT = 200;
int NUM_OF_BROADCAST_RECEIVER_STATES = 0;
private final Disconnected mDisconnected;
private final Connected mConnected;
private final Connecting mConnecting;
private final Disconnecting mDisconnecting;
private final ConnectedProcessing mConnectedProcessing;
private int mLastConnectionState = -1;
private static int mConnectTimeoutMs = 30000;
private boolean mMTUChangeRequested = false;
private boolean mDiscoveryInitiated = false;
private BCService mService;
private final BluetoothDevice mDevice;
private BluetoothGatt mBluetoothGatt = null;
//BASS Characteristics UUID
public static final UUID BASS_UUID = UUID.fromString("0000184F-0000-1000-8000-00805F9B34FB");
private static final UUID BASS_BCAST_AUDIO_SCAN_CTRL_POINT = UUID.fromString("00002BC7-0000-1000-8000-00805F9B34FB");
private static final UUID BASS_BCAST_RECEIVER_STATE = UUID.fromString("00002BC8-0000-1000-8000-00805F9B34FB");
private static final UUID CLIENT_CHARACTERISTIC_CONFIG = UUID.fromString(
"00002902-0000-1000-8000-00805f9b34fb");
private List<BluetoothGattCharacteristic> mBroadcastReceiverStates;
private BluetoothGattCharacteristic mBroadcastScanControlPoint;
/*key is combination of sourceId, Address and advSid for this hashmap*/
private final Map<Integer, BleBroadcastSourceInfo> mBleBroadcastSourceInfos;
private boolean mFirstTimeBisDiscovery = false;
private int mPASyncRetryCounter = 0;
private ScanResult mScanRes = null;
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
private ServiceFactory mFactory = new ServiceFactory();
///*_BMS
private BroadcastService mBAService = null;
//_BMS*/
private final byte[] REMOTE_SCAN_STOP = {00};
private final byte[] REMOTE_SCAN_START = {01};
private byte BASS_ADD_SOURCE_OPCODE = 0x02;
private byte BASS_UPDATE_SOURCE_OPCODE = 0x03;
private byte BASS_SET_BCAST_PIN_OPCODE = 0x04;
private byte BASS_REMOVE_SOURCE_OPCODE = 0x05;
private static int num_of_recever_states = 0;
private static int PIN_CODE_CMD_LEN = 18;
private final int BASS_MAX_BYTES = 100;
private int mPendingOperation = -1;
private byte mPendingSourceId = -1;
public static byte INVALID_SRC_ID = -1;
private int GATT_TXN_TOUT_ERROR = -1;
private BleBroadcastSourceInfo mSetBroadcastPINSrcInfo = null;
private boolean mSetBroadcastCodePending = false;
//types of command for set broadcast PIN operation
public int FRESH = 1;
private int QUEUED = 2;
//types of command for select and add Broadcast source operations
public int AUTO = 1;
public int USER = 2;
//types of operation for Select source to determine
//if psync achieved on behalf of single device or multiple devices
public int GROUP_OP = 1;
public int NON_GROUP_OP = 0;
public static int BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC = 0;
//Service data Octet0
private static int BROADCAST_ADV_ADDRESS_DONT_MATCHES_EXT_ADV_ADDRESS = 0x00000001;
private static int BROADCAST_ADV_ADDRESS_DONT_MATCHES_SOURCE_ADV_ADDRESS = 0x00000002;
//Psync and PAST interfaces
private PeriodicAdvertisingManager mPeriodicAdvManager;
private static UUID BASIC_AUDIO_UUID = UUID.fromString("00001851-0000-1000-8000-00805F9B34FB");
private boolean mAutoAssist = false;
private boolean mNoReverse = false;
private boolean mAutoTriggerred = false;
private boolean mSyncingOnBehalfOfGroup = false;
private boolean mNoStopScanOffload = false;
//CSET interfaces
///*_CSIP
private GroupService mSetCoordinator = GroupService.getGroupService();
private boolean mCsipConnected = false;
//_CSIP*/
private boolean mPacsAvail = false;
private boolean mDefNoPAS = false;
private boolean mNoPast = false;
private boolean mNoCSIPReconn = false;
private boolean mPublicAddrForcSrc = false;
private boolean mForceSB = false;
private boolean mVcpForBroadcast = false;
private int BROADCAST_SOURCE_ID_LENGTH = 3;
private byte mTempSourceId = 0;
//broadcast receiver state indicies
private static final int BCAST_RCVR_STATE_SRC_ID_IDX = 0;
private static final int BCAST_RCVR_STATE_SRC_ADDR_TYPE_IDX = 1;
private static final int BCAST_RCVR_STATE_SRC_ADDR_START_IDX = 2;
private static final int BCAST_RCVR_STATE_SRC_BCAST_ID_START_IDX = 9;
private static final int BCAST_RCVR_STATE_SRC_ADDR_SIZE = 6;
private static final int BCAST_RCVR_STATE_SRC_ADV_SID_IDX = 8;
private static final int BCAST_RCVR_STATE_PA_SYNC_IDX = 12;
private static final int BCAST_RCVR_STATE_ENC_STATUS_IDX = 13;
private static final int BCAST_RCVR_STATE_BADCODE_START_IDX = 14;
private static final int BCAST_RCVR_STATE_BADCODE_SIZE = 16;
private static final int BCAST_RCVR_STATE_BIS_SYNC_START_IDX = 10;
private static final int BCAST_RCVR_STATE_BIS_SYNC_SIZE = 4;
private static final int BCAST_RCVR_STATE_METADATA_LENGTH_IDX = 15;
private static final int BCAST_RCVR_STATE_METADATA_START_IDX = 16;
BassClientStateMachine(BluetoothDevice device, BCService svc,
Looper looper) {
super(TAG + "(" + device.toString() + ")", looper);
mDevice = device;
mService = svc;
mDisconnected = new Disconnected();
mDisconnecting = new Disconnecting();
mConnected = new Connected();
mConnecting = new Connecting();
mConnectedProcessing = new ConnectedProcessing();
addState(mDisconnected);
addState(mDisconnecting);
addState(mConnected);
addState(mConnecting);
addState(mConnectedProcessing);
setInitialState(mDisconnected);
mBroadcastReceiverStates = new ArrayList<BluetoothGattCharacteristic>();
mBleBroadcastSourceInfos = new HashMap<Integer, BleBroadcastSourceInfo>();
//PSYNC and PAST instances
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter != null) {
mPeriodicAdvManager = mBluetoothAdapter.getPeriodicAdvertisingManager();
}
///*_BMS
mBAService = BroadcastService.getBroadcastService();
//_BMS*/
mNoReverse = SystemProperties.getBoolean("persist.vendor.service.bt.nReverse", false);
mAutoAssist = SystemProperties.getBoolean("persist.vendor.service.bt.autoassist", false);
mIsWhitelist = SystemProperties.getBoolean("persist.vendor.service.bt.wl", true);
mDefNoPAS = SystemProperties.getBoolean("persist.vendor.service.bt.defNoPAS", false);
mNoPast = SystemProperties.getBoolean("persist.vendor.service.bt.noPast", false);
mNoCSIPReconn = SystemProperties.getBoolean("persist.vendor.service.bt.noCsipRec", false);
mPublicAddrForcSrc = SystemProperties.getBoolean("persist.vendor.service.bt.pAddrForcSource", true);
mForceSB = SystemProperties.getBoolean("persist.vendor.service.bt.forceSB", false);
mVcpForBroadcast = SystemProperties.getBoolean("persist.vendor.service.bt.vcpForBroadcast", true);
}
static BassClientStateMachine make(BluetoothDevice device, BCService svc,
Looper looper) {
Log.d(TAG, "make for device " + device);
BassClientStateMachine BassclientSm = new BassClientStateMachine(device, svc,
looper);
BassclientSm.start();
return BassclientSm;
}
public void doQuit() {
log("doQuit for device " + mDevice);
quitNow();
}
public void cleanup() {
log("cleanup for device " + mDevice);
clearCharsCache();
if (mBluetoothGatt != null) {
log("disconnect gatt");
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
}
mPendingOperation = -1;
mPendingSourceId = -1;
}
BleBroadcastSourceInfo getBroadcastSourceInfoForSourceDevice (BluetoothDevice srcDevice) {
List<BleBroadcastSourceInfo> currentSourceInfos =
getAllBroadcastSourceInformation();
BleBroadcastSourceInfo srcInfo = null;
for (int i=0; i<currentSourceInfos.size(); i++) {
BluetoothDevice device = currentSourceInfos.get(i).getSourceDevice();
if (device != null && device.equals(srcDevice)) {
srcInfo = currentSourceInfos.get(i);
Log.e(TAG, "getBroadcastSourceInfoForSourceDevice: returns for: " + srcDevice + "&srcInfo" + srcInfo);
return srcInfo;
}
}
return null;
}
BleBroadcastSourceInfo getBroadcastSourceInfoForSourceId (int srcId) {
List<BleBroadcastSourceInfo> currentSourceInfos =
getAllBroadcastSourceInformation();
BleBroadcastSourceInfo srcInfo = null;
for (int i=0; i<currentSourceInfos.size(); i++) {
int sId = currentSourceInfos.get(i).getSourceId();
if (srcId == sId) {
srcInfo = currentSourceInfos.get(i);
Log.e(TAG, "getBroadcastSourceInfoForSourceId: returns for: " + srcId + "&srcInfo" + srcInfo);
return srcInfo;
}
}
return null;
}
void parseBaseData(BluetoothDevice device, int syncHandle, byte[] serviceData) {
log("parseBaseData" + Arrays.toString(serviceData));
BaseData base_ = new BaseData(serviceData);
if (base_ != null) {
mService.updateBASE(syncHandle, base_);
base_.print();
base_.printConsolidated();
if (mAutoTriggerred == false) {
mService.sendBroadcastSourceSelectedCallback(device, base_.getBroadcastChannels(),
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SUCCESS);
} else {
//successfull auto periodic synchrnization with source
log("auto triggered assist");
mAutoTriggerred = false;
//perform PAST with this device
BluetoothDevice srcDevice = mService.getDeviceForSyncHandle(syncHandle);
if (srcDevice != null) {
BleBroadcastSourceInfo srcInfo = getBroadcastSourceInfoForSourceDevice(srcDevice);
processPASyncState(srcInfo);
} else {
Log.w(TAG, "Autoassist: no matching device");
}
}
} else {
//
Log.e(TAG, "Seems BASE is not in parsable format");
if (mAutoTriggerred == false) {
mService.sendBroadcastSourceSelectedCallback(device, base_.getBroadcastChannels(),
BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_SELECTED);
BluetoothDevice srcDevice = mService.getDeviceForSyncHandle(syncHandle);
cancelActiveSync(srcDevice);
} else {
mAutoTriggerred = false;
}
}
}
void parseScanRecord(int syncHandle, ScanRecord record) {
log("parseScanRecord" + record);
BluetoothDevice srcDevice = mService.getDeviceForSyncHandle(syncHandle);
Map<ParcelUuid, byte[]> bmsAdvDataMap = record.getServiceData();
if (bmsAdvDataMap != null) {
for (Map.Entry<ParcelUuid,byte[]> entry : bmsAdvDataMap.entrySet()) {
log("ParcelUUid = " + entry.getKey() +
", Value = " + entry.getValue());
}
} else {
log("bmsAdvDataMap is null");
if (mAutoTriggerred == false) {
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_SELECTED);
cancelActiveSync(srcDevice);
} else {
mAutoTriggerred = false;
}
}
ParcelUuid basicAudioUuid = new ParcelUuid(BASIC_AUDIO_UUID);
byte[] bmsAdvData = record.getServiceData(basicAudioUuid);
if (bmsAdvData != null) {
//ByteBuffer bb = ByteBuffer.wrap(bmsAdvData);
parseBaseData(mDevice, syncHandle, bmsAdvData);
} else {
Log.e(TAG, "No service data in Scan record");
if (mAutoTriggerred == false) {
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_SELECTED);
cancelActiveSync(srcDevice);
} else {
mAutoTriggerred = false;
}
}
}
/*Local Public address based check
Use this prior to addition of Broadcast source*/
boolean isLocalBroadcastSource (BluetoothDevice device)
{
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
boolean ret = btAdapter.getAddress().equals(device.getAddress());
log("isLocalBroadcastSource returns" +ret);
return ret;
}
private boolean isValidBroadcastSourceInfo(BleBroadcastSourceInfo srcInfo) {
boolean ret = true;
List<BleBroadcastSourceInfo> currentSourceInfos =
getAllBroadcastSourceInformation();
Log.i(TAG, "input srcInfo: " + srcInfo);
for (int i=0; i<currentSourceInfos.size(); i++) {
Log.i(TAG, "srcInfo: [" + i + "]" + currentSourceInfos.get(i));
if (srcInfo.matches(currentSourceInfos.get(i))) {
ret = false;
break;
}
}
log("isValidBroadcastSourceInfo returns: " + ret);
return ret;
}
public boolean selectBroadcastSource (ScanResult scanRes, boolean groupOp, boolean autoTriggerred) {
Log.i(TAG, "selectBroadcastSource for " + "isGroupOp:" + groupOp);
Log.i(TAG, "ScanResult " + scanRes);
int broadcastId = BCService.INVALID_BROADCAST_ID;
if (isLocalBroadcastSource(scanRes.getDevice()) != true) {
mAutoTriggerred = autoTriggerred;
mFirstTimeBisDiscovery = true;
mPASyncRetryCounter = 1;
//Cache Scan res for Retrys
mScanRes = scanRes;
/*This is an override case
if Previous sync is still active, cancel It
But dont stop the Scan offload as we still trying to assist remote*/
mNoStopScanOffload = true;
cancelActiveSync(null);
mService.getBassUtils().leScanControl(true);
try {
mPeriodicAdvManager.registerSync(scanRes, 0,
PSYNC_TIMEOUT, mPeriodicAdvCallback);
mSyncingOnBehalfOfGroup = groupOp;
} catch (IllegalArgumentException ex) {
Log.w(TAG, "registerSync:IllegalArguementException");
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_SELECTED);
mService.stopScanOffloadInternal(mDevice, false);
return false;
}
//updating mainly for Address type and PA Interval here
//extract BroadcastId from ScanResult
ScanRecord scanRecord = scanRes.getScanRecord();
if (scanRecord != null) {
Map<ParcelUuid, byte[]> listOfUuids = scanRecord.getServiceData();
if (listOfUuids != null) {
if(listOfUuids.containsKey(ParcelUuid.fromString(BassUtils.BAAS_UUID))) {
byte[] bId = listOfUuids.get(ParcelUuid.fromString(BassUtils.BAAS_UUID));
broadcastId = (0x00FF0000 & (bId[0] << 16));
broadcastId |= (0x0000FF00 & (bId[1] << 8));
broadcastId |= (0x000000FF & bId[2]);
}
}
mService.updatePAResultsMap(scanRes.getDevice(), scanRes.getAddressType(),
BCService.INVALID_SYNC_HANDLE, BCService.INVALID_ADV_SID,
scanRes.getPeriodicAdvertisingInterval(),
broadcastId);
}
}
else {
log("colocated case");
if (autoTriggerred) {
log("should never happen!!!");
//ignore
mAutoTriggerred = false;
}
///*_BMS
if (mBAService == null || mBAService.isBroadcastActive() != true) {
Log.e(TAG, "colocated source handle unavailable OR not in streaming");
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_COLOCATED_SRC_UNAVAILABLE);
mService.stopScanOffloadInternal(mDevice, false);
return false;
}
String colocatedAddress = null;
int colocatedAddressType;
if (mPublicAddrForcSrc == true) {
colocatedAddress = BluetoothAdapter.getDefaultAdapter().getAddress();
colocatedAddressType = BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC;
} else {
colocatedAddress = mBAService.BroadcastGetAdvAddress();
colocatedAddressType = mBAService.BroadcastGetAdvAddrType();
}
int paInterval = 0x0000FFFF;
paInterval = mBAService.BroadcastGetAdvInterval();
if (colocatedAddress == null) {
log("colocatedAddress is null");
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_COLOCATED_SRC_UNAVAILABLE);
mService.stopScanOffloadInternal(mDevice, false);
return false;
}
BluetoothDevice colocatedSrcDevice =
BluetoothAdapter.getDefaultAdapter().getRemoteDevice(colocatedAddress);
log("caching local Broacast details: " + colocatedSrcDevice);
//advSid is same as advHandle for collocated case
byte[] broadcast_id = mBAService.getBroadcastId();
broadcastId = (0x00FF0000 & (broadcast_id[2] << 16));
broadcastId |= (0x0000FF00 & (broadcast_id[1] << 8));
broadcastId |= (0x000000FF & broadcast_id[0]);
mService.updatePAResultsMap(colocatedSrcDevice, colocatedAddressType,
mBAService.BroadcatGetAdvHandle(),
mBAService.BroadcatGetAdvHandle(),
paInterval,
broadcastId);
BaseData localBase = new BaseData(mBAService.getNumSubGroups(),
mBAService.BroadcastGetBisInfo(),
mBAService.BroadcastGetMetaInfo());
localBase.printConsolidated();
//Use advHandle to cahce Base
mService.updateBASE(mBAService.BroadcatGetAdvHandle(), localBase);
mService.sendBroadcastSourceSelectedCallback(mDevice, localBase.getBroadcastChannels(),
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SUCCESS);
//_BMS*/
}
return true;
}
private void cancelActiveSync(BluetoothDevice sourceDev) {
log("cancelActiveSync");
boolean isCancelSyncNeeded = false;
BluetoothDevice activeSyncedSrc = mService.getActiveSyncedSource(mDevice);
if (activeSyncedSrc != null ) {
if (sourceDev == null) {
isCancelSyncNeeded = true;
} else if(activeSyncedSrc.equals(sourceDev)) {
isCancelSyncNeeded = true;
}
}
if (isCancelSyncNeeded) {
removeMessages(PSYNC_ACTIVE_TIMEOUT);
try {
log("calling unregisterSync");
mPeriodicAdvManager.unregisterSync(mPeriodicAdvCallback);
} catch (IllegalArgumentException ex) {
Log.w(TAG, "unregisterSync:IllegalArguementException");
//ignore
}
mService.clearPAResults(activeSyncedSrc);
mService.setActiveSyncedSource(mDevice, null);
if (mNoStopScanOffload != true) {
//trigger scan stop here
mService.stopScanOffloadInternal(mDevice, false);
}
}
mNoStopScanOffload = false;
}
/* Internal periodc Advertising manager callback
*
*/
private PeriodicAdvertisingCallback mPeriodicAdvCallback = new PeriodicAdvertisingCallback() {
@Override
public void onSyncEstablished(int syncHandle, BluetoothDevice device,
int advertisingSid, int skip, int timeout,
int status) {
log ("onSyncEstablished" + "syncHandle" + syncHandle +
"device" + device + "advertisingSid" + advertisingSid +
"skip" + skip + "timeout" + timeout + "status" +
status);
//turn off the LeScan once sync estd
mService.getBassUtils().leScanControl(false);
if (status == BluetoothGatt.GATT_SUCCESS) {
//upates syncHandle, advSid
mService.updatePAResultsMap(device,
BCService.INVALID_ADV_ADDRESS_TYPE,
syncHandle, advertisingSid,
BCService.INVALID_ADV_INTERVAL,
BCService.INVALID_BROADCAST_ID);
sendMessageDelayed(PSYNC_ACTIVE_TIMEOUT, PSYNC_ACTIVE_TIMEOUT_MS);
mService.setActiveSyncedSource(mDevice, device);
} else {
log("failed to sync to PA" + mPASyncRetryCounter);
mScanRes = null;
if (mAutoTriggerred == false) {
mService.sendBroadcastSourceSelectedCallback(mDevice, null,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SOURCE_UNAVAILABLE);
mService.stopScanOffloadInternal(mDevice, false);
}
mAutoTriggerred = false;
}
}
@Override
public void onPeriodicAdvertisingReport(PeriodicAdvertisingReport report) {
log( "onPeriodicAdvertisingReport");
//Parse the BIS indicies from report's service data
if (mFirstTimeBisDiscovery) {
parseScanRecord(report.getSyncHandle(),report.getData());
mFirstTimeBisDiscovery = false;
}
}
@Override
public void onSyncLost(int syncHandle) {
log( "OnSyncLost" + syncHandle);
BluetoothDevice srcDevice = mService.getDeviceForSyncHandle(syncHandle);
cancelActiveSync(srcDevice);
}
public void onSyncTransfered(BluetoothDevice device, int status) {
log("sync transferred:" + device + " : " + status);
}
};
private void broadcastReceiverState(BleBroadcastSourceInfo state, int index, int max_num_srcInfos) {
log("broadcastReceiverState: " + mDevice);
Intent intent = new Intent(BleBroadcastAudioScanAssistManager.ACTION_BROADCAST_SOURCE_INFO);
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
intent.putExtra(BleBroadcastSourceInfo.EXTRA_SOURCE_INFO, state);
intent.putExtra(BleBroadcastSourceInfo.EXTRA_SOURCE_INFO_INDEX, index);
intent.putExtra(BleBroadcastSourceInfo.EXTRA_MAX_NUM_SOURCE_INFOS, max_num_srcInfos);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT
| Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
mService.sendBroadcastAsUser(intent, UserHandle.ALL, BLUETOOTH_CONNECT,
Utils.getTempAllowlistBroadcastOptions());
}
private static boolean isEmpty(final byte[] data){
return IntStream.range(0, data.length).parallel().allMatch(i -> data[i] == 0);
}
private void processPASyncState(BleBroadcastSourceInfo srcInfo) {
log("processPASyncState" + srcInfo);
int serviceData = 0;
if (srcInfo == null) {
Log.e(TAG, "processPASyncState: srcInfo is null");
return;
}
if (srcInfo.getMetadataSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ) {
log("Initiate PAST procedure");
BCService.PAResults res = mService.getPAResults(srcInfo.getSourceDevice());
if (isAddedBroadcastSourceIsLocal(srcInfo.getSourceDevice()) &&
mService.isLocalBroadcasting()) {
if (res == null) {
log("Populate colocated PA and initiate PAST");
int colocatedAddressType;
if (mPublicAddrForcSrc == true) {
colocatedAddressType = BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC;
} else {
colocatedAddressType = mBAService.BroadcastGetAdvAddrType();
}
int broadcastId;
byte[] broadcast_id = mBAService.getBroadcastId();
broadcastId = (0x00FF0000 & (broadcast_id[2] << 16));
broadcastId |= (0x0000FF00 & (broadcast_id[1] << 8));
broadcastId |= (0x000000FF & broadcast_id[0]);
mService.updatePAResultsMap(srcInfo.getSourceDevice(), colocatedAddressType,
mBAService.BroadcatGetAdvHandle(),
mBAService.BroadcatGetAdvHandle(),
mBAService.BroadcastGetAdvInterval(),
broadcastId);
}
res = mService.getPAResults(srcInfo.getSourceDevice());
}
if (res != null) {
int syncHandle = res.mSyncHandle;
log("processPASyncState: syncHandle" + res.mSyncHandle);
if (mNoPast == false && syncHandle != BCService.INVALID_SYNC_HANDLE) {
if (isAddedBroadcastSourceIsLocal(srcInfo.getSourceDevice())) {
log("Collocated Case Initiate PAST for :" + mDevice + "syncHandle:" + syncHandle +
"serviceData" + serviceData);
serviceData = 0x000000FF & srcInfo.getSourceId();
serviceData = serviceData << 8;
//advA matches EXT_ADV_ADDRESS
//but not matches source address (as we would have written pAddr)
serviceData = serviceData & (~BROADCAST_ADV_ADDRESS_DONT_MATCHES_EXT_ADV_ADDRESS);
serviceData = serviceData | (BROADCAST_ADV_ADDRESS_DONT_MATCHES_SOURCE_ADV_ADDRESS);
try {
mPeriodicAdvManager.transferSetInfo(mDevice, serviceData, syncHandle,mPeriodicAdvCallback);
} catch (IllegalArgumentException ex) {
Log.w(TAG, "transferSetInfo: IllegalArgumentException : PAST failure");
//ignore
}
} else {
serviceData = 0x000000FF & srcInfo.getSourceId();
serviceData = serviceData << 8;
//advA matches EXT_ADV_ADDRESS
//also matches source address (as we would have written)
serviceData = serviceData & (~BROADCAST_ADV_ADDRESS_DONT_MATCHES_EXT_ADV_ADDRESS);
serviceData = serviceData & (~BROADCAST_ADV_ADDRESS_DONT_MATCHES_SOURCE_ADV_ADDRESS);
log("Initiate PAST for :" + mDevice + "syncHandle:" + syncHandle +
"serviceData" + serviceData);
mPeriodicAdvManager.transferSync(mDevice, serviceData, syncHandle);
}
}
} else {
Log.e(TAG, "There is no valid sync handle for this Source");
if (mAutoAssist) {
//initiate Auto Assist procedure for this device
mService.getBassUtils().triggerAutoAssist (srcInfo);
}
}
}
else if (srcInfo.getAudioSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED ||
srcInfo.getMetadataSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_NO_PAST) {
//Cancel the existing sync and Invalidate the sync handle
if (isAddedBroadcastSourceIsLocal(srcInfo.getSourceDevice()) == false) {
if (mSyncingOnBehalfOfGroup == false) {
//Cancel the Sync only If it is NOT syced on behalf of group.
//group based sync will be kept active PSYNC_ACTIVE_TIMEOUT seconds so that
//all group members can get back in sync
log("Unregister sync as It is non colocated");
cancelActiveSync(srcInfo.getSourceDevice());
}
} else {
//trigger scan stop here
mService.stopScanOffloadInternal(mDevice, false);
}
}
}
/*Actual OTA advertising address based check
Use this after the addition of Broadcast source*/
private boolean isAddedBroadcastSourceIsLocal (BluetoothDevice device)
{
if (device == null) {
Log.e(TAG, "device handle is null");
return false;
}
String localBroadcasterAddr = null;
///*_BMS
if (mPublicAddrForcSrc) {
localBroadcasterAddr = BluetoothAdapter.getDefaultAdapter().getAddress();
} else {
if (mBAService == null) {
mBAService = BroadcastService.getBroadcastService();
}
if (mBAService == null || mBAService.isBroadcastActive() != true) {
Log.e(TAG, "isAddedBroadcastSourceIsLocal: colocated source handle is unavailable");
return false;
}
localBroadcasterAddr = mBAService.BroadcastGetAdvAddress();
}
//_BMS*/
boolean ret = false;
if (localBroadcasterAddr == null) {
Log.e(TAG, "isAddedBroadcastSourceIsLocal: localBroadcasterAddr is null");
ret = false;
} else {
ret = localBroadcasterAddr.equals(device.getAddress());
}
log("isAddedBroadcastSourceIsLocal returns" +ret);
return ret;
}
private void checkAndUpdateBroadcastCode(BleBroadcastSourceInfo srcInfo) {
if (isAddedBroadcastSourceIsLocal(srcInfo.getSourceDevice())) {
if (mForceSB == true ||
srcInfo.getEncryptionStatus() == BleBroadcastSourceInfo.BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED) {
//query the Encryption Key from BMS and update
///*_BMS
byte[] colocatedBcastCode = mBAService.GetEncryptionKey(null);
if (mBAService.isBroadcastStreamingEncrypted() == false) {
Log.e(TAG, "seem to be Unencrypted colocated broadcast");
//do nothing
return;
}
log("colocatedBcastCode is " + colocatedBcastCode);
//queue a fresh command to update the
Message m = obtainMessage(BassClientStateMachine.SET_BCAST_CODE);
m.obj = srcInfo;
m.arg1 = FRESH;
log("checkAndUpdateBroadcastCode: src device: " + srcInfo.getSourceDevice());
sendMessage(m);
//_BMS*/
}
} else {
log("checkAndUpdateBroadcastCode");
//non colocated case, Broadcast PIN should have been updated from lyaer
//If there is pending one process it Now
if (srcInfo.getEncryptionStatus() == BleBroadcastSourceInfo.BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED &&
mSetBroadcastCodePending == true) {
//Make a QUEUED command
log("Update the Broadcast now");
Message m = obtainMessage(BassClientStateMachine.SET_BCAST_CODE);
m.obj = mSetBroadcastPINSrcInfo;
m.arg1 = QUEUED;
sendMessage(m);
mSetBroadcastCodePending = false;
mSetBroadcastPINSrcInfo = null;
}
}
}
private List<BleBroadcastSourceChannel> getListOfBisIndicies(int bisIndicies, int subGroupId, byte[] metaData) {
List<BleBroadcastSourceChannel> bcastIndicies = new ArrayList<BleBroadcastSourceChannel>();
int index =0;
log("getListOfBisIndicies:" + bisIndicies);
while (bisIndicies != 0) {
if ((bisIndicies & 0x00000001) == 0x00000001) {
BleBroadcastSourceChannel bI =
new BleBroadcastSourceChannel(index, Integer.toString(index), true, subGroupId, metaData);
bcastIndicies.add(bI);
log("Adding BIS index for :" + index);
}
bisIndicies = bisIndicies>>1;
index++;
}
return bcastIndicies;
}
private void processBroadcastReceiverState (byte[] receiverState, BluetoothGattCharacteristic characteristic) {
int index = -1;
boolean isEmptyEntry = false;
BleBroadcastSourceInfo srcInfo = null;
log("processBroadcastReceiverState:: characteristic:" + characteristic);
byte sourceId = 0;
if (receiverState.length > 0)
sourceId = receiverState[BCAST_RCVR_STATE_SRC_ID_IDX];
log("processBroadcastReceiverState: receiverState length: " + receiverState.length);
if (receiverState.length == 0 ||
isEmpty(Arrays.copyOfRange(receiverState, 1, receiverState.length-1))) {
log("This is an Empty Entry");
if (mPendingOperation == REMOVE_BCAST_SOURCE) {
srcInfo = new BleBroadcastSourceInfo(mPendingSourceId);
} else if (receiverState.length == 0) {
if (mBleBroadcastSourceInfos != null) {
mTempSourceId = (byte)mBleBroadcastSourceInfos.size();
}
if (mTempSourceId < NUM_OF_BROADCAST_RECEIVER_STATES) {
mTempSourceId++;
srcInfo = new BleBroadcastSourceInfo(mTempSourceId);
} else {
Log.e(TAG, "reached the remote supported max SourceInfos");
return;
}
}
isEmptyEntry = true;
//just create an Empty entry
if (srcInfo.isEmptyEntry()) {
log("An empty entry has been created");
}
}
else {
byte sourceAddressType = receiverState[BCAST_RCVR_STATE_SRC_ADDR_TYPE_IDX];
byte[] sourceAddress = new byte[BCAST_RCVR_STATE_SRC_ADDR_SIZE];
System.arraycopy(receiverState, BCAST_RCVR_STATE_SRC_ADDR_START_IDX, sourceAddress, 0, BCAST_RCVR_STATE_SRC_ADDR_SIZE);
byte sourceAdvSid = receiverState[BCAST_RCVR_STATE_SRC_ADV_SID_IDX];
byte[] broadcastIdBytes = new byte[BROADCAST_SOURCE_ID_LENGTH];
System.arraycopy(receiverState, BCAST_RCVR_STATE_SRC_BCAST_ID_START_IDX, broadcastIdBytes, 0, BROADCAST_SOURCE_ID_LENGTH);
int broadcastId = (0x00FF0000 & (broadcastIdBytes[2] << 16));
broadcastId |= (0x0000FF00 & (broadcastIdBytes[1] << 8));
broadcastId |= (0x000000FF & broadcastIdBytes[0]);
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
BluetoothDevice device = btAdapter.getRemoteDevice(reverseBytes(sourceAddress));
byte metaDataSyncState = receiverState[BCAST_RCVR_STATE_PA_SYNC_IDX];
byte encyptionStatus = receiverState[BCAST_RCVR_STATE_ENC_STATUS_IDX];
byte[] badBroadcastCode = null;
byte badBroadcastCodeLen = 0;
byte numSubGroups = 0;
byte[] metadataLength = null;
byte[] metaData = null;
if (encyptionStatus == BleBroadcastSourceInfo.BROADCAST_ASSIST_ENC_STATE_BADCODE) {
badBroadcastCode = new byte[BCAST_RCVR_STATE_BADCODE_SIZE];
System.arraycopy(receiverState, BCAST_RCVR_STATE_BADCODE_START_IDX, badBroadcastCode, 0, BCAST_RCVR_STATE_BADCODE_SIZE);
badBroadcastCode = reverseBytes(badBroadcastCode);
badBroadcastCodeLen = BCAST_RCVR_STATE_BADCODE_SIZE;
}
numSubGroups = receiverState[BCAST_RCVR_STATE_BADCODE_START_IDX + badBroadcastCodeLen];
int offset = BCAST_RCVR_STATE_BADCODE_START_IDX + badBroadcastCodeLen + 1;
//Map of Bis Status <subGroupId, List_OF_Broadcast_channel>
Map<Integer, List<BleBroadcastSourceChannel>> bisIndexList = new HashMap<Integer, List<BleBroadcastSourceChannel>>();
//Map for Metada <subGroupId, Metadata>
Map<Integer, byte[]> metadataList = new HashMap<Integer, byte[]>();
metadataLength = new byte[numSubGroups];
byte audioSyncState = 0;
for (int i = 0; i < numSubGroups; i++) {
byte[] audioSyncIndex = new byte[BCAST_RCVR_STATE_BIS_SYNC_SIZE];
System.arraycopy(receiverState, offset, audioSyncIndex, 0, BCAST_RCVR_STATE_BIS_SYNC_SIZE);
offset = offset + BCAST_RCVR_STATE_BIS_SYNC_SIZE;
log("BIS index byte array: ");
BassUtils.printByteArray(audioSyncIndex);
ByteBuffer wrapped = ByteBuffer.wrap(reverseBytes(audioSyncIndex));
int audioBisIndex = wrapped.getInt();
if (audioBisIndex == 0xFFFFFFFF) {
log("Remote failed to sync to BIS");
audioSyncState = 0x00;
audioBisIndex = 0;
} else {
//Bits (0-30)=> (1-31)
audioBisIndex = audioBisIndex << 1;
log("BIS index converted: " + audioBisIndex);
if (audioBisIndex != 0){
//If any BIS is in sync, Set Audio state as ON
audioSyncState = 0x01;
}
}
metadataLength[i] = receiverState[offset++];
if (metadataLength[i] != 0) {
log("metadata of length: " + metadataLength[i] + "is avaialble");
metaData = new byte[metadataLength[i]];
System.arraycopy(receiverState, offset, metaData, 0, metadataLength[i]);
offset = offset + metadataLength[i];
metaData = reverseBytes(metaData);
metadataList.put(i, metaData);
}
bisIndexList.put(i, getListOfBisIndicies(audioBisIndex, i, metaData));
}
srcInfo = new BleBroadcastSourceInfo(device,
sourceId,
sourceAdvSid,
broadcastId,
(int)sourceAddressType,
(int)metaDataSyncState,
(int)encyptionStatus,
badBroadcastCode,
numSubGroups,
(int)audioSyncState,
bisIndexList,
metadataList
);
}
BleBroadcastSourceInfo oldSourceInfo = mBleBroadcastSourceInfos.get(characteristic.getInstanceId());
if (oldSourceInfo == null) {
log("Initial Read and Populating values");
if (mBleBroadcastSourceInfos.size() == NUM_OF_BROADCAST_RECEIVER_STATES) {
Log.e(TAG, "reached the Max SourceInfos");
return;
}
mBleBroadcastSourceInfos.put(characteristic.getInstanceId(), srcInfo);
checkAndUpdateBroadcastCode(srcInfo);
processPASyncState(srcInfo);
} else {
log("old sourceInfo: " + oldSourceInfo);
log("new sourceInfo: " + srcInfo);
mBleBroadcastSourceInfos.replace(characteristic.getInstanceId(), srcInfo);
if (oldSourceInfo.isEmptyEntry() == true) {
log("New Source Addition");
sendPendingCallbacks(ADD_BCAST_SOURCE,
srcInfo.getSourceId(), BluetoothGatt.GATT_SUCCESS);
checkAndUpdateBroadcastCode(srcInfo);
processPASyncState(srcInfo);
} else {
if (isEmptyEntry) {
BluetoothDevice removedDevice = oldSourceInfo.getSourceDevice();
log("sourceInfo removal" + removedDevice);
cancelActiveSync(removedDevice);
sendPendingCallbacks(REMOVE_BCAST_SOURCE,
srcInfo.getSourceId(), BluetoothGatt.GATT_SUCCESS);
} else {
log("update to an existing srcInfo");
sendPendingCallbacks(UPDATE_BCAST_SOURCE,
srcInfo.getSourceId(),BluetoothGatt.GATT_SUCCESS);
processPASyncState(srcInfo);
checkAndUpdateBroadcastCode(srcInfo);
}
}
}
index = srcInfo.getSourceId();
if (index == -1) {
log("processBroadcastReceiverState: invalid index");
return;
}
broadcastReceiverState(srcInfo, index, NUM_OF_BROADCAST_RECEIVER_STATES);
}
// Implements callback methods for GATT events that the app cares about. For example,
// connection change and services discovered.
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
boolean isStateChanged = false;
log( "onConnectionStateChange : Status=" + status + "newState" + newState);
if (newState == BluetoothProfile.STATE_CONNECTED && getConnectionState() != BluetoothProfile.STATE_CONNECTED) {
isStateChanged = true;
Log.w(TAG, "Bassclient Connected from Disconnected state: " + mDevice);
if (mService.okToConnect(mDevice)) {
log("Bassclient Connected to: " + mDevice);
if (mBluetoothGatt != null) {
log( "Attempting to start service discovery:" +
mBluetoothGatt.discoverServices());
mDiscoveryInitiated = true;
}
} else {
if (mBluetoothGatt != null) {
// Reject the connection
Log.w(TAG, "Bassclient Connect request rejected: " + mDevice);
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
//force move to disconnected
newState = BluetoothProfile.STATE_DISCONNECTED;
}
}
} else if (newState == BluetoothProfile.STATE_DISCONNECTED &&
getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) {
isStateChanged = true;
log( "Disconnected from Bass GATT server.");
}
if (isStateChanged) {
Message m = obtainMessage(CONNECTION_STATE_CHANGED);
m.obj = newState;
sendMessage(m);
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
log("onServicesDiscovered:" + status);
if (mDiscoveryInitiated == true) {
mDiscoveryInitiated = false;
if (status == BluetoothGatt.GATT_SUCCESS && mBluetoothGatt != null) {
mBluetoothGatt.requestMtu(BASS_MAX_BYTES);
mMTUChangeRequested = true;
} else {
Log.w(TAG, "onServicesDiscovered received: " + status
+ "mBluetoothGatt" + mBluetoothGatt);
}
} else {
log("remote initiated callback");
//do nothing
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic,
int status) {
log( "onCharacteristicRead:: status: " + status + "char:" + characteristic);
if (status == BluetoothGatt.GATT_SUCCESS &&
characteristic.getUuid().equals(BASS_BCAST_RECEIVER_STATE)) {
log( "onCharacteristicRead: BASS_BCAST_RECEIVER_STATE: status" + status);
logByteArray("Received ", characteristic.getValue(), 0,
characteristic.getValue().length);
if (characteristic.getValue() == null) {
Log.e(TAG, "Remote receiver state is NULL");
return;
}
processBroadcastReceiverState(characteristic.getValue(), characteristic);
}
// switch to receiving notifications after initial characteristic read
BluetoothGattDescriptor desc = characteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG);
if (mBluetoothGatt != null && desc != null) {
log("Setting the value for Desc");
mBluetoothGatt.setCharacteristicNotification(characteristic, true);
desc.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(desc);
} else {
Log.w(TAG, "CCC for " + characteristic + "seem to be not present");
//atleast move the SM to stable state
Message m = obtainMessage(GATT_TXN_PROCESSED);
m.arg1 = status;
sendMessage(m);
}
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor,
int status) {
log("onDescriptorWrite");
if (status == BluetoothGatt.GATT_SUCCESS &&
descriptor.getUuid().equals(CLIENT_CHARACTERISTIC_CONFIG)) {
log("CCC write resp");
}
//Move the SM to connected so further reads happens
Message m = obtainMessage(GATT_TXN_PROCESSED);
m.arg1 = status;
sendMessage(m);
}
@Override
public void onMtuChanged(BluetoothGatt gatt, int mtu, int status)
{
log("onMtuChanged: mtu:" + mtu);
if (mMTUChangeRequested == true && mBluetoothGatt != null) {
acquireAllBassChars();
mMTUChangeRequested = false;
} else {
log("onMtuChanged is remote initiated trigger, mBluetoothGatt:" + mBluetoothGatt);
//Do nothing
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
log( "onCharacteristicChanged :: "
+ characteristic.getUuid().toString());
if (characteristic.getUuid().equals(BASS_BCAST_RECEIVER_STATE)) {
log( "onCharacteristicChanged is rcvr State :: "
+ characteristic.getUuid().toString());
if (characteristic.getValue() == null) {
Log.e(TAG, "Remote receiver state is NULL");
return;
}
logByteArray("onCharacteristicChanged: Received ", characteristic.getValue(), 0,
characteristic.getValue().length);
processBroadcastReceiverState(characteristic.getValue(), characteristic);
}
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status) {
log( "onCharacteristicWrite: "
+ characteristic.getUuid().toString()
+ "status:" + status);
if (status == 0 &&
characteristic.getUuid().equals(BASS_BCAST_AUDIO_SCAN_CTRL_POINT)) {
log( "BASS_BCAST_AUDIO_SCAN_CTRL_POINT is written successfully");
}
Message m = obtainMessage(GATT_TXN_PROCESSED);
m.arg1 = status;
sendMessage(m);
}
};
public List<BleBroadcastSourceInfo> getAllBroadcastSourceInformation() {
log( "getAllBroadcastSourceInformation");
List list = new ArrayList(mBleBroadcastSourceInfos.values());
return list;
}
void acquireAllBassChars() {
clearCharsCache();
BluetoothGattService service = null;
if (mBluetoothGatt != null) {
log("getting Bass Service handle");
service = mBluetoothGatt.getService(BASS_UUID);
}
if (service != null) {
log( "found BASS_SERVICE");
List<BluetoothGattCharacteristic> allChars = service.getCharacteristics();
int numOfChars = allChars.size();
NUM_OF_BROADCAST_RECEIVER_STATES = numOfChars-1;
log( "Total number of chars" + numOfChars);
//static var to keep track of read callbacks
num_of_recever_states = NUM_OF_BROADCAST_RECEIVER_STATES;
for (int i = 0; i < allChars.size(); i++) {
if (allChars.get(i).getUuid().equals(BASS_BCAST_AUDIO_SCAN_CTRL_POINT)) {
mBroadcastScanControlPoint = allChars.get(i);
log( "Index of ScanCtrlPoint:" + i);
} else {
log( "Reading " + i + "th ReceiverState");
mBroadcastReceiverStates.add(allChars.get(i));
Message m = obtainMessage(READ_BASS_CHARACTERISTICS);
m.obj = allChars.get(i);
sendMessage(m);
}
}
} else {
Log.e(TAG, "acquireAllBassChars: BASS service not found");
}
}
void clearCharsCache() {
if (mBroadcastReceiverStates != null) {
mBroadcastReceiverStates.clear();
}
if (mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint = null;
}
num_of_recever_states = 0;
if (mBleBroadcastSourceInfos != null) {
mBleBroadcastSourceInfos.clear();
}
mPendingOperation = -1;
}
@VisibleForTesting
class Disconnected extends State {
@Override
public void enter() {
log( "Enter Disconnected(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
clearCharsCache();
mTempSourceId = 0;
removeDeferredMessages(DISCONNECT);
if (mLastConnectionState == -1) {
log( "no Broadcast of initial profile state ");
} else {
if (mPacsAvail == true) {
/*_PACS
PacsClientService mPacsClientService = PacsClientService.getPacsClientService();
if (mPacsClientService != null) {
log("trigger disconnect to Pacs");
mPacsClientService.disconnect(mDevice);
} else {
Log.e(TAG, "PACs interface is null");
}
_PACS*/
}
///*_VCP
if (mVcpForBroadcast) {
VcpController vcpController = VcpController.getVcpController();
if (vcpController != null) {
log("trigger disconnect to Vcp Renderer");
if (!vcpController.disconnect(mDevice, BluetoothVcp.MODE_BROADCAST)) {
log("Disconnect Vcp failed");
}
} else {
Log.e(TAG, "VcpController interface is null");
}
}
//_VCP*/
broadcastConnectionState(mDevice, mLastConnectionState,
BluetoothProfile.STATE_DISCONNECTED);
}
}
@Override
public void exit() {
log("Exit Disconnected(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
mLastConnectionState = BluetoothProfile.STATE_DISCONNECTED;
}
@Override
public boolean processMessage(Message message) {
log("Disconnected process message(" + mDevice + "): " + messageWhatToString(
message.what));
switch (message.what) {
case CONNECT:
log("Connecting to " + mDevice);
if (mBluetoothGatt != null) {
Log.d(TAG, "clear off, pending wl connection");
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
}
if ((mBluetoothGatt = mDevice.connectGatt(mService, mIsWhitelist, mGattCallback,
BluetoothDevice.TRANSPORT_LE, false, (BluetoothDevice.PHY_LE_1M_MASK |
BluetoothDevice.PHY_LE_2M_MASK | BluetoothDevice.PHY_LE_CODED_MASK),
null, true)) == null) {
Log.e(TAG, "Disconnected: error connecting to " + mDevice);
break;
} else {
transitionTo(mConnecting);
}
break;
case DISCONNECT:
Log.w(TAG, "Disconnected: DISCONNECT ignored: " + mDevice);
break;
case CONNECTION_STATE_CHANGED:
int state = (int)message.obj;
Log.w(TAG, "connection state changed:" + state);
if (state == BluetoothProfile.STATE_CONNECTED) {
log("remote/wl connection, ensure csip is up as well");
if (mNoCSIPReconn == false && mService != null &&
mService.isLockSupportAvailable(mDevice)) {
/////*_CSIP
mCsipConnected = false;
mSetCoordinator.connect(mService.mCsipAppId, mDevice);
transitionTo(mConnecting);
break;
////_CSIP*/
} else {
transitionTo(mConnected);
}
} else {
Log.w(TAG, "Disconected: Connection failed to " + mDevice);
}
break;
case PSYNC_ACTIVE_TIMEOUT:
cancelActiveSync(null);
break;
default:
log("DISCONNECTED: not handled message:" + message.what);
return NOT_HANDLED;
}
return HANDLED;
}
}
@VisibleForTesting
class Connecting extends State {
@Override
public void enter() {
log( "Enter Connecting(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
sendMessageDelayed(CONNECT_TIMEOUT, mDevice, mConnectTimeoutMs);
broadcastConnectionState(mDevice, mLastConnectionState,
BluetoothProfile.STATE_CONNECTING);
}
@Override
public void exit() {
log("Exit Connecting(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
mLastConnectionState = BluetoothProfile.STATE_CONNECTING;
removeMessages(CONNECT_TIMEOUT);
}
@Override
public boolean processMessage(Message message) {
log("Connecting process message(" + mDevice + "): " + messageWhatToString(
message.what));
switch (message.what) {
case CONNECT:
log("Already Connecting to " + mDevice);
log("Ignore this connection request " + mDevice);
break;
case DISCONNECT:
Log.w(TAG, "Connecting: DISCONNECT deferred: " + mDevice);
deferMessage(message);
break;
case READ_BASS_CHARACTERISTICS:
Log.w(TAG, "defer READ_BASS_CHARACTERISTICS requested!: " + mDevice);
deferMessage(message);
break;
case CSIP_CONNECTION_STATE_CHANGED:
int state = (int)message.obj;
if (state == BluetoothProfile.STATE_CONNECTED) {
///*_CSIP
if (mCsipConnected == true) {
Log.e(TAG, "CSIP is already up, ignore this DUP event");
break;
}
mCsipConnected = true;
Log.d(TAG, "Csip connected");
transitionTo(mConnected);
} else {
Log.w(TAG, "CSIP Connection failed to " + mDevice);
if (mBluetoothGatt != null) {
//disc bass
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
}
transitionTo(mDisconnected);
}
break;
case CONNECTION_STATE_CHANGED:
state = (int)message.obj;
Log.w(TAG, "Connecting: connection state changed:" + state);
if (state == BluetoothProfile.STATE_CONNECTED) {
if (mService != null &&
mService.isLockSupportAvailable(mDevice)) {
///*_CSIP
//If Lock support available & connect to csip
mCsipConnected = false;
mSetCoordinator.connect(mService.mCsipAppId, mDevice);
break;
//_CSIP*/
} else {
transitionTo(mConnected);
}
} else {
Log.w(TAG, "Connection failed to " + mDevice);
transitionTo(mDisconnected);
}
break;
case CONNECT_TIMEOUT:
Log.w(TAG, "CONNECT_TIMEOUT");
BluetoothDevice device = (BluetoothDevice) message.obj;
if (!mDevice.equals(device)) {
Log.e(TAG, "Unknown device timeout " + device);
break;
}
transitionTo(mDisconnected);
break;
case PSYNC_ACTIVE_TIMEOUT:
deferMessage(message);
break;
default:
log("CONNECTING: not handled message:" + message.what);
return NOT_HANDLED;
}
return HANDLED;
}
}
private byte[] reverseBytes(byte[] a) {
if (mNoReverse) {
log("no reverse is enabled>");
return a;
}
for(int i=0; i<a.length/2; i++){
byte tmp = a[i];
a[i] = a[a.length -i -1];
a[a.length -i -1] = tmp;
}
return a;
}
private byte[] BluetoothAddressToBytes (String s) {
log("BluetoothAddressToBytes: input string:" + s);
String[] splits = s.split(":");
byte[] addressBytes = new byte[6];
for (int i=0; i<6; i++) {
int hexValue = Integer.parseInt(splits[i], 16);
log("hexValue:" + hexValue);
addressBytes[i] = (byte)hexValue;
}
return addressBytes;
}
private int convertBisIndiciesToIntegerValue(List<BleBroadcastSourceChannel> bisIndicies, int subGroupId) {
int audioBisIndex = 0;
if (bisIndicies != null) {
for (int i=0; i<bisIndicies.size(); i++) {
if (bisIndicies.get(i).getStatus() == true && bisIndicies.get(i).getSubGroupId() == subGroupId) {
audioBisIndex = audioBisIndex | 1<<(bisIndicies.get(i).getIndex()-1);
log( "set the bit" + bisIndicies.get(i).getIndex() + "after:" + audioBisIndex);
}
}
} else {
log("bisIndicies Channels are null");
audioBisIndex = 0xFFFFFFFF;
}
log( "audioBisIndex" + audioBisIndex);
return audioBisIndex;
}
private byte[] convertSourceInfoToAddSourceByteArray(BleBroadcastSourceInfo srcInfo) {
byte[] res;
/*fixed length for add source op*/
int addSourceFixedLength = 16;
byte[] metaDataLength = null;
BluetoothDevice broadcastSource = null;
String localBcastAddr = null;
BCService.PAResults paRes = null;
log("Get PAresults for :" + srcInfo.getSourceDevice());
broadcastSource = srcInfo.getSourceDevice();
///*_BMS
if (mPublicAddrForcSrc == false) {
if (isLocalBroadcastSource(broadcastSource)){
//update broadcastSource if it is colocated
if (mBAService != null) {
localBcastAddr = mBAService.BroadcastGetAdvAddress();
}
if (localBcastAddr == null) {
Log.w(TAG, "convertSourceInfoToAddSourceByteArray: localBCast not avaiable");
sendPendingCallbacks(ADD_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SOURCE_UNAVAILABLE);
return null;
} else {
broadcastSource =
BluetoothAdapter.getDefaultAdapter().getRemoteDevice(localBcastAddr);
log("convertSourceInfoToAddSourceByteArray: colocated case: " + broadcastSource);
}
}
}
//_BMS*/
paRes = mService.getPAResults(broadcastSource);
if (paRes == null) {
Log.e(TAG, "No mathcing psync, scan res for this addition");
sendPendingCallbacks(ADD_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SOURCE_UNAVAILABLE);
return null;
}
//populate metadata from BASE levelOne
BaseData base_ = mService.getBASE(paRes.mSyncHandle);
if (base_ == null) {
Log.e(TAG, "No valid base data populated for this device");
sendPendingCallbacks(ADD_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_SOURCE_UNAVAILABLE);
return null;
}
int numSubGroups = base_.getNumberOfSubgroupsofBIG();
metaDataLength = new byte[numSubGroups];
int totalMetadataLength = 0;
for (int i=0; i<numSubGroups; i++) {
if (base_.getMetadata(i) == null) {
Log.w(TAG, "no valid metadata from BASE");
metaDataLength[i] = 0;
} else {
metaDataLength[i] = (byte)base_.getMetadata(i).length;
log("metaDataLength updated:" + metaDataLength[i]);
}
totalMetadataLength = totalMetadataLength + metaDataLength[i];
}
res = new byte [addSourceFixedLength + numSubGroups*5 + totalMetadataLength];
srcInfo.setSourceDevice(broadcastSource);
srcInfo.setAdvAddressType((byte)paRes.mAddressType);
srcInfo.setAdvertisingSid((byte)paRes.mAdvSid);
srcInfo.setBroadcasterId(paRes.mBroadcastId);
if (isValidBroadcastSourceInfo(srcInfo) == false) {
log("Discarding this Add Broadcast source If It is DUP");
sendPendingCallbacks(ADD_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_DUPLICATE_ADDITION);
return null;
}
res[0] = BASS_ADD_SOURCE_OPCODE;
res[1] = (byte)paRes.mAddressType;
String address = broadcastSource.getAddress();
byte[] addrByteVal = BluetoothAddressToBytes(address);
log("Address bytes: " + Arrays.toString(addrByteVal));
byte[] revAddress= reverseBytes(addrByteVal);
log("reverse Address bytes: " + Arrays.toString(revAddress));
System.arraycopy(revAddress, 0, res, 2, 6);
res[8] = (byte)paRes.mAdvSid;
//System.arraycopy(paRes.mBroadcastId, 0, res, 9, BROADCAST_SOURCE_ID_LENGTH);
log("mBroadcastId: " + paRes.mBroadcastId);
res[9] = (byte)(paRes.mBroadcastId & 0x00000000000000FF);
res[10] = (byte)((paRes.mBroadcastId & 0x000000000000FF00) >>> 8);
res[11] = (byte)((paRes.mBroadcastId & 0x0000000000FF0000) >>> 16);
if (mDefNoPAS == false &&
srcInfo.getMetadataSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC) {
res[12] = (byte)(0x01);
} else {
log("setting PA sync to ZERO");
res[12] = (byte)0x00;
}
res[13] = (byte)(paRes.mPAInterval & 0x00000000000000FF);
res[14] = (byte)((paRes.mPAInterval & 0x000000000000FF00)>>>8);
res[15] = base_.getNumberOfSubgroupsofBIG();
int offset = 16;
for (int i=0; i<base_.getNumberOfSubgroupsofBIG(); i++) {
//Select based on PACs?
//int bisIndexValue = convertBisIndiciesToIntegerValue(srcInfo.getBroadcastChannelsSyncStatus());
int bisIndexValue = convertBisIndiciesToIntegerValue(mService.getBassUtils().selectBises(mDevice, srcInfo, base_), i);
res[offset++] = (byte)(bisIndexValue & 0x00000000000000FF);
res[offset++] = (byte)((bisIndexValue & 0x000000000000FF00)>>>8);
res[offset++] = (byte)((bisIndexValue & 0x0000000000FF0000)>>>16);
res[offset++] = (byte)((bisIndexValue & 0x00000000FF000000)>>>24);
res[offset++] = metaDataLength[i];
if (metaDataLength[i] != 0) {
if (isLocalBroadcastSource(broadcastSource) == false) {
byte[] revMetadata = reverseBytes(base_.getMetadata(i));
System.arraycopy(revMetadata, 0, res, offset, metaDataLength[i]);
} else {
System.arraycopy(base_.getMetadata(i), 0, res, offset, metaDataLength[i]);
}
}
offset = offset + metaDataLength[i];
}
log("ADD_BCAST_SOURCE in Bytes");
BassUtils.printByteArray(res);
return res;
}
private byte[] convertSourceInfoToUpdateSourceByteArray(BleBroadcastSourceInfo srcInfo) {
byte[] res;
int updateSourceFixedLength = 6;
BCService.PAResults paRes = null;
BleBroadcastSourceInfo existingSI = getBroadcastSourceInfoForSourceId(srcInfo.getSourceId());
if (existingSI == null) {
log("no existing SI for update source op");
return null;
}
byte numSubGroups = existingSI.getNumberOfSubGroups();
//on Modify source, dont update any Metadata
byte metaDataLength = 0;
res = new byte [updateSourceFixedLength + numSubGroups*5];
res[0] = BASS_UPDATE_SOURCE_OPCODE;
res[1] = srcInfo.getSourceId();
if (srcInfo.getMetadataSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC) {
res[2] = (byte)(0x01);
} else {
res[2] = (byte)0x00;
}
//update these from existing SI
BluetoothDevice existingSrcDevice = existingSI.getSourceDevice();
if (isAddedBroadcastSourceIsLocal(existingSrcDevice)) {
int paInterval = 0x0000FFFF;
paInterval = mBAService.BroadcastGetAdvInterval();
res[4] = (byte)((paInterval & 0x000000000000FF00)>>>8);
res[3] = (byte)(paInterval & 0x00000000000000FF);
} else {
//for non-c mmodify op, set PA Interval as UNKNOWN
res[4] = (byte)0xFF;
res[3] = (byte)0xFF;
}
//For modify op, just set number of Subgroups as UNKNOWN
//ZERO is treated as UNKNOWN
res[5] = numSubGroups;
int offset = 6;
int bisIndexValue = 0;
Map<Integer, Integer> bisIndexList = existingSI.getBisIndexList();
if (srcInfo.getAudioSyncState() == BleBroadcastSourceInfo.BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED) {
//Force BIS index value to NO_PREF for modify SRC
bisIndexValue = 0xFFFFFFFF;
} else {
bisIndexValue = 0x00000000;
}
log("UPDATE_BCAST_SOURCE b4: bisIndexValue : " + bisIndexValue);
//If there is an empty List, set NO pref all subgroups
if (bisIndexList == null || bisIndexList.size() == 0) {
bisIndexValue = 0xFFFFFFFF;
}
for (int i=0; i<numSubGroups; i++) {
//Select based on PACs?
//int bisIndexValue = convertBisIndiciesToIntegerValue(srcInfo.getBroadcastChannelsSyncStatus());
if (bisIndexValue != 0xFFFFFFFF && bisIndexValue != 0) {
bisIndexValue = bisIndexList.get(i);
}
log("UPDATE_BCAST_SOURCE: bisIndexValue : " + bisIndexValue);
res[offset++] = (byte)(bisIndexValue & 0x00000000000000FF);
res[offset++] = (byte)((bisIndexValue & 0x000000000000FF00)>>>8);
res[offset++] = (byte)((bisIndexValue & 0x0000000000FF0000)>>>16);
res[offset++] = (byte)((bisIndexValue & 0x00000000FF000000)>>>24);
res[offset++] = metaDataLength;
}
log("UPDATE_BCAST_SOURCE in Bytes");
BassUtils.printByteArray(res);
return res;
}
private byte[] convertAsciitoValues (byte[] val) {
byte[] ret = new byte[val.length];
for (int i=0; i< val.length; i++) {
ret[i] = (byte)(val[i] - (byte)'0');
}
log("convertAsciitoValues: returns:" + Arrays.toString(val));
return ret;
}
private byte[] convertSourceInfoToSetBroadcastCodeByteArray(BleBroadcastSourceInfo srcInfo) {
byte[] res = new byte[PIN_CODE_CMD_LEN];
res[0] = BASS_SET_BCAST_PIN_OPCODE;
res[1] = srcInfo.getSourceId();
log("convertSourceInfoToSetBroadcastCodeByteArray: Source device : " + srcInfo.getSourceDevice());
byte[] actualPIN = null;
//srcInfo.getSourceDevice() will be NULL if this request coming from SDK
// srcInfo.getSourceDevice() will have valid Source device only If this is
//collocated device
if (srcInfo.getSourceDevice() != null &&
isAddedBroadcastSourceIsLocal(srcInfo.getSourceDevice())) {
//colocated Source addition
//query the Encryption Key from BMS and update
///*_BMS
actualPIN = mBAService.GetEncryptionKey(null);
//_BMS*/
log("colocatedBcastCode is " + Arrays.toString(actualPIN));
} else {
//Can Keep as ASCII as is
String reversePIN = new StringBuffer(srcInfo.getBroadcastCode()).reverse().toString();
actualPIN = reversePIN.getBytes();
}
if (actualPIN == null) {
Log.e(TAG, "actual PIN is null");
return null;
} else {
log( "byte array broadcast Code:" + Arrays.toString(actualPIN));
log( "pinLength:" + actualPIN.length);
//Fill the PIN code in the Last Position
System.arraycopy(actualPIN, 0, res, ((PIN_CODE_CMD_LEN)-actualPIN.length), actualPIN.length);
log("SET_BCAST_PIN in Bytes");
BassUtils.printByteArray(res);
}
return res;
}
private boolean IsItRightTimeToUpdateBroadcastPIN(byte srcId) {
Collection<BleBroadcastSourceInfo> srcInfos = mBleBroadcastSourceInfos.values();
Iterator<BleBroadcastSourceInfo> iterator = srcInfos.iterator();
boolean ret = false;
if (mForceSB) {
log("force SB is set");
return true;
}
while (iterator.hasNext()) {
BleBroadcastSourceInfo sI = iterator.next();
if (sI == null) {
log("src Info is null");
continue;
}
if (srcId == sI.getSourceId() &&
sI.getEncryptionStatus() == BleBroadcastSourceInfo.BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED) {
ret = true;
break;
}
}
log("IsItRightTimeToUpdateBroadcastPIN returning:" + ret);
return ret;
}
@VisibleForTesting
class Connected extends State {
@Override
public void enter() {
log( "Enter Connected(" + mDevice + "): "
+ messageWhatToString(getCurrentMessage().what));
removeDeferredMessages(CONNECT);
if (mLastConnectionState == BluetoothProfile.STATE_CONNECTED) {
log("CONNECTED->CONNTECTED: Ignore");
} else {
broadcastConnectionState(mDevice, mLastConnectionState,
BluetoothProfile.STATE_CONNECTED);
//initialize PACs for this devices
if (mPacsAvail == true) {
/*
PacsClientService mPacsClientService = PacsClientService.getPacsClientService();
if (mPacsClientService != null) {
log("trigger connect to Pacs");
mPacsClientService.connect(mDevice);
} else {
Log.e(TAG, "PACs interface is null");
}
*/
}
///*_VCP
if (mVcpForBroadcast) {
VcpController vcpController = VcpController.getVcpController();
if (vcpController != null) {
log("trigger connect to Vcp Renderer");
if (!vcpController.connect(mDevice, BluetoothVcp.MODE_BROADCAST)) {
log("Connect vcp failed");
}
} else {
Log.e(TAG, "VcpController interface is null");
}
}
//_VCP*/
}
}
@Override
public void exit() {
log("Exit Connected(" + mDevice + "): "
+ messageWhatToString(getCurrentMessage().what));
mLastConnectionState = BluetoothProfile.STATE_CONNECTED;
}
@Override
public boolean processMessage(Message message) {
log("Connected process message(" + mDevice + "): "
+ messageWhatToString(message.what));
BleBroadcastSourceInfo srcInfo;
switch (message.what) {
case CONNECT:
Log.w(TAG, "Connected: CONNECT ignored: " + mDevice);
break;
case DISCONNECT:
log("Disconnecting from " + mDevice);
if (mBluetoothGatt != null) {
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
//transitionTo(mDisconnecting);
cancelActiveSync(null);
//Trigger the CSip disconnection, dont worry about pass/failure
if (mCsipConnected && mSetCoordinator != null) {
mSetCoordinator.disconnect(mService.mCsipAppId, mDevice);
mCsipConnected = false;
}
transitionTo(mDisconnected);
} else {
log("mBluetoothGatt is null");
}
break;
case CONNECTION_STATE_CHANGED:
int state = (int)message.obj;
Log.w(TAG, "Connected:connection state changed:" + state);
if (state == BluetoothProfile.STATE_CONNECTED) {
Log.w(TAG, "device is already connected to Bass" + mDevice);
} else {
Log.w(TAG, "unexpected disconnected from " + mDevice);
cancelActiveSync(null);
///*_CSIP
//Trigger the CSip disconnection, dont worry about pass/failure
if (mCsipConnected) {
mSetCoordinator.disconnect(mService.mCsipAppId, mDevice);
mCsipConnected = false;
}
//_CSIP*/
transitionTo(mDisconnected);
}
break;
case READ_BASS_CHARACTERISTICS:
BluetoothGattCharacteristic characteristic = (BluetoothGattCharacteristic)message.obj;
if (mBluetoothGatt != null) {
mBluetoothGatt.readCharacteristic(characteristic);
transitionTo(mConnectedProcessing);
} else {
Log.e(TAG, "READ_BASS_CHARACTERISTICS is ignored, Gatt handle is null");
}
break;
case START_SCAN_OFFLOAD:
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(REMOTE_SCAN_START);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
transitionTo(mConnectedProcessing);
} else {
log("no Bluetooth Gatt handle, may need to fetch write");
}
break;
case STOP_SCAN_OFFLOAD:
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(REMOTE_SCAN_STOP);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
transitionTo(mConnectedProcessing);
} else {
log("no Bluetooth Gatt handle, may need to fetch write");
}
break;
case SELECT_BCAST_SOURCE:
ScanResult scanRes = (ScanResult)message.obj;
boolean auto = ((int) message.arg1) == AUTO;
boolean isGroupOp = ((int) message.arg2) == GROUP_OP;
selectBroadcastSource(scanRes, isGroupOp, auto);
break;
case ADD_BCAST_SOURCE:
srcInfo = (BleBroadcastSourceInfo)message.obj;
log("Adding Broadcast source" + srcInfo);
byte[] addSourceInfo = convertSourceInfoToAddSourceByteArray(srcInfo);
if (addSourceInfo == null) {
Log.e(TAG, "add source: source Info is NULL");
break;
}
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(addSourceInfo);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
transitionTo(mConnectedProcessing);
sendMessageDelayed(GATT_TXN_TIMEOUT, GATT_TXN_TIMEOUT_MS);
} else {
Log.e(TAG, "ADD_BCAST_SOURCE: no Bluetooth Gatt handle, Fatal");
sendPendingCallbacks(ADD_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_FATAL);
}
break;
case UPDATE_BCAST_SOURCE:
srcInfo = (BleBroadcastSourceInfo)message.obj;
mAutoTriggerred = ((int) message.arg1) == AUTO;
log("Updating Broadcast source" + srcInfo);
byte[] updateSourceInfo = convertSourceInfoToUpdateSourceByteArray(srcInfo);
if (updateSourceInfo == null) {
Log.e(TAG, "update source: source Info is NULL");
break;
}
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(updateSourceInfo);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
mPendingSourceId = srcInfo.getSourceId();
transitionTo(mConnectedProcessing);
sendMessageDelayed(GATT_TXN_TIMEOUT, GATT_TXN_TIMEOUT_MS);
} else {
Log.e(TAG, "UPDATE_BCAST_SOURCE: no Bluetooth Gatt handle, Fatal");
sendPendingCallbacks(UPDATE_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_FATAL);
}
break;
case SET_BCAST_CODE:
srcInfo = (BleBroadcastSourceInfo)message.obj;
int cmdType = message.arg1;
log("SET_BCAST_CODE srcInfo: " + srcInfo);
if (cmdType != QUEUED &&
IsItRightTimeToUpdateBroadcastPIN(srcInfo.getSourceId()) != true) {
mSetBroadcastCodePending = true;
mSetBroadcastPINSrcInfo = srcInfo;
log("Ignore SET_BCAST now, but store it for later");
//notify so that lock release happens as SET_BCAST_CODE
//queued for future
mService.notifyOperationCompletion(mDevice,SET_BCAST_CODE);
} else {
byte[] setBroadcastPINcmd = convertSourceInfoToSetBroadcastCodeByteArray(srcInfo);
if (setBroadcastPINcmd == null) {
Log.e(TAG, "SET_BCAST_CODE: Broadcast code is NULL");
break;
}
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(setBroadcastPINcmd);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
mPendingSourceId = srcInfo.getSourceId();
transitionTo(mConnectedProcessing);
sendMessageDelayed(GATT_TXN_TIMEOUT, GATT_TXN_TIMEOUT_MS);
} else {
Log.e(TAG, "SET_BCAST_CODE: no Bluetooth Gatt handle, Fatal");
sendPendingCallbacks(SET_BCAST_CODE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_FATAL);
}
}
break;
case REMOVE_BCAST_SOURCE:
byte sourceId = (byte)message.arg1;
BluetoothDevice audioSrc = (BluetoothDevice)message.obj;
log("Removing Broadcast source: audioSource:" + audioSrc + "sourceId:" + sourceId);
byte[] removeSourceInfo = new byte [2];
removeSourceInfo[0] = BASS_REMOVE_SOURCE_OPCODE;
removeSourceInfo[1] = sourceId;
if (mBluetoothGatt != null &&
mBroadcastScanControlPoint != null) {
mBroadcastScanControlPoint.setValue(removeSourceInfo);
mBluetoothGatt.writeCharacteristic(mBroadcastScanControlPoint);
mPendingOperation = message.what;
mPendingSourceId = sourceId;
transitionTo(mConnectedProcessing);
sendMessageDelayed(GATT_TXN_TIMEOUT, GATT_TXN_TIMEOUT_MS);
} else {
Log.e(TAG, "REMOVE_BCAST_SOURCE: no Bluetooth Gatt handle, Fatal");
sendPendingCallbacks(REMOVE_BCAST_SOURCE,INVALID_SRC_ID,
BleBroadcastAudioScanAssistCallback.BASS_STATUS_FATAL);
}
break;
case PSYNC_ACTIVE_TIMEOUT:
cancelActiveSync(null);
break;
default:
log("CONNECTED: not handled message:" + message.what);
return NOT_HANDLED;
}
return HANDLED;
}
}
void sendPendingCallbacks(int pendingOp, byte sourceId, int status) {
if (status != 0) {
//Notify service only In case of failure cases
//Success case would have been notified through State machine anyways
mService.notifyOperationCompletion(mDevice, pendingOp);
}
switch (pendingOp) {
case START_SCAN_OFFLOAD:
if (status != 0) {
if (mAutoTriggerred == false) {
log("notify the app only if start Scan offload fails");
//shouldnt happen in general
mService.sendBroadcastSourceSelectedCallback(mDevice, null, status);
cancelActiveSync(null);
} else {
mAutoTriggerred = false;
}
}
break;
case ADD_BCAST_SOURCE:
if (status != 0) {
sourceId = INVALID_SRC_ID;
cancelActiveSync(null);
//stop Scan offload for colocated case
mService.stopScanOffloadInternal(mDevice, false);
}
mService.sendAddBroadcastSourceCallback(mDevice, sourceId, status);
break;
case UPDATE_BCAST_SOURCE:
if (mAutoTriggerred == false) {
mService.sendUpdateBroadcastSourceCallback(mDevice, sourceId, status);
} else {
mAutoTriggerred = false;
}
break;
case REMOVE_BCAST_SOURCE:
mService.sendRemoveBroadcastSourceCallback(mDevice, sourceId, status);
break;
case SET_BCAST_CODE:
mService.sendSetBroadcastPINupdatedCallback(mDevice, sourceId, status);
break;
default:
{
log("sendPendingCallbacks: unhandled case");
}
}
}
@VisibleForTesting
class ConnectedProcessing extends State {
@Override
public void enter() {
log( "Enter ConnectedProcessing(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
}
@Override
public void exit() {
log("Exit ConnectedProcessing(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
}
@Override
public boolean processMessage(Message message) {
log("ConnectedProcessing process message(" + mDevice + "): " + messageWhatToString(
message.what));
switch (message.what) {
case CONNECT:
Log.w(TAG, "CONNECT request is ignored" + mDevice);
break;
case DISCONNECT:
Log.w(TAG, "DISCONNECT requested!: " + mDevice);
if (mBluetoothGatt != null) {
mBluetoothGatt.disconnect();
mBluetoothGatt.close();
mBluetoothGatt = null;
cancelActiveSync(null);
//Trigger the CSIP disconnection, dont worry about pass/failure
if (mCsipConnected && mSetCoordinator != null) {
mSetCoordinator.disconnect(mService.mCsipAppId, mDevice);
mCsipConnected = false;
}
transitionTo(mDisconnected);
} else {
log("mBluetoothGatt is null");
}
break;
case READ_BASS_CHARACTERISTICS:
Log.w(TAG, "defer READ_BASS_CHARACTERISTICS requested!: " + mDevice);
deferMessage(message);
break;
case CONNECTION_STATE_CHANGED:
int state = (int)message.obj;
Log.w(TAG, "ConnectedProcessing: connection state changed:" + state);
if (state == BluetoothProfile.STATE_CONNECTED) {
Log.w(TAG, "should never happen from this state");
} else {
Log.w(TAG, "Unexpected disconnection " + mDevice);
transitionTo(mDisconnected);
}
break;
case GATT_TXN_PROCESSED:
removeMessages(GATT_TXN_TIMEOUT);
int status = (int)message.arg1;
log( "GATT transaction processed for" + mDevice);
mService.notifyOperationCompletion(mDevice, mPendingOperation);
if (status == BluetoothGatt.GATT_SUCCESS) {
if (mPendingOperation == SET_BCAST_CODE) {
//If Pending operation is SET_BCAST_CODE
//send callback to notify BCAST is updated
//This is needed only for SET_BCAST operation
sendPendingCallbacks(mPendingOperation,
mPendingSourceId, BleBroadcastAudioScanAssistCallback.BASS_STATUS_SUCCESS);
}
} else {
//any failure to write operation
//will be converted to corresponding
//callback with failure status
sendPendingCallbacks(mPendingOperation,
mPendingSourceId, BleBroadcastAudioScanAssistCallback.BASS_STATUS_FAILURE);
}
transitionTo(mConnected);
break;
case GATT_TXN_TIMEOUT:
log( "GATT transaction timedout for" + mDevice);
mService.notifyOperationCompletion(mDevice, mPendingOperation);
sendPendingCallbacks(mPendingOperation,
mPendingSourceId, BleBroadcastAudioScanAssistCallback.BASS_STATUS_TXN_TIMEOUT);
mPendingOperation = -1;
transitionTo(mConnected);
mPendingSourceId = -1;
break;
case START_SCAN_OFFLOAD:
case STOP_SCAN_OFFLOAD:
case SELECT_BCAST_SOURCE:
case ADD_BCAST_SOURCE:
case SET_BCAST_CODE:
case REMOVE_BCAST_SOURCE:
case PSYNC_ACTIVE_TIMEOUT:
log("defer the message:" + message.what + "so that it will be processed later");
deferMessage(message);
break;
default:
log("CONNECTEDPROCESSING: not handled message:" + message.what);
return NOT_HANDLED;
}
return HANDLED;
}
}
@VisibleForTesting
class Disconnecting extends State {
@Override
public void enter() {
log( "Enter Disconnecting(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
sendMessageDelayed(CONNECT_TIMEOUT, mDevice, mConnectTimeoutMs);
broadcastConnectionState(mDevice, mLastConnectionState,
BluetoothProfile.STATE_DISCONNECTING);
}
@Override
public void exit() {
log("Exit Disconnecting(" + mDevice + "): " + messageWhatToString(
getCurrentMessage().what));
removeMessages(CONNECT_TIMEOUT);
mLastConnectionState = BluetoothProfile.STATE_DISCONNECTING;
}
@Override
public boolean processMessage(Message message) {
log("Disconnecting process message(" + mDevice + "): " + messageWhatToString(
message.what));
switch (message.what) {
case CONNECT:
log("Disconnecting to " + mDevice);
log("deferring this connection request " + mDevice);
deferMessage(message);
break;
case DISCONNECT:
Log.w(TAG, "Already disconnecting: DISCONNECT ignored: " + mDevice);
break;
case CONNECTION_STATE_CHANGED:
int state = (int)message.obj;
Log.w(TAG, "Disconnecting: connection state changed:" + state);
if (state == BluetoothProfile.STATE_CONNECTED) {
Log.e(TAG, "should never happen from this state");
transitionTo(mConnected);
} else {
Log.w(TAG, "disconnection successfull to " + mDevice);
cancelActiveSync(null);
transitionTo(mDisconnected);
///*_CSIP
//Trigger the CSip disconnection, dont worry about pass/failure
if (mCsipConnected) {
mSetCoordinator.disconnect(mService.mCsipAppId, mDevice);
mCsipConnected = false;
}
//_CSIP*/
}
break;
case CONNECT_TIMEOUT:
Log.w(TAG, "CONNECT_TIMEOUT");
BluetoothDevice device = (BluetoothDevice) message.obj;
if (!mDevice.equals(device)) {
Log.e(TAG, "Unknown device timeout " + device);
break;
}
transitionTo(mDisconnected);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
void broadcastConnectionState(BluetoothDevice device, int fromState, int toState) {
log( "broadcastConnectionState " + device + ": " + fromState + "->" + toState);
if (fromState == BluetoothProfile.STATE_CONNECTED &&
toState == BluetoothProfile.STATE_CONNECTED) {
log("CONNECTED->CONNTECTED: Ignore");
return;
}
Intent intent = new Intent(BluetoothSyncHelper.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);
mService.sendBroadcastAsUser(intent, UserHandle.ALL,
BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions());
}
int getConnectionState() {
String currentState = "Unknown";
if (getCurrentState() != null) {
currentState = getCurrentState().getName();
}
switch (currentState) {
case "Disconnected":
log("Disconnected");
return BluetoothProfile.STATE_DISCONNECTED;
case "Disconnecting":
log("Disconnecting");
return BluetoothProfile.STATE_DISCONNECTING;
case "Connecting":
log("Connecting");
return BluetoothProfile.STATE_CONNECTING;
case "Connected":
case "ConnectedProcessing":
log("connected");
return BluetoothProfile.STATE_CONNECTED;
default:
Log.e(TAG, "Bad currentState: " + currentState);
return BluetoothProfile.STATE_DISCONNECTED;
}
}
BluetoothDevice getDevice() {
return mDevice;
}
synchronized boolean isConnected() {
return getCurrentState() == mConnected;
}
public static String messageWhatToString(int what) {
switch (what) {
case CONNECT:
return "CONNECT";
case DISCONNECT:
return "DISCONNECT";
case CONNECTION_STATE_CHANGED:
return "CONNECTION_STATE_CHANGED";
case GATT_TXN_PROCESSED:
return "GATT_TXN_PROCESSED";
case READ_BASS_CHARACTERISTICS:
return "READ_BASS_CHARACTERISTICS";
case START_SCAN_OFFLOAD:
return "START_SCAN_OFFLOAD";
case STOP_SCAN_OFFLOAD:
return "STOP_SCAN_OFFLOAD";
case ADD_BCAST_SOURCE:
return "ADD_BCAST_SOURCE";
case SELECT_BCAST_SOURCE:
return "SELECT_BCAST_SOURCE";
case UPDATE_BCAST_SOURCE:
return "UPDATE_BCAST_SOURCE";
case SET_BCAST_CODE:
return "SET_BCAST_CODE";
case REMOVE_BCAST_SOURCE:
return "REMOVE_BCAST_SOURCE";
case PSYNC_ACTIVE_TIMEOUT:
return "PSYNC_ACTIVE_TIMEOUT";
case CSIP_CONNECTION_STATE_CHANGED:
return "CSIP_CONNECTION_STATE_CHANGED";
case CONNECT_TIMEOUT:
return "CONNECT_TIMEOUT";
default:
break;
}
return Integer.toString(what);
}
private static String profileStateToString(int state) {
switch (state) {
case BluetoothProfile.STATE_DISCONNECTED:
return "DISCONNECTED";
case BluetoothProfile.STATE_CONNECTING:
return "CONNECTING";
case BluetoothProfile.STATE_CONNECTED:
return "CONNECTED";
case BluetoothProfile.STATE_DISCONNECTING:
return "DISCONNECTING";
default:
break;
}
return Integer.toString(state);
}
public void dump(StringBuilder sb) {
ProfileService.println(sb, "mDevice: " + mDevice);
ProfileService.println(sb, " StateMachine: " + this);
// Dump the state machine logs
StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
super.dump(new FileDescriptor(), printWriter, new String[]{});
printWriter.flush();
stringWriter.flush();
ProfileService.println(sb, " StateMachineLog:");
Scanner scanner = new Scanner(stringWriter.toString());
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
ProfileService.println(sb, " " + line);
}
scanner.close();
}
@Override
protected void log( String msg) {
if (BASS_DBG) {
super.log(msg);
}
}
private static void logByteArray(String prefix, byte[] value, int offset, int count) {
StringBuilder builder = new StringBuilder(prefix);
for (int i = offset; i < count; i++) {
builder.append(String.format("0x%02X", value[i]));
if (i != value.length - 1) {
builder.append(", ");
}
}
Log.d(TAG, builder.toString());
}
}