/*
 * Copyright (c) 2020 The Linux Foundation. All rights reserved.
 *
 * Copyright (C) 2016 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 static android.Manifest.permission.BLUETOOTH_CONNECT;


import android.app.ActivityManager;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.IBluetoothSyncHelper;
import android.bluetooth.IBluetoothManager;
import android.bluetooth.IBleBroadcastAudioScanAssistCallback;
import android.bluetooth.BluetoothSyncHelper;
import android.bluetooth.BleBroadcastSourceInfo;
import android.bluetooth.BleBroadcastSourceChannel;
import android.bluetooth.BleBroadcastAudioScanAssistManager;
import android.bluetooth.BleBroadcastAudioScanAssistCallback;

import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Process;
import android.os.RemoteException;
import android.os.HandlerThread;
import android.util.Log;
import android.os.ParcelUuid;
import android.bluetooth.BluetoothUuid;
import java.util.ArrayList;
import android.os.ServiceManager;

import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanRecord;
import android.bluetooth.le.PeriodicAdvertisingCallback;
import android.bluetooth.le.PeriodicAdvertisingManager;
import android.bluetooth.le.PeriodicAdvertisingReport;

import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;

import com.android.bluetooth.BluetoothMetricsProto;
import com.android.bluetooth.Utils;
import com.android.bluetooth.btservice.MetricsLogger;
import com.android.bluetooth.btservice.ProfileService;
import com.android.internal.annotations.VisibleForTesting;
import com.android.bluetooth.btservice.AdapterService;
//*_CSIP
//CSIP related imports
import com.android.bluetooth.groupclient.GroupService;
import android.bluetooth.BluetoothGroupCallback;
import android.bluetooth.DeviceGroup;
//_CSIP*/

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.UUID;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Objects;
import java.util.NoSuchElementException;
import android.os.SystemProperties;


import com.android.internal.util.ArrayUtils;
/** @hide */
public class BCService extends ProfileService {
    private static final boolean DBG = true;
    private static final String TAG = BCService.class.getSimpleName();

    private static final ParcelUuid CAS_UUID = null;//ParcelUuid.fromString("000089FF-0000-1000-8000-00805F9B34FB");

    public static final String BC_ID = "0000184F-0000-1000-8000-00805F9B34FB";
    public static final String BS_ID = "00001852-0000-1000-8000-00805F9B34FB";
    private static BCService sBCService;
    private static final int MAX_BASS_CLIENT_STATE_MACHINES = 10;
    private static final int MAX_BASS_CLIENT_CSET_MEMBERS = 10;
    private final Map<BluetoothDevice, BassClientStateMachine> mStateMachines =
             new HashMap<>();
    private HandlerThread mStateMachinesThread;
    private final Map<Integer, BassCsetManager> mSetManagers =
             new HashMap<>();
    private HandlerThread mSetManagerThread;

    private AdapterService mAdapterService;

    private Map<BluetoothDevice, ArrayList<IBleBroadcastAudioScanAssistCallback>> mAppCallbackMap =
             new HashMap<BluetoothDevice, ArrayList<IBleBroadcastAudioScanAssistCallback>>();

    private BassUtils bassUtils = null;
    public static final int INVALID_SYNC_HANDLE = -1;
    public static final int INVALID_ADV_SID = -1;
    public static final int INVALID_ADV_ADDRESS_TYPE = -1;
    public static final int INVALID_ADV_INTERVAL = -1;
    public static final int INVALID_BROADCAST_ID = -1;
    private Map<BluetoothDevice, BluetoothDevice> mActiveSourceMap;

    //*_CSIP
    //CSET interfaces
    private GroupService mSetCoordinator = GroupService.getGroupService();
    public int mCsipAppId = -1;
    private int mQueuedOps = 0;
    //_CSIP*/

    /*Caching the PAresults from Broadcast source*/
    /*This is stored at service so that each device state machine can access
    and use it as needed. Once the periodic sync in cancelled, this data will bre
    removed to ensure stable data won't used*/
    /*broadcastSrcDevice, syncHandle*/
    private Map<BluetoothDevice, Integer> mSyncHandleMap;
    /*syncHandle, parsed BaseData data*/
    private Map<Integer, BaseData> mSyncHandleVsBaseInfo;
    /*bcastSrcDevice, corresponding PAResultsMap*/
    private Map<BluetoothDevice, PAResults> mPAResultsMap;
    public class PAResults {
        public BluetoothDevice mDevice;
        public int mAddressType;
        public int mAdvSid;
        public int mSyncHandle;
        public byte metaDataLength;
        public byte[] metaData;
        public int mPAInterval;
        public int mBroadcastId;

        PAResults(BluetoothDevice device, int addressType,
                         int syncHandle, int advSid, int paInterval, int broadcastId) {
            mDevice = device;
            mAddressType = addressType;
            mAdvSid = advSid;
            mSyncHandle = syncHandle;
            mPAInterval = paInterval;
            mBroadcastId = broadcastId;
        }

        public void updateSyncHandle(int syncHandle) {
            mSyncHandle = syncHandle;
        }

        public void updateAdvSid(int advSid) {
            mAdvSid = advSid;
        }

        public void updateAddressType(int addressType) {
            mAddressType = addressType;
        }

        public void updateAdvInterval(int advInterval) {
            mPAInterval = advInterval;
        }

        public void updateBroadcastId(int broadcastId) {
            mBroadcastId = broadcastId;
        }

        public void print() {
            log("-- PAResults --");
            log("mDevice:" + mDevice);
            log("mAddressType:" + mAddressType);
            log("mAdvSid:" + mAdvSid);
            log("mSyncHandle:" + mSyncHandle);
            log("mPAInterval:" + mPAInterval);
            log("mBroadcastId:" + mBroadcastId);
            log("-- END: PAResults --");
        }
    };

    public void updatePAResultsMap(BluetoothDevice device, int addressType, int syncHandle, int advSid, int advInterval, int bId) {
          log("updatePAResultsMap: device: " + device);
          log("updatePAResultsMap: syncHandle: " + syncHandle);
          log("updatePAResultsMap: advSid: " + advSid);
          log("updatePAResultsMap: addressType: " + addressType);
          log("updatePAResultsMap: advInterval: " + advInterval);
          log("updatePAResultsMap: broadcastId: " + bId);
          log("mSyncHandleMap" + mSyncHandleMap);
          log("mPAResultsMap" + mPAResultsMap);
          //Cache the SyncHandle
          if (mSyncHandleMap != null) {
              Integer i = new Integer(syncHandle);
              mSyncHandleMap.put(device, i);
          }
          if (mPAResultsMap != null) {
              PAResults paRes = mPAResultsMap.get(device);
              if (paRes == null) {
                  log("PAResmap: add >>>");
                  paRes = new PAResults (device, addressType,
                              syncHandle, advSid, advInterval, bId);
                  if (paRes != null) {
                      paRes.print();
                      mPAResultsMap.put(device, paRes);
                  }
              } else {
                  if (advSid != INVALID_ADV_SID) {
                      paRes.updateAdvSid(advSid);
                  }
                  if (syncHandle != INVALID_SYNC_HANDLE) {
                      paRes.updateSyncHandle(syncHandle);
                  }
                  if (addressType != INVALID_ADV_ADDRESS_TYPE) {
                      paRes.updateAddressType(addressType);
                  }
                  if (advInterval != INVALID_ADV_INTERVAL) {
                      paRes.updateAdvInterval(advInterval);
                  }
                  if (bId != INVALID_BROADCAST_ID) {
                      paRes.updateBroadcastId(bId);
                  }
                  log("PAResmap: update >>>");
                  paRes.print();
                  mPAResultsMap.replace(device, paRes);
              }
          }
          log(">>mPAResultsMap" + mPAResultsMap);
      }

      public PAResults getPAResults(BluetoothDevice device) {
          PAResults res = null;
          if (mPAResultsMap != null) {
            res = mPAResultsMap.get(device);
          } else {
            Log.e(TAG, "getPAResults: mPAResultsMap is null");
        }
        return res;
      }
      public PAResults clearPAResults(BluetoothDevice device) {
          PAResults res = null;
          if (mPAResultsMap != null) {
            res = mPAResultsMap.remove(device);
          } else {
            Log.e(TAG, "getPAResults: mPAResultsMap is null");
        }
        return res;
      }

      public void updateBASE(int syncHandlemap, BaseData base) {
         if (mSyncHandleVsBaseInfo != null) {
             log("updateBASE : mSyncHandleVsBaseInfo>>");
             mSyncHandleVsBaseInfo.put(syncHandlemap, base);
         } else {
             Log.e(TAG, "updateBASE: mSyncHandleVsBaseInfo is null");
         }
      }

    public BaseData getBASE(int syncHandlemap) {
        BaseData base = null;
        if (mSyncHandleVsBaseInfo != null) {
            log("getBASE : syncHandlemap::" + syncHandlemap);
            base = mSyncHandleVsBaseInfo.get(syncHandlemap);
        } else {
            Log.e(TAG, "getBASE: mSyncHandleVsBaseInfo is null");
        }
        log("getBASE returns" + base);
        return base;
    }

    public void clearBASE(int syncHandlemap) {
        if (mSyncHandleVsBaseInfo != null) {
            log("clearBASE : mSyncHandleVsBaseInfo>>");
            mSyncHandleVsBaseInfo.remove(syncHandlemap);
        } else {
            Log.e(TAG, "updateBASE: mSyncHandleVsBaseInfo is null");
        }
    }

    public void setActiveSyncedSource(BluetoothDevice scanDelegator, BluetoothDevice sourceDevice) {
        log("setActiveSyncedSource: scanDelegator" + scanDelegator + ":: sourceDevice:" + sourceDevice);
        if (sourceDevice == null) {
            mActiveSourceMap.remove(scanDelegator);
        } else {
            mActiveSourceMap.put(scanDelegator, sourceDevice);
        }
    }

    public BluetoothDevice getActiveSyncedSource(BluetoothDevice scanDelegator) {
        BluetoothDevice currentSource =  mActiveSourceMap.get(scanDelegator);
        log("getActiveSyncedSource: scanDelegator" + scanDelegator + "returning " + currentSource);
        return currentSource;
    }

     @Override
     protected IProfileServiceBinder initBinder() {
         return new BluetoothSyncHelperBinder(this);
     }

     //*_CSIP
     private BluetoothGroupCallback mBluetoothGroupCallback = new BluetoothGroupCallback() {
          public void onGroupClientAppRegistered(int status, int appId) {
              log("onCsipAppRegistered:" + status + "appId: " + appId);
              if (status == 0) {
                  mCsipAppId = appId;
              } else {
                  Log.e(TAG, "Csip registeration failed, status:" + status);
              }
          }

          public void onConnectionStateChanged (int state, BluetoothDevice device) {
              log("onConnectionStateChanged: Device: " + device + "state: " + state);
                  //notify the statemachine about CSIP connection
                  synchronized (mStateMachines) {
                      BassClientStateMachine stateMachine = getOrCreateStateMachine(device);
                      Message m = stateMachine.obtainMessage(BassClientStateMachine.CSIP_CONNECTION_STATE_CHANGED);
                      m.obj = state;
                      stateMachine.sendMessage(m);
                  }
          }

          public void onNewGroupFound (int setId,  BluetoothDevice device, UUID uuid) {     }
          public void onGroupDiscoveryStatusChanged (int setId, int status, int reason) {    }
          public void onGroupDeviceFound (int setId, BluetoothDevice device) {    }
          public void onExclusiveAccessChanged (int setId, int value, int status, List<BluetoothDevice> devices) {
              log("onLockStatusChanged: setId" + setId + devices + "status:" + status);
              BassCsetManager setMgr = null;
              setMgr = getOrCreateCSetManager(setId, null);
              if (setMgr == null) {
                      return;
              }
              log ("sending Lock status to setId:" + setId);
              Message m = setMgr.obtainMessage(BassCsetManager.LOCK_STATE_CHANGED);
              m.obj = devices;
              m.arg1 = value;
              setMgr.sendMessage(m);
          }
          public void onExclusiveAccessStatusFetched (int setId, int lockStatus) {    }
          public void onExclusiveAccessAvailable (int setId, BluetoothDevice device) {    }
     };
     //_CSIP*/

     @Override
     protected boolean start() {
        if (DBG) {
            Log.d(TAG, "start()");
        }
        mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
                 "AdapterService cannot be null when BCService starts");
         mStateMachines.clear();
         mStateMachinesThread = new HandlerThread("BCService.StateMachines");
         mStateMachinesThread.start();

         mSetManagers.clear();
         mSetManagerThread = new HandlerThread("BCService.SetManagers");
         mSetManagerThread.start();

         setBCService(this);
         bassUtils = new BassUtils(this);
         //Saving PSync stuff for future addition
         mSyncHandleMap = new HashMap<BluetoothDevice, Integer>();
         mPAResultsMap = new HashMap<BluetoothDevice, PAResults>();
         mSyncHandleVsBaseInfo = new HashMap<Integer, BaseData>();
         mActiveSourceMap = new HashMap<BluetoothDevice, BluetoothDevice>();

         //*_CSIP
         //CSET initialization
         mSetCoordinator = GroupService.getGroupService();
         if (mSetCoordinator != null) {
             mSetCoordinator.registerGroupClientModule(mBluetoothGroupCallback);
         }
         //_CSIP*/
         /*_PACS
         mPacsClientService = PacsClientService.getPacsClientService();
         _PACS*/

         ///*_GAP
         //GAP registeration for Bass UUID notification
         if (mAdapterService != null) {
             log("register for BASS UUID notif");
            ParcelUuid bassUuid = new ParcelUuid(BassClientStateMachine.BASS_UUID);
            mAdapterService.registerUuidSrvcDisc(bassUuid);
         }
         //_GAP*/
         return true;
     }

    @Override
    protected boolean stop() {
        if (DBG) {
            Log.d(TAG, "stop()");
        }

        synchronized (mStateMachines) {
             for (BassClientStateMachine sm : mStateMachines.values()) {
                 sm.doQuit();
                 sm.cleanup();
             }
             mStateMachines.clear();
        }

        if (mStateMachinesThread != null) {
             mStateMachinesThread.quitSafely();
             mStateMachinesThread = null;
        }

        if (mSetManagerThread != null) {
             mSetManagerThread.quitSafely();
             mSetManagerThread = null;
        }

        setBCService(null);

        if (mAppCallbackMap != null) {
            mAppCallbackMap.clear();
            mAppCallbackMap = null;
        }

        if (mSyncHandleMap != null) {
            mSyncHandleMap.clear();
            mSyncHandleMap = null;
        }

        if (mActiveSourceMap != null) {
            mActiveSourceMap.clear();
            mActiveSourceMap = null;
        }
        //*_CSIP
        if (mSetCoordinator != null && mCsipAppId != -1) {
           //mSetCoordinator.unregisterGroupClientModule(mCsipAppId);
        }
        //_CSIP*/
        return true;
     }

     @Override
     public boolean onUnbind(Intent intent) {
        Log.d(TAG, "Need to unregister app");
        //unregisterApp();
        return super.onUnbind(intent);
    }

    /**
     * Get the BCService instance
     * @return BCService instance
     */
    public static synchronized BCService getBCService() {
        if (sBCService == null) {
            Log.w(TAG, "getBCService(): service is NULL");
            return null;
        }

        if (!sBCService.isAvailable()) {
            Log.w(TAG, "getBCService(): service is not available");
            return null;
        }
        return sBCService;
    }

    public BassUtils getBassUtils() {
        return bassUtils;
    }

    public BluetoothDevice getDeviceForSyncHandle(int syncHandle) {
        BluetoothDevice dev = null;
        if (mSyncHandleMap != null) {
            for (Map.Entry<BluetoothDevice, Integer> entry : mSyncHandleMap.entrySet()) {
                Integer value = entry.getValue();
                if (value == syncHandle) {
                    dev = entry.getKey();
                }
            }
        }
        return dev;
    }

    private static synchronized void setBCService(BCService instance) {
        if (DBG) {
            Log.d(TAG, "setBCService(): set to: " + instance);
        }
        sBCService = instance;
    }

    /**
     * Connects the bass profile to the passed in device
     *
     * @param device is the device with which we will connect the Bass profile
     * @return true if BAss profile successfully connected, false otherwise
     */
    public boolean connect(BluetoothDevice device) {
        if (DBG) {
            Log.d(TAG, "connect(): " + device);
        }
        if (device == null) {
            return false;
        }

        if (getConnectionPolicy(device) == BluetoothProfile.CONNECTION_POLICY_UNKNOWN) {
            return false;
        }
        synchronized (mStateMachines) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(device);

            stateMachine.sendMessage(BassClientStateMachine.CONNECT);
        }
        return true;
    }

  /**
     * Disconnects Bassclient profile for the passed in device
     *
     * @param device is the device with which we want to disconnected the BAss client profile
     * @return true if Bass client profile successfully disconnected, false otherwise
     */
    public boolean disconnect(BluetoothDevice device) {

        if (DBG) {
            Log.d(TAG, "disconnect(): " + device);
        }
        if (device == null) {
            return false;
        }

      synchronized (mStateMachines) {
          BassClientStateMachine stateMachine = getOrCreateStateMachine(device);

          stateMachine.sendMessage(BassClientStateMachine.DISCONNECT);
        }
        return true;
    }

    List<BluetoothDevice> getConnectedDevices() {

        synchronized (mStateMachines) {
            List<BluetoothDevice> devices = new ArrayList<>();
            for (BassClientStateMachine sm : mStateMachines.values()) {
                if (sm.isConnected()) {
                    devices.add(sm.getDevice());
                }
            }
            log("getConnectedDevices: " + devices);
            return devices;
        }
    }

    /**
     * Check whether can connect to a peer device.
     * The check considers a number of factors during the evaluation.
     *
     * @param device the peer device to connect to
     * @return true if connection is allowed, otherwise false
     */
    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
    public boolean okToConnect(BluetoothDevice device) {
        // Check if this is an incoming connection in Quiet mode.
        if (mAdapterService.isQuietModeEnabled()) {
            Log.e(TAG, "okToConnect: cannot connect to " + device + " : quiet mode enabled");
            return false;
        }
        // Check connection policy and accept or reject the connection.
        int connectionPolicy = getConnectionPolicy(device);
        int bondState = mAdapterService.getBondState(device);
        // Allow this connection only if the device is bonded. Any attempt to connect while
        // bonding would potentially lead to an unauthorized connection.
        if (bondState != BluetoothDevice.BOND_BONDED) {
            Log.w(TAG, "okToConnect: return false, bondState=" + bondState);
            return false;
        } else if (connectionPolicy != BluetoothProfile.CONNECTION_POLICY_UNKNOWN
                && connectionPolicy != BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
            // Otherwise, reject the connection if connectionPolicy is not valid.
            Log.w(TAG, "okToConnect: return false, connectionPolicy=" + connectionPolicy);
            return false;
        }
        return true;
    }

    List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {

        ArrayList<BluetoothDevice> devices = new ArrayList<>();
        if (states == null) {
            return devices;
        }
        final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices();
        if (bondedDevices == null) {
            return devices;
        }
        synchronized (mStateMachines) {
            for (BluetoothDevice device : bondedDevices) {
                final ParcelUuid[] featureUuids = device.getUuids();
                if (!ArrayUtils.contains(featureUuids, new ParcelUuid(BassClientStateMachine.BASS_UUID))) {
                    continue;
                }
                int connectionState = BluetoothProfile.STATE_DISCONNECTED;
                BassClientStateMachine sm = getOrCreateStateMachine(device);
                if (sm != null) {
                    connectionState = sm.getConnectionState();
                }
                for (int state : states) {
                    if (connectionState == state) {
                        devices.add(device);
                        break;
                    }
                }
            }
            return devices;
        }
    }

    public int getConnectionState(BluetoothDevice device) {
        synchronized (mStateMachines) {
            BassClientStateMachine sm = getOrCreateStateMachine(device);
            if (sm == null) {
                log("getConnectionState returns STATE_DISC");
                return BluetoothProfile.STATE_DISCONNECTED;
            }
            return sm.getConnectionState();
        }
    }

    /**
     * Set the connectionPolicy of the Hearing Aid profile.
     *
     * @param device the remote device
     * @param connectionPolicy the connection policy of the profile
     * @return true on success, otherwise false
     */
    public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {

        if (DBG) {
            Log.d(TAG, "Saved connectionPolicy " + device + " = " + connectionPolicy);
        }
        boolean setSuccessfully;
        setSuccessfully = mAdapterService.getDatabase()
                .setProfileConnectionPolicy(device, BluetoothProfile.BC_PROFILE, connectionPolicy);
        if (setSuccessfully && connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
            connect(device);
        } else if (setSuccessfully
                && connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {
            disconnect(device);
        }
        return setSuccessfully;
    }

    /**
     * Get the connection policy of the profile.
     *
     * <p> The connection policy can be any of:
     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED},
     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN},
     * {@link BluetoothProfile#CONNECTION_POLICY_UNKNOWN}
     *
     * @param device Bluetooth device
     * @return connection policy of the device
     * @hide
     */
    public int getConnectionPolicy(BluetoothDevice device) {

        return mAdapterService.getDatabase()
                .getProfileConnectionPolicy(device, BluetoothProfile.BC_PROFILE);
    }

    public void sendBroadcastSourceSelectedCallback(BluetoothDevice device, List<BleBroadcastSourceChannel> bChannels, int status){
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return;
        }
        for (IBleBroadcastAudioScanAssistCallback cb : cbs) {
            try {
               cb.onBleBroadcastAudioSourceSelected(device, status, bChannels);
            } catch (RemoteException e)  {
               Log.e(TAG, "Exception while calling sendBroadcastSourceSelectedCallback");
            }
        }
    }

    public void sendAddBroadcastSourceCallback(BluetoothDevice device, byte srcId, int status){
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return;
        }
        for (IBleBroadcastAudioScanAssistCallback cb : cbs) {
            try {
               cb.onBleBroadcastAudioSourceAdded(device, srcId, status);
            } catch (RemoteException e)  {
               Log.e(TAG, "Exception while calling onBleBroadcastAudioSourceAdded");
            }
        }
    }

    public void sendUpdateBroadcastSourceCallback(BluetoothDevice device, byte sourceId, int status){
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return;
        }

        for (IBleBroadcastAudioScanAssistCallback cb : cbs) {
            try {
                cb.onBleBroadcastAudioSourceUpdated(device, sourceId, status);
            } catch (RemoteException e)  {
                Log.e(TAG, "Exception while calling onBleBroadcastAudioSourceUpdated");
            }
        }
    }
    public void sendRemoveBroadcastSourceCallback(BluetoothDevice device, byte sourceId, int status){
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return;
        }

        for (IBleBroadcastAudioScanAssistCallback cb : cbs) {
            try {
                cb.onBleBroadcastAudioSourceRemoved(device, sourceId, status);
            } catch (RemoteException e)  {
                Log.e(TAG, "Exception while calling onBleBroadcastAudioSourceRemoved");
            }
        }
    }
    public void sendSetBroadcastPINupdatedCallback(BluetoothDevice device, byte sourceId, int status){
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return;
        }

        for (IBleBroadcastAudioScanAssistCallback cb : cbs) {
            try {
                cb.onBleBroadcastPinUpdated(device, sourceId, status);
            } catch (RemoteException e)  {
                Log.e(TAG, "Exception while calling onBleBroadcastPinUpdated");
            }
        }
    }

    public void registerAppCallback (BluetoothDevice device, IBleBroadcastAudioScanAssistCallback cb) {

        Log.i(TAG, "registerAppCallback" + device);

        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.i(TAG, "registerAppCallback: entry exists");
            cbs = new ArrayList<IBleBroadcastAudioScanAssistCallback>();
        }
        cbs.add(cb);
        mAppCallbackMap.put(device, cbs);
        return;
    }

    public void unregisterAppCallback (BluetoothDevice device, IBleBroadcastAudioScanAssistCallback cb) {

        Log.i(TAG, "unregisterAppCallback" + device);

        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.i(TAG, "unregisterAppCallback: cb list is null");
            return;
        } else {
           boolean ret = cbs.remove(cb);
           Log.i(TAG, "unregisterAppCallback: ret value of removal from list:" + ret);
        }
        if (cbs.size() != 0) {
            mAppCallbackMap.replace(device, cbs);
        } else {
            Log.i(TAG, "unregisterAppCallback: Remove the cmplete entry");
            mAppCallbackMap.remove(device);
        }
        return;
    }

    public boolean searchforLeAudioBroadcasters (BluetoothDevice device) {

        Log.i(TAG, "searchforLeAudioBroadcasters on behalf of" + device);
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
            return false;
        }
        boolean ret = false;
        if (bassUtils != null) {
            ret = bassUtils.searchforLeAudioBroadcasters(device, cbs);
        } else {
            Log.e(TAG, "searchforLeAudioBroadcasters :Null Bass Util Handle" + device);
            ret = false;
        }
        return ret;
    }

    public boolean stopSearchforLeAudioBroadcasters (BluetoothDevice device) {

        Log.i(TAG, "stopsearchforLeAudioBroadcasters on behalf of" + device);
        ArrayList<IBleBroadcastAudioScanAssistCallback> cbs = mAppCallbackMap.get(device);
        if (cbs == null) {
            Log.e(TAG, "no App callback for this device" + device);
        }
        boolean ret = false;
        if (bassUtils != null) {
            ret = bassUtils.stopSearchforLeAudioBroadcasters(device, cbs);
        } else {
            Log.e(TAG, "stopsearchforLeAudioBroadcasters :Null Bass Util Handle" + device);
            ret = false;
        }
        return ret;
    }

    public boolean selectBroadcastSource (BluetoothDevice device, ScanResult scanRes, boolean isGroupOp, boolean auto) {

        Log.i(TAG, "selectBroadcastSource for " + device + "isGroupOp:" + isGroupOp);
        Log.i(TAG, "ScanResult " + scanRes);

        if (scanRes == null) {
            Log.e(TAG, "selectBroadcastSource: null Scan results");
            return false;
        }
        List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
        listOfDevices.add(device);
        if (isRoomForBroadcastSourceAddition(listOfDevices) == false) {
            sendBroadcastSourceSelectedCallback(device, null,
                BleBroadcastAudioScanAssistCallback.BASS_STATUS_NO_EMPTY_SLOT);
            return false;
        }
        //dummy BleSourceInfo from scanRes
        BleBroadcastSourceInfo scanResSI = new BleBroadcastSourceInfo (scanRes.getDevice(),
                                                            BassClientStateMachine.INVALID_SRC_ID,
                                                            (byte)scanRes.getAdvertisingSid(),
                                                            BleBroadcastSourceInfo.BROADCASTER_ID_INVALID,
                                                            scanRes.getAddressType(),
                                                            BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_INVALID,
                                                            BleBroadcastSourceInfo.BROADCAST_ASSIST_ENC_STATE_INVALID,
                                                            null,
                                                            (byte)0,
                                                            BleBroadcastSourceInfo.BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED,
                                                            null,
                                                            null);
        if (isValidBroadcastSourceAddition(listOfDevices, scanResSI) == false) {
            sendBroadcastSourceSelectedCallback(device,
                null, BleBroadcastAudioScanAssistCallback.BASS_STATUS_DUPLICATE_ADDITION);
            return false;
        }
        startScanOffloadInternal(device, isGroupOp);
        synchronized (mStateMachines) {
            BassClientStateMachine sm = getOrCreateStateMachine(device);
            if (sm == null) {
                return false;
            }
            Message m = sm.obtainMessage(BassClientStateMachine.SELECT_BCAST_SOURCE);
            m.obj = scanRes;
            if (auto) {
                m.arg1 = sm.AUTO;
            } else {
                m.arg1 = sm.USER;
            }
            if (isGroupOp) {
                m.arg2 = sm.GROUP_OP;
            } else {
                m.arg2 = sm.NON_GROUP_OP;
            }
            sm.sendMessage(m);
        }
        return true;
    }

    public synchronized void notifyOperationCompletion(BluetoothDevice device, int pendingOperation) {
        log("notifyOperationCompletion: " + device + "pendingOperation: " +
            BassClientStateMachine.messageWhatToString(pendingOperation));
        //synchronized (mStateMachines) {
            switch (pendingOperation) {
                case BassClientStateMachine.START_SCAN_OFFLOAD:
                case BassClientStateMachine.STOP_SCAN_OFFLOAD:
                case BassClientStateMachine.ADD_BCAST_SOURCE:
                case BassClientStateMachine.UPDATE_BCAST_SOURCE:
                case BassClientStateMachine.REMOVE_BCAST_SOURCE:
                case BassClientStateMachine.SET_BCAST_CODE:
                    if (mQueuedOps > 0) {
                        mQueuedOps = mQueuedOps - 1;
                    } else {
                        log("not a queued op, Internal op");
                        return;
                    }
                break;
                default:
                     {
                         log("notifyOperationCompletion: unhandled case");
                         return;
                     }
              }
        //}
          if (mQueuedOps == 0) {
              log("notifyOperationCompletion: all ops are done!");
              //trigger unlock with last device
              triggerUnlockforCSet(device);
          }

    }

    public synchronized boolean startScanOffload (BluetoothDevice masterDevice, List<BluetoothDevice> devices) {

        Log.i(TAG, "startScanOffload for " + devices);
        for (BluetoothDevice dev : devices) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
            if (stateMachine == null) {
                continue;
            }
            stateMachine.sendMessage(BassClientStateMachine.START_SCAN_OFFLOAD);
            mQueuedOps = mQueuedOps + 1;
        }
        return true;
    }

    public synchronized boolean stopScanOffload (BluetoothDevice masterDevice, List<BluetoothDevice> devices) {

        Log.i(TAG, "stopScanOffload for " + devices);
        for (BluetoothDevice dev : devices) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
            if (stateMachine == null) {
                continue;
            }
            stateMachine.sendMessage(BassClientStateMachine.STOP_SCAN_OFFLOAD);
            mQueuedOps = mQueuedOps + 1;
        }

        return true;
    }

    public boolean isLocalBroadcasting() {
        return bassUtils.isLocalLEAudioBroadcasting();
    }

    private boolean isValidBroadcastSourceAddition(List<BluetoothDevice> devices,
                                                BleBroadcastSourceInfo srcInfo) {
        boolean ret = true;

        //run through all the device, if it is not valid
        //to even one device to add this source, return failure
        for (BluetoothDevice dev : devices) {
            List<BleBroadcastSourceInfo> currentSourceInfos =
                getAllBroadcastSourceInformation(dev);
            if (currentSourceInfos == null) {
                log("currentSourceInfos is null for " + dev);
                continue;
            }
            for (int i=0; i<currentSourceInfos.size(); i++) {
                if (srcInfo.matches(currentSourceInfos.get(i))) {
                   ret = false;
                   Log.e(TAG, "isValidBroadcastSourceAddition: fails for: " + dev + "&srcInfo" + srcInfo);
                   break;
                }
            }
        }

        log("isValidBroadcastSourceInfo returns: " + ret);
        return ret;
    }

    private boolean isRoomForBroadcastSourceAddition(List<BluetoothDevice> devices) {
        boolean isRoomAvail = false;

        //run through all the device, if it is not valid
        //to even one device to add this source, return failure
        for (BluetoothDevice dev : devices) {
            isRoomAvail = false;
            List<BleBroadcastSourceInfo> currentSourceInfos =
                getAllBroadcastSourceInformation(dev);
            for (int i=0; i<currentSourceInfos.size(); i++) {
                BleBroadcastSourceInfo srcInfo = currentSourceInfos.get(i);
                if (srcInfo.isEmptyEntry()) {
                   isRoomAvail = true;
                   continue;
                }
            }
            if (isRoomAvail == false) {
                Log.e(TAG, "isRoomForBroadcastSourceAddition: fails for: " + dev);
                break;
            }
        }

        log("isRoomForBroadcastSourceAddition returns: " + isRoomAvail);
        return isRoomAvail;
    }

    public synchronized boolean addBroadcastSource (BluetoothDevice masterDevice, List<BluetoothDevice> devices, BleBroadcastSourceInfo srcInfo
                                      ) {

        Log.i(TAG, "addBroadcastSource for " + devices +
                   "SourceInfo " + srcInfo);
        if (srcInfo == null) {
            Log.e(TAG, "addBroadcastSource: null SrcInfo");
            return false;
        }
        if (isRoomForBroadcastSourceAddition(devices) == false) {
            sendAddBroadcastSourceCallback(masterDevice,
                BassClientStateMachine.INVALID_SRC_ID, BleBroadcastAudioScanAssistCallback.BASS_STATUS_NO_EMPTY_SLOT);
            triggerUnlockforCSet(masterDevice);
            return false;
        }

        if (isValidBroadcastSourceAddition(devices, srcInfo) == false) {
            sendAddBroadcastSourceCallback(masterDevice,
                BassClientStateMachine.INVALID_SRC_ID, BleBroadcastAudioScanAssistCallback.BASS_STATUS_DUPLICATE_ADDITION);
            triggerUnlockforCSet(masterDevice);
            return false;
        }
        for (BluetoothDevice dev : devices) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
            if (stateMachine == null) {
                Log.w(TAG, "addBroadcastSource: device seem to be not avaiable, proceed");
                continue;
            }
            Message m = stateMachine.obtainMessage(BassClientStateMachine.ADD_BCAST_SOURCE);
            m.obj = srcInfo;
            stateMachine.sendMessage(m);
            mQueuedOps = mQueuedOps + 1;
        }
        return true;
    }

    private byte getSrcIdForCSMember(BluetoothDevice masterDevice, BluetoothDevice memberDevice, byte masterSrcId) {
        byte targetSrcId = -1;
        List<BleBroadcastSourceInfo> masterSrcInfos = getAllBroadcastSourceInformation(masterDevice);
        List<BleBroadcastSourceInfo> memberSrcInfos = getAllBroadcastSourceInformation(memberDevice);
        if (masterSrcInfos == null || masterSrcInfos.size() == 0 ||
            memberSrcInfos == null || memberSrcInfos.size() == 0) {
            Log.e(TAG, "master or member source Infos not available");
            return targetSrcId;
        }
        if (masterDevice.equals(memberDevice)) {
            log("master: " + masterDevice + "member:memberDevice");
            return masterSrcId;
        }
        BluetoothDevice masterSrcDevice = null;
        for (int i=0; i<masterSrcInfos.size(); i++) {
            if (masterSrcInfos.get(i).getSourceId() == masterSrcId) {
                masterSrcDevice = masterSrcInfos.get(i).getSourceDevice();
                break;
            }
        }
        if (masterSrcDevice == null) {
            Log.e(TAG, "No matching SRC Id for the operation in masterDevice");
            return targetSrcId;
        }

        //look for this srcAddress in member to retrieve the srcId
        for (int i=0; i<memberSrcInfos.size(); i++) {
            if (masterSrcDevice.equals(memberSrcInfos.get(i).getSourceDevice())) {
                targetSrcId = masterSrcInfos.get(i).getSourceId();
                break;
            }
        }
        if (targetSrcId == -1) {
            Log.e(TAG, "No matching SRC Address in the member Src Infos");
        }
        return targetSrcId;
    }

    public synchronized boolean updateBroadcastSource (BluetoothDevice masterDevice, List<BluetoothDevice> devices,
                                    BleBroadcastSourceInfo srcInfo
                                 ) {

         int status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
         Log.i(TAG, "updateBroadcastSource for " + devices +
                     "masterDevice " + masterDevice +
                     "SourceInfo " + srcInfo);

         if (srcInfo == null) {
             Log.e(TAG, "updateBroadcastSource: null SrcInfo");
             return false;
         }

         for (BluetoothDevice dev : devices) {
             if (getSrcIdForCSMember(masterDevice, dev, srcInfo.getSourceId()) == -1) {
                  if (devices.size() > 1) {
                      status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_GROUP_OP;
                  } else {
                      status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
                  }
                  sendRemoveBroadcastSourceCallback(masterDevice, BassClientStateMachine.INVALID_SRC_ID,
                          status);
                  triggerUnlockforCSet(masterDevice);
                  return false;
             }
         }

         for (BluetoothDevice dev : devices) {
             BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
             if (stateMachine == null) {
                 Log.w(TAG, "updateBroadcastSource: Device seem to be not avaiable");
                 continue;
             }
             byte targetSrcId = getSrcIdForCSMember(masterDevice, dev, srcInfo.getSourceId());
             srcInfo.setSourceId(targetSrcId);

             Message m = stateMachine.obtainMessage(BassClientStateMachine.UPDATE_BCAST_SOURCE);
             m.obj = srcInfo;
             m.arg1 = stateMachine.USER;
             stateMachine.sendMessage(m);
             mQueuedOps = mQueuedOps + 1;
         }

        return true;
    }

    public synchronized boolean setBroadcastCode  (BluetoothDevice masterDevice, List<BluetoothDevice> devices,
                                      BleBroadcastSourceInfo srcInfo
                                    ) {

        int status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
        Log.i(TAG, "setBroadcastCode for " + devices +
                   "masterDevice" + masterDevice +
                   "Broadcast PIN" + srcInfo.getBroadcastCode());

        if (srcInfo == null) {
            Log.e(TAG, "setBroadcastCode: null SrcInfo");
            return false;
        }

        for (BluetoothDevice dev : devices) {
            if (getSrcIdForCSMember(masterDevice, dev, srcInfo.getSourceId()) == -1) {
                 if (devices.size() > 1) {
                     status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_GROUP_OP;
                 } else {
                     status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
                 }
                 sendRemoveBroadcastSourceCallback(masterDevice, BassClientStateMachine.INVALID_SRC_ID,
                         status);
                 triggerUnlockforCSet(masterDevice);
                 return false;
            }
        }

        for (BluetoothDevice dev : devices) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
            if (stateMachine == null) {
                 Log.w(TAG, "setBroadcastCode: Device seem to be not avaiable");
                 continue;
            }

            byte targetSrcId = getSrcIdForCSMember(masterDevice, dev, srcInfo.getSourceId());
            srcInfo.setSourceId(targetSrcId);

            Message m = stateMachine.obtainMessage(BassClientStateMachine.SET_BCAST_CODE);
            m.obj = srcInfo;
            m.arg1 = stateMachine.FRESH;
            stateMachine.sendMessage(m);
            mQueuedOps = mQueuedOps + 1;
        }

        return true;
    }

    public synchronized boolean removeBroadcastSource (BluetoothDevice masterDevice, List<BluetoothDevice> devices,
                                    byte sourceId
                                 ) {

        int status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
        Log.i(TAG,  "removeBroadcastSource for " + devices +
                   "masterDevice " + masterDevice +
                    "removeBroadcastSource: sourceId:" + sourceId);

        if (sourceId == BassClientStateMachine.INVALID_SRC_ID) {
            Log.e(TAG, "removeBroadcastSource: Invalid source Id");
            return false;
        }


        for (BluetoothDevice dev : devices) {
            if (getSrcIdForCSMember(masterDevice, dev, sourceId) == -1) {
                 if (devices.size() > 1) {
                     status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_GROUP_OP;
                 } else {
                     status = BleBroadcastAudioScanAssistCallback.BASS_STATUS_INVALID_SOURCE_ID;
                 }
                 sendRemoveBroadcastSourceCallback(masterDevice, BassClientStateMachine.INVALID_SRC_ID,
                         status);
                 triggerUnlockforCSet(masterDevice);
                 return false;
            }
        }

        for (BluetoothDevice dev : devices) {
            BassClientStateMachine stateMachine = getOrCreateStateMachine(dev);
            if (stateMachine == null) {
                Log.w(TAG, "setBroadcastCode: Device seem to be not avaiable");
                continue;
            }

            Message m = stateMachine.obtainMessage(BassClientStateMachine.REMOVE_BCAST_SOURCE);
            m.arg1 = getSrcIdForCSMember(masterDevice, dev, sourceId);
            log("removeBroadcastSource: send message to SM " + dev);
            stateMachine.sendMessage(m);
            mQueuedOps = mQueuedOps + 1;
        }

        return true;
    }

    void triggerUnlockforCSet (BluetoothDevice device) {
        //get setId
        int setId = getCsetId(device);
        BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
        if (setMgr == null) {
            Log.e(TAG, "triggerUnlockforCSet: setMgr is NULL");
            return;
        }
        //Sending UnLock to
        log ("sending Unlock to device:" + device);
        Message m = setMgr.obtainMessage(BassCsetManager.UNLOCK);
        setMgr.sendMessage(m);
    }
    public List<BleBroadcastSourceInfo> getAllBroadcastSourceInformation (BluetoothDevice device
                                    ) {
        Log.i(TAG, "getAllBroadcastSourceInformation for " + device);
        synchronized (mStateMachines) {
            BassClientStateMachine sm = getOrCreateStateMachine(device);
            if (sm == null) {
                return null;
            }
            return sm.getAllBroadcastSourceInformation();
        }
    }

    private BassClientStateMachine getOrCreateStateMachine(BluetoothDevice device) {
        if (device == null) {
            Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null");
            return null;
        }
        synchronized (mStateMachines) {
            BassClientStateMachine sm = mStateMachines.get(device);
            if (sm != null) {
                return sm;
            }
            // Limit the maximum number of state machines to avoid DoS attack
            if (mStateMachines.size() >= MAX_BASS_CLIENT_STATE_MACHINES) {
                Log.e(TAG, "Maximum number of Bassclient state machines reached: "
                        + MAX_BASS_CLIENT_STATE_MACHINES);
                return null;
            }
            if (DBG) {
                Log.d(TAG, "Creating a new state machine for " + device);
            }
            sm = BassClientStateMachine.make(device, this,
                    mStateMachinesThread.getLooper());
            mStateMachines.put(device, sm);
            return sm;
        }
    }

    private BassCsetManager getOrCreateCSetManager(int setId, BluetoothDevice masterDevice) {
        if (setId == -1) {
            Log.e(TAG, "getOrCreateCSetManager failed: invalid setId");
            return null;
        }
        synchronized (mSetManagers) {
            BassCsetManager sm = mSetManagers.get(setId);
            log("getOrCreateCSetManager: hashmap Entry:" + sm);
            if (sm != null) {
                return sm;
            }
            // Limit the maximum number of set manager state machines
            if (mStateMachines.size() >= MAX_BASS_CLIENT_CSET_MEMBERS) {
                Log.e(TAG, "Maximum number of Bassclient cset members reached: "
                        + MAX_BASS_CLIENT_CSET_MEMBERS);
                return null;
            }
            if (DBG) {
                Log.d(TAG, "Creating a new set Manager for " + setId);
            }
            sm = BassCsetManager.make(setId, masterDevice, this,
                    mSetManagerThread.getLooper());
            mSetManagers.put(setId, sm);
            return sm;
        }
    }

    public boolean isLockSupportAvailable(BluetoothDevice device) {
        boolean isLockAvail = false;
        boolean forceNoCsip = SystemProperties.getBoolean("persist.vendor.service.bt.forceNoCsip", false);
        if (forceNoCsip) {
            log("forceNoCsip is set");
            return isLockAvail;
        }
        //*_CSIP
        isLockAvail = mAdapterService.isGroupExclAccessSupport(device);
        //_CSIP*/

        log("isLockSupportAvailable for:" + device + "returns " + isLockAvail);
        return isLockAvail;
    }

    private int getCsetId(BluetoothDevice device) {
        int setId = 1;
        //*_CSIP
        setId = mSetCoordinator.getRemoteDeviceGroupId(device, CAS_UUID);
        //_CSIP*/
        log("getCsetId return:" + setId);
        return setId;
    }
    public boolean stopScanOffloadInternal (BluetoothDevice device, boolean isGroupOp) {
        boolean ret = false;
        log("stopScanOffloadInternal: device: " + device
             + "isGroupOp" + isGroupOp);
        /* Even If the request is for Grouoop, If Lock support not avaiable
         * for that device, go ahead and treat this as single device operation
         */
        if (isGroupOp && isLockSupportAvailable(device) == true) {
            int setId = getCsetId(device);
            synchronized (mSetManagers) {
                BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                if (setMgr == null) {
                    return false;
                 }
                 Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_STOP_SCAN_OFFLOAD);
                 setMgr.sendMessage(m);
                 //queue req and return true
                 ret = true;
            }
        } else {
            List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
            listOfDevices.add(device);
            ret = stopScanOffload(device, listOfDevices);
        }
        return ret;
    }

    public boolean startScanOffloadInternal (BluetoothDevice device, boolean isGroupOp) {
        boolean ret = false;
        log("startScanOffloadInternal: device: " + device
             + "isGroupOp" + isGroupOp);
        /* Even If the request is for Grouoop, If Lock support not avaiable
         * for that device, go ahead and treat this as single device operation
         */
        if (isGroupOp&& isLockSupportAvailable(device) == true) {
            int setId = getCsetId(device);
            synchronized (mSetManagers) {
                BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                if (setMgr == null) {
                    return false;
                 }
                 Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_START_SCAN_OFFLOAD);
                 setMgr.sendMessage(m);
                 //queue req and return true
                 ret = true;
            }
        } else {
           List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
           listOfDevices.add(device);
           ret = startScanOffload(device, listOfDevices);
        }
        return ret;
    }

    public boolean addBroadcastSourceInternal (BluetoothDevice device, BleBroadcastSourceInfo srcInfo,
                                      boolean isGroupOp) {
        boolean ret = false;
        log("addBroadcastSourceInternal: device: " + device
            + "srcInfo" + srcInfo
            + "isGroupOp" + isGroupOp);
        /* Even If the request is for Group, If Lock support not avaiable
         * for that device, go ahead and treat this as single device operation
         */
        if (isGroupOp && isLockSupportAvailable(device) == true) {
            int setId = getCsetId(device);
            synchronized (mSetManagers) {
                BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                if (setMgr == null) {
                    return false;
                 }
                 Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_ADD_BCAST_SOURCE);
                 m.obj = srcInfo;
                 setMgr.sendMessage(m);
                 //queue req and return true
                 ret = true;
            }
        } else {
           List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
           listOfDevices.add(device);
           ret = addBroadcastSource(device, listOfDevices, srcInfo);
        }
        return ret;
    }

    public boolean updateBroadcastSourceInternal (BluetoothDevice device, BleBroadcastSourceInfo srcInfo,
                                                          boolean isGroupOp
                                      ) {
        boolean ret = false;
        log("updateBroadcastSourceInternal: device: " + device
            + "srcInfo" + srcInfo
            + "isGroupOp" + isGroupOp);
        /* Even If the request is for Grouoop, If Lock support not avaiable
         * for that device, go ahead and treat this as single device operation
         */
        if (isGroupOp && isLockSupportAvailable(device) == true) {
            int setId = getCsetId(device);
            synchronized (mSetManagers) {
                BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                if (setMgr == null) {
                    return false;
                 }
                 Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_UPDATE_BCAST_SOURCE);
                 m.obj = srcInfo;
                 setMgr.sendMessage(m);
                 //queue req and return true
                 ret = true;
            }
        } else {
           List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
           listOfDevices.add(device);
           ret = updateBroadcastSource(device, listOfDevices, srcInfo);
        }
        return ret;
    }

    protected boolean setBroadcastCodeInternal (BluetoothDevice device, BleBroadcastSourceInfo srcInfo,
                                                   boolean isGroupOp
                                      ) {
        boolean ret = false;
        log("setBroadcastCodeInternal: device: " + device
            + "srcInfo" + srcInfo
            + "isGroupOp" + isGroupOp);
        /* Even If the request is for Grouoop, If Lock support not avaiable
         * for that device, go ahead and treat this as single device operation
         */
        if (isGroupOp && isLockSupportAvailable(device) == true) {
            int setId = getCsetId(device);
            synchronized (mSetManagers) {
                BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                if (setMgr == null) {
                    return false;
                 }
                 Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_SET_BCAST_CODE);
                 m.obj = srcInfo;
                 setMgr.sendMessage(m);
                 //queue req and return true
                 ret = true;
            }
        } else {
           List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
           listOfDevices.add(device);
           ret = setBroadcastCode(device, listOfDevices, srcInfo);
        }
        return ret;
    }

    public boolean removeBroadcastSourceInternal (BluetoothDevice device, byte sourceId, boolean isGroupOp
                                       ) {
         boolean ret = false;
         /* Even If the request is for Grouoop, If Lock support not avaiable
          * for that device, go ahead and treat this as single device operation
          */
         if (isGroupOp && isLockSupportAvailable(device) == true) {
             int setId = getCsetId(device);
             synchronized (mSetManagers) {
                 BassCsetManager setMgr = getOrCreateCSetManager(setId, device);
                 if (setMgr == null) {
                     return false;
                  }
                  Message m = setMgr.obtainMessage(BassCsetManager.BASS_GRP_REMOVE_BCAST_SOURCE);
                  m.arg1 = sourceId;
                  setMgr.sendMessage(m);
                  //queue req and return true
                  ret = true;
             }
         } else {
            List<BluetoothDevice> listOfDevices = new ArrayList<BluetoothDevice>();
            listOfDevices.add(device);
            ret = removeBroadcastSource(device, listOfDevices, sourceId);
         }
         return ret;
     }

    static void log(String msg) {
        if (BassClientStateMachine.BASS_DBG) {
           Log.d(TAG, msg);
        }
    }

    /**
     * Binder object: must be a static class or memory leak may occur
     */
    @VisibleForTesting
    static class BluetoothSyncHelperBinder extends IBluetoothSyncHelper.Stub
            implements IProfileServiceBinder {
        private BCService mService;

        private BCService getService() {
            if (!Utils.checkCallerIsSystemOrActiveUser(TAG)) {
                return null;
            }

            if (mService != null && mService.isAvailable()) {
                return mService;
            }
            return null;
        }

        BluetoothSyncHelperBinder(BCService svc) {
            mService = svc;
        }

        @Override
        public void cleanup() {
            mService = null;
        }

        @Override
        public boolean connect(BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.connect(device);
        }

        @Override
        public boolean disconnect(BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.disconnect(device);
        }

        @Override
        public List<BluetoothDevice> getConnectedDevices() {
            BCService service = getService();
            if (service == null) {
                return new ArrayList<>();
            }
            return service.getConnectedDevices();
        }

        @Override
        public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
            BCService service = getService();
            if (service == null) {
                return new ArrayList<>();
            }
            return service.getDevicesMatchingConnectionStates(states);
        }

        @Override
        public int getConnectionState(BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return BluetoothProfile.STATE_DISCONNECTED;
            }
            return service.getConnectionState(device);
        }

        @Override
        public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
           return service.setConnectionPolicy(device, connectionPolicy);
        }

        @Override
        public int getConnectionPolicy(BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return BluetoothProfile.CONNECTION_POLICY_UNKNOWN;
            }
            return service.getConnectionPolicy(device);
        }
        @Override
        public boolean searchforLeAudioBroadcasters (BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.searchforLeAudioBroadcasters(device);
        }

        @Override
        public boolean stopSearchforLeAudioBroadcasters (BluetoothDevice device) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.stopSearchforLeAudioBroadcasters(device);
        }

        @Override
        public boolean selectBroadcastSource (BluetoothDevice device, ScanResult scanRes, boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.selectBroadcastSource(device, scanRes, isGroupOp, false);
        }

        @Override
        public void registerAppCallback(BluetoothDevice device, IBleBroadcastAudioScanAssistCallback cb) {
            BCService service = getService();
            if (service == null) {
                return;
            }
            service.registerAppCallback(device, cb);
        }

        @Override
        public void unregisterAppCallback(BluetoothDevice device, IBleBroadcastAudioScanAssistCallback cb) {
            BCService service = getService();
            if (service == null) {
                return;
            }
            service.unregisterAppCallback(device, cb);
        }

        @Override
        public boolean startScanOffload(BluetoothDevice device, boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.startScanOffloadInternal(device, isGroupOp);
        }

        @Override
        public boolean stopScanOffload(BluetoothDevice device, boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.stopScanOffloadInternal(device, isGroupOp);
        }

        @Override
        public boolean addBroadcastSource(BluetoothDevice device, BleBroadcastSourceInfo srcInfo
                                      , boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.addBroadcastSourceInternal(device, srcInfo, isGroupOp);
        }

        @Override
        public boolean updateBroadcastSource (BluetoothDevice device,
                                    BleBroadcastSourceInfo srcInfo,
                                    boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.updateBroadcastSourceInternal(device, srcInfo, isGroupOp);
        }

        @Override
        public boolean setBroadcastCode (BluetoothDevice device,
                                    BleBroadcastSourceInfo srcInfo,
                                    boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.setBroadcastCodeInternal(device, srcInfo, isGroupOp);
        }

        @Override
        public boolean removeBroadcastSource (BluetoothDevice device,
                                    byte sourceId,
                                    boolean isGroupOp) {
            BCService service = getService();
            if (service == null) {
                return false;
            }
            return service.removeBroadcastSourceInternal(device, sourceId, isGroupOp);
        }
        @Override
        public List<BleBroadcastSourceInfo> getAllBroadcastSourceInformation (BluetoothDevice device
                                    ) {
            BCService service = getService();
            if (service == null) {
                return null;
            }
            return service.getAllBroadcastSourceInformation(device);
       }
   }
}