/*
 *Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
 */

/*
 * Copyright 2012 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.cc;

import static android.Manifest.permission.BLUETOOTH_CONNECT;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothHeadset;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.telephony.PhoneStateListener;
import android.content.SharedPreferences;
import android.util.Log;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Queue;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.Map;
import android.os.Message;
import android.os.Binder;
import android.os.IBinder;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.SystemProperties;
import android.util.Log;

import com.android.bluetooth.Utils;
import com.android.bluetooth.btservice.AdapterService;
import com.android.bluetooth.btservice.ProfileService;
import com.android.bluetooth.apm.ApmConst;
import com.android.bluetooth.apm.CallAudio;
import com.android.bluetooth.apm.CallControl;
import com.android.bluetooth.apm.ActiveDeviceManagerService;
import java.util.Objects;

/**
 * Provides Bluetooth CC profile as a service in the Bluetooth application.
 * @hide
 */
public class CCService extends ProfileService {

    private static final String TAG = "CCService";
    private static final String DISABLE_INBAND_RINGING_PROPERTY =
             "persist.bluetooth.disableinbandringing";
    private static final boolean DBG = true;
    private static CCService sCCService;
    private BroadcastReceiver mBondStateChangedReceiver;

    private int mCCId = 0xFF;
    private BluetoothDevice mActiveDevice;
    private BluetoothDevice mCallOriginatedDevice = null;
    private AdapterService mAdapterService;
    private CCNativeInterface mNativeInterface;
    private CallAudio mCallAudio = null;
    private ActiveDeviceManagerService mActiveDevMgrService = null;
    private Context mContext  = null;;
    private CcsMessageHandler mHandler;
    private int mMaxConnectedAudioDevices = 1;
    private boolean  InBandRingtoneSupport = false;
    private boolean mVirtualCallStarted = false;
    private boolean mStarted;
    private boolean mCreated;
    private static int mLatestActiveCallIndex = 0;
    private static int mLatestHeldCallIndex = 0;
    private CallControlState mPrevTelephonyState = null;
    private HashMap<Integer, CallControlState> mCallStateList = null;
    private HashMap<Integer, CallControlState> mPrevCallStateList = null;
    private Queue<Integer> mLccTobeQueued = null;
    private Queue<Integer> mLccWaitForResponseQ = null;

    private static final int FLAGS_DIRECTION_BIT = 0x0001;
    private static final int CC_SIGNAL_STRENGTH_FACTOR = 20;

    private static final int CC_CONTENT_CONTROL_ID = 77;
    private static final int CC_OPTIONAL_LOCAL_HOLD_FEAT = 0x01;
    private static final int CC_OPTIONAL_JOIN_FEAT = 0x02;
    private static final int CALL_CONTROL_OPTIONAL_FEATURES = CC_OPTIONAL_LOCAL_HOLD_FEAT|CC_OPTIONAL_JOIN_FEAT;
    //native event
    static final int EVENT_TYPE_CONNECTION_STATE_CHANGED = 1;
    static final int EVENT_TYPE_CALL_CONTROL_POINT_CHANGED = 2;
    //CC to JNI update
    static final int UPDATE_BEARER_NAME = 3;
    static final int UPDATE_BEARER_TECH = 4;
    static final int UPDATE_STATUS_FLAGS = 5;
    static final int UPDATE_SIGNAL_STRENGTH = 6;
    static final int UPDATE_BEARERLIST_SUPPORTED = 7;
    static final int UPDATE_CONTENT_CONTROL_ID = 8;
    static final int UPDATE_CALL_STATE = 9;
    static final int UPDATE_CALL_CONTROL_OPCODES_SUPPORTED = 10;
    static final int UPDATE_CALL_CONTROL_RESPONSE = 11;
    static final int UPDATE_INCOMING_CALL = 12;
    static final int PROCESS_CALL_STATE = 13;
    static final int PROCESS_PHONE_STATE_CHANGED = 14;
    static final int ACTIVE_DEVICE_CHANGED = 15;

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

    @Override
    protected void create() {
        Log.i(TAG, "create()");
        if (mCreated) {
            throw new IllegalStateException("create() called twice");
        }
        mCreated = true;
    }

    @Override
    protected void cleanup() {
        Log.i(TAG, "cleanup()");
        if (mNativeInterface != null) {
           mNativeInterface.cleanup();
        }
    }

    @Override
    protected boolean start() {
        Log.i(TAG, "start()");
        if (sCCService != null) {
            Log.w(TAG, "CCService is already running");
            return true;
        }
        if (DBG) {
            Log.d(TAG, "Create CCService Instance");
        }

        mContext = this;
        mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
                "AdapterService cannot be null when CCService starts");
        mNativeInterface = Objects.requireNonNull(CCNativeInterface.getInstance(),
                "CcNativeInterface cannot be null when CcService starts");
        // Step 2: Get maximum number of connected audio devices
        mMaxConnectedAudioDevices = mAdapterService.getMaxConnectedAudioDevices();
        Log.i(TAG, "Max connected audio devices set to " + mMaxConnectedAudioDevices);

        if (mHandler != null) {
           mHandler = null;
        }
        HandlerThread thread = new HandlerThread("BluetoothCCSHandler");
        thread.start();
        Looper looper = thread.getLooper();
        mHandler = new CcsMessageHandler(looper);
        //APM's CallControl and CallAudio initialization
        CallControl.init(mContext);
        mCallAudio = CallAudio.init(mContext);
        mNativeInterface.init(mMaxConnectedAudioDevices,InBandRingtoneSupport);
        Log.d(TAG, "cc native init done");
        IntentFilter filter = new IntentFilter();
        //mSystemInterface = HeadsetService.getSystemInterfaceObj();
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        mBondStateChangedReceiver = new BondStateChangedReceiver();
        mContext.registerReceiver(mBondStateChangedReceiver, filter);
        mCallStateList = new HashMap<> ();
        mPrevCallStateList = new HashMap<> ();
        mLccWaitForResponseQ = new LinkedList<> ();
        mLccTobeQueued = new LinkedList<> ();
        mActiveDevMgrService = ActiveDeviceManagerService.get();
        setCCService(this);
        return true;
    }

    @Override
    protected boolean stop() {
        Log.i(TAG, "stop()");
        if (sCCService == null) {
           Log.w(TAG, "stop() called before start()");
           return true;
        }
        // Step 8: Mark service as stopped
        setCCService(null);
        // Cleanup native interface
        mNativeInterface.cleanup();
        mNativeInterface = null;
        mContext.unregisterReceiver(mBondStateChangedReceiver);
        // Clear AdapterService
        mAdapterService = null;
        mMaxConnectedAudioDevices = 1;
        mCallOriginatedDevice = null;
        CallControl.listenForPhoneState(PhoneStateListener.LISTEN_NONE);
        return true;
    }

    private static synchronized void setCCService(CCService instance) {
        if (DBG) {
            Log.d(TAG, "setCCService(): set to: " + instance);
        }
        sCCService = instance;
    }

    public static synchronized CCService getCCService() {
        if (sCCService == null) {
            Log.w(TAG, "getCCService(): service is null");
            return null;
        }
        return sCCService;
    }

    public boolean updateBearerProviderName(String name) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_BEARER_NAME;
       msg.obj = name;
       mHandler.sendMessage(msg);
       return true;
    }
    public boolean updateBearerProviderTechnology (int  tech_type)  {
      Message msg = mHandler.obtainMessage();
      msg.what = UPDATE_BEARER_TECH;
      msg.arg1 = tech_type;
      mHandler.sendMessage(msg);
      return true;
    }

    public boolean updateSignalStrength(int signal) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_SIGNAL_STRENGTH;
       msg.arg1 = signal*CC_SIGNAL_STRENGTH_FACTOR;
       mHandler.sendMessage(msg);
       return true;
    }

    public boolean updateSupportedBearerList(String supportedBearers) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_BEARERLIST_SUPPORTED ;
       msg.obj = supportedBearers;
       mHandler.sendMessage(msg);
       return true;
    }

    public void updateOriginateResult(BluetoothDevice device, int event, int res) {
        if (mCallOriginatedDevice == null || device != mCallOriginatedDevice) {
            Log.e(TAG, "Originate resp ignored, as there is no Orginate req");
            return;
        }
        if (res != 1) {
            mCallOriginatedDevice = null;
            updateCallControlResponse(CCHalConstants.BTCC_OP_ORIGINATE,
                                      CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES,
                                      CCHalConstants.BTCC_OP_NOT_POSSIBLE, device);
        }
    }

    public boolean updateContentControlID(int ccid) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_CONTENT_CONTROL_ID;
       msg.arg1 = ccid;
       mHandler.sendMessage(msg);
       mCCId = ccid;
       return true;
    }

    public boolean updateStatusFlags(int statusFlags) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_STATUS_FLAGS;
       msg.arg1 = statusFlags;
       mHandler.sendMessage(msg);
       return true;
    }

    public boolean updateCallControlOptionalFeatures(int feature) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_CALL_CONTROL_OPCODES_SUPPORTED;
       msg.arg1 = feature;
       mHandler.sendMessage(msg);
       return true;
    }

    public boolean updateCallControlResponse(int op, int index, int status, BluetoothDevice device) {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_CALL_CONTROL_RESPONSE ;
       msg.arg1 = op;
       msg.arg2 = index;
       msg.obj = status;
       mHandler.sendMessage(msg);
       return true;
    }

    private boolean updateIncomingCall(int index, String uri)  {
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_INCOMING_CALL ;
       msg.arg1 = index;
       msg.obj = uri;
       mHandler.sendMessage(msg);
       return true;
    }

    boolean isVirtualCallStarted() {

        return mVirtualCallStarted;
    }

   public void setVirtualCallActive(boolean state) {
      Log.i(TAG, "setVirtualCallActive: " + state);
      if (state == true) {
        startScoUsingVirtualVoiceCall();
      } else {
          stopScoUsingVirtualVoiceCall();
      }
    }

    private void disaptchFakeCallState (CallControlState state) {
        if (state != null) {
            mCallStateList.put(state.mIndex, state);
        }
        Message msg = mHandler.obtainMessage();
        msg.what = PROCESS_CALL_STATE;
        Collection<CallControlState> values = mCallStateList.values();
        ArrayList<CallControlState> listOfValues = new ArrayList<>(values);
        msg.obj = listOfValues;
        mHandler.sendMessage(msg);
    }

    boolean startScoUsingVirtualVoiceCall() {

        Log.i(TAG, "startScoUsingVirtualVoiceCall: " + Utils.getUidPidString());
        mVirtualCallStarted = true;
        // Send fake call states to mimic outgoing calls

        mCallStateList.clear();
        CallControlState alertingState = new CallControlState(1,CCHalConstants.CALL_STATE_ALERTING,FLAGS_DIRECTION_BIT);
        disaptchFakeCallState(alertingState);
        CallControlState activeState = new CallControlState(1,CCHalConstants.CALL_STATE_ACTIVE,FLAGS_DIRECTION_BIT);
        disaptchFakeCallState(activeState);
        return true;
   }

   boolean stopScoUsingVirtualVoiceCall() {

        Log.i(TAG, "stopScoUsingVirtualVoiceCall: " + Utils.getUidPidString());
            // 1. Check if virtual call has already started
         if (!mVirtualCallStarted) {
            Log.w(TAG, "stopScoUsingVirtualVoiceCall: virtual call not started");
             return false;
         }
         mVirtualCallStarted = false;
            // 2. Send fake call states to mimic it ias outgoing calls

         mCallStateList.clear();
         CallControlState disConnectedState = new CallControlState(1,CCHalConstants.CCS_STATE_DISCONNECTED,FLAGS_DIRECTION_BIT);
         disaptchFakeCallState(disConnectedState);
         return true;
   }

   private void updateCallState(ArrayList<CallControlState> listOfValues) {
       Log.d(TAG, "updateCallState");
       Message msg = mHandler.obtainMessage();
       msg.what = UPDATE_CALL_STATE;
       msg.obj = listOfValues;
       mHandler.sendMessage(msg);
   }

   public void processAndUpdateCallState(ArrayList<CallControlState> listOfValues) {
      int flags = 0;

      for (CallControlState state : listOfValues) {
          Log.i(TAG, "processAndUpdateCallState: direction" + state.mDirection);
          if (state.mDirection == 1) {
              //Incoming call: off the direction bit
             flags = (flags & (~FLAGS_DIRECTION_BIT));
          } else {
             //Outgoing call: on the direction bit
             flags = (flags | FLAGS_DIRECTION_BIT);
          }
          state.mFlags = flags;
          String uri = "";
          String uri_str = "tel:";
          Log.i(TAG, "processAndUpdateCallState: index = " + state.mIndex);
          if (state.mState == CCHalConstants.CALL_STATE_ACTIVE) {
              mLatestActiveCallIndex = state.mIndex;
          } else if (state.mState == CCHalConstants.CALL_STATE_HELD) {
              mLatestHeldCallIndex = state.mIndex;
          }
          if (state.mState == CCHalConstants.CALL_STATE_INCOMING) {
              if (state.mNumber != null) {
                  uri = uri_str.concat(state.mNumber);
              }
              Log.i(TAG, "processAndUpdateCallState: inc uri = " + uri);
              updateIncomingCall(state.mIndex, uri);
          }
      }
      updateCallState(listOfValues);
   }

   private void compareAndUpdateWithPrevCallList (HashMap<Integer, CallControlState> currentCallStateList) {
        Log.d(TAG, "compareAndUpdateWithPrevCallList");
        for (Integer key: mPrevCallStateList.keySet()) {
            if (currentCallStateList.containsKey(key) == false) {
            //create a fake disconnected for that index
                if (mPrevCallStateList.get(key).mState != CCHalConstants.CALL_STATE_DISCONNECTED) {
                    Log.d(TAG, "inserting DISC state fake!");
                    CallControlState fakeDiscForDisappeared =
                        new CallControlState(key,CCHalConstants.CALL_STATE_DISCONNECTED, mPrevCallStateList.get(key).mFlags);
                        mCallStateList.put(key, fakeDiscForDisappeared);
                }
            }
        }
        mPrevCallStateList.putAll(mCallStateList);
   }

   public void clccResponse(int index, int direction, int call_status, int mode, boolean mpty,
                 String number, int type) {
        Log.d(TAG, "clccResponse");
        if (index != 0) {
            CallControlState state = new CallControlState(index, direction, call_status, number);
            mCallStateList.put(index, state);
        } else {
            //update the call state to stack as 0 indicates end of call list
            compareAndUpdateWithPrevCallList(mCallStateList);
            Message msg = mHandler.obtainMessage();
            msg.what = PROCESS_CALL_STATE;
            Collection<CallControlState> values = mCallStateList.values();
              ArrayList<CallControlState> listOfValues = new ArrayList<>(values);
            msg.obj = listOfValues;
            mHandler.sendMessage(msg);
            if (!mLccWaitForResponseQ.isEmpty()) {
                mLccWaitForResponseQ.remove();
            }
            if (!mLccTobeQueued.isEmpty()) {
                mLccTobeQueued.remove();
                getBlcc();
            }
        }
    }

    private void getBlcc() {
        Log.d(TAG, "getBlcc");
        if (mLccTobeQueued.isEmpty()) {
            if (CallControl.listCurrentCalls() == true) {
                mLccWaitForResponseQ.add(1);
                Log.d(TAG, "getBlcc: successfully sent");
                //telephony should always respond with clccresponse
                mCallStateList.clear();
            }
        } else {
            mLccTobeQueued.add(1);
        }
    }

    private boolean processCallStateChange(CallControlState state) {
        Message msg = mHandler.obtainMessage();
        msg.what = PROCESS_PHONE_STATE_CHANGED;
        msg.obj = state;
        mHandler.sendMessage(msg);
        return true;
    }

    boolean isInbandRingingEnabled() {
        boolean returnVal;

        returnVal = BluetoothHeadset.isInbandRingingSupported(this) && !SystemProperties.getBoolean(
                DISABLE_INBAND_RINGING_PROPERTY, true);
        Log.d(TAG, "isInbandRingingEnabled returning: " + returnVal);
        return returnVal;
    }

     boolean isCallAudioNeeded(CallControlState state) {
        boolean ret = false;
        if (isInbandRingingEnabled() && state.mState == CCHalConstants.CALL_STATE_INCOMING) {
            ret = true;
        } else if (mCallAudio != null && mCallAudio.isAudioOn() == false &&
                   (state.mState == CCHalConstants.CALL_STATE_ALERTING ||
                   mPrevTelephonyState != null && mPrevTelephonyState.mNumActive == 0 &&
                   state.mNumActive == 1)) {

            ret = true;
        }
        return ret;
    }

    public  boolean  phoneStateChanged(int numActive, int numHeld, int callState, String number, int type,
                       String name, boolean isVirtualCall)    {
      Log.d(TAG, "phoneStateChanged: " +
                 "callState: " + callState +
                 "number:" + number +
                 "numActive:" + numActive +
                 "isVirtualCall:" + isVirtualCall);
      CallControlState currentTelephonyState = new CallControlState(numActive, numHeld,callState, number, type, name);

      if (isCallAudioNeeded(currentTelephonyState)) {
          if (mCallAudio != null) {
            mCallAudio.connectAudio();
        } else {
            Log.e(TAG, "no CallAudio handle");
        }
      }

      if (mPrevTelephonyState != null && mPrevTelephonyState.mNumActive == 1
            && currentTelephonyState.mNumActive == 0 && currentTelephonyState.mNumHeld == 0) {
            if (mPrevTelephonyState.mNumHeld == 0 && currentTelephonyState.mNumHeld == 1) {
             Log.d(TAG, "special case where Active call moved to HOLD");
          } else {
             if (mCallAudio != null) {
                 mCallAudio.disconnectAudio();
             } else {
                 Log.e(TAG, "no CallAudio handle for disc Call handling");
             }
          }
      }

      if (callState == CCHalConstants.CALL_STATE_DIALING) {
          //ignore this as it is fake Telephony event
          return true;
      }

      // Should stop all other audio mode in this case
      if ((numActive + numHeld) > 0 || callState != CCHalConstants.CALL_STATE_IDLE) {
          if (!isVirtualCall && mVirtualCallStarted) {
              // stop virtual voice call if there is an incoming Telecom call update
              stopScoUsingVirtualVoiceCall();
          }
          processCallStateChange(currentTelephonyState);
          mPrevTelephonyState = currentTelephonyState;
       } else {
          // ignore CS non-call state update when virtual call started
          if (!isVirtualCall && mVirtualCallStarted) {
            Log.i(TAG, "Ignore CS non-call state update");
            return true;
          }
       }
       return true;
   }

    public BluetoothDevice getActiveDevice() {
        return mActiveDevice;
    }

    public int getContentControlID() {
        return mCCId;
    }

    public boolean setActiveDevice(BluetoothDevice device) {
        Message msg = mHandler.obtainMessage();
        msg.what = ACTIVE_DEVICE_CHANGED;
        msg.obj = device;
        mHandler.sendMessage(msg);
        return true;
    }

    private boolean setActiveDeviceRemoteTrigger(BluetoothDevice device) {
        boolean ret = false;
        if (mActiveDevMgrService != null) {
            ret = mActiveDevMgrService.setActiveDeviceBlocking(device, ApmConst.AudioFeatures.CALL_AUDIO);
        }
        Log.d(TAG, "setActiveDevice returns" + ret);
        return ret;
    }

    private boolean isActiveDevice(BluetoothDevice device) {
        boolean ret = false;
        if (mActiveDevMgrService != null) {
            ret = (device == mActiveDevMgrService.getActiveDevice(ApmConst.AudioFeatures.CALL_AUDIO));
        }
        Log.d(TAG, "isActiveDevice returns" + ret);
        return ret;
    }

    public boolean onCallControlPointChangedRequest(int op, int[] call_indices, int count, String dialNumber, BluetoothDevice device ) {
       Log.d(TAG, " onCallControlPointChangedRequest opcode  : " + CCHalConstants.operationToString(op)) ;
       switch(op) {
         case CCHalConstants.BTCC_OP_ACCEPT: {
            setActiveDeviceRemoteTrigger (device);
            CallControl.answerCall(device);
            break;
         }
         case CCHalConstants.BTCC_OP_TERMINATE: {
            int callIndex = call_indices[0];
            Log.d(TAG, "callIndex: " + callIndex);
            CallControl.terminateCall(device, callIndex);
            break;
         }
         case CCHalConstants.BTCC_OP_LOCAL_HLD:{
            int callIndex = call_indices[0];
            int res;
            int idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            Log.d(TAG, "callIndex: " + callIndex);
            if (CallControl.holdCall(device, callIndex) == true) {
                res = CCHalConstants.BTCC_OP_SUCCESS;
                idx = callIndex;
            } else {
                res = CCHalConstants.BTCC_OP_NOT_POSSIBLE;
                idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            }
            updateCallControlResponse(op, idx, res, device);
            break;
         }
         case CCHalConstants.BTCC_OP_LOCAL_RETRIEVE: {
             //Analogus to SWAP as stack would have
             //already validated the input index is in HELD state
            int chld = 2;
            int res;
            int idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            if (CallControl.processChld(device, chld) == true) {
                res = CCHalConstants.BTCC_OP_SUCCESS;
                idx = call_indices[0];
            } else {
                res = CCHalConstants.BTCC_OP_NOT_POSSIBLE;
                idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            }
            updateCallControlResponse(op, idx, res, device);
            break;
         }
         case CCHalConstants.BTCC_OP_ORIGINATE: {
            Log.d(TAG, "Orignate: from Device: " + device + "dialString: " + dialNumber);
            if (dialNumber == null) {
                Log.e(TAG, "null dial string");
                break;
            }
            if (mCallOriginatedDevice != null) {
                Log.d(TAG, "Originate is pending from device: " + mCallOriginatedDevice);
                updateCallControlResponse(op, CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES,
                                          CCHalConstants.BTCC_OP_NOT_POSSIBLE, device);
                break;
            } else {
                setActiveDeviceRemoteTrigger (device);
                String[] result = dialNumber.split(":");
                if (CallControl.dialOutgoingCall(device, result[1]) == true) {
                    mCallOriginatedDevice = device;
                } else {
                    updateCallControlResponse(op, CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES,
                                          CCHalConstants.BTCC_OP_NOT_POSSIBLE, device);
                }
            }
            break;
         }
         case CCHalConstants.BTCC_OP_JOIN: {
             //Stack would have validate to ensure the input indicies
             //are valid candidates for JOIN op
            int chld = 3;
            int res;
            int idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            if (CallControl.processChld(device, chld) == true) {
                res = CCHalConstants.BTCC_OP_SUCCESS;
                idx = call_indices[0];
            } else {
                res = CCHalConstants.BTCC_OP_NOT_POSSIBLE;
                idx = CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES;
            }
            updateCallControlResponse(op, idx, res, device);
            break;
         }
        }
        return true;
    }

    public void onCallControlInitialized(int status) {
       Log.v(TAG, "CallControlInitializedCallback: status=" + status);
       if (status == 0)  {
           //Initialize Telephony and APM related Initialization
           CallControl.listenForPhoneState(PhoneStateListener.LISTEN_SERVICE_STATE|PhoneStateListener.LISTEN_SERVICE_STATE);
           updateContentControlID(CC_CONTENT_CONTROL_ID);
           updateSupportedBearerList("tel");
           updateCallControlOptionalFeatures(CALL_CONTROL_OPTIONAL_FEATURES);
       }
    }


    public void onConnectionStateChanged(BluetoothDevice device, int status) {
       Log.v(TAG, "onConnectionStateChanged: address=" + device.toString());
    }

    private class BondStateChangedReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())) {
                return;
            }
            int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
                                           BluetoothDevice.ERROR);
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            Objects.requireNonNull(device, "ACTION_BOND_STATE_CHANGED with no EXTRA_DEVICE");
            bondStateChanged(device, state);
        }
    }

    void bondStateChanged(BluetoothDevice device, int bondState) {
        if (DBG) {
            Log.d(TAG, "Bond state changed for device: " + device + " state: " + bondState);
        }
        // Remove state machine if the bonding for a device is removed
        if (bondState != BluetoothDevice.BOND_NONE) {
            return;
        }

    }

    private boolean callListContainsDialingCall(ArrayList<CallControlState> listOfValues) {
        boolean ret = false;
        for (CallControlState state : listOfValues) {
            if (state.mState == CCHalConstants.CALL_STATE_DIALING
                || state.mState == CCHalConstants.CALL_STATE_ALERTING) {
                ret = true;
                break;
            }
        }
        return ret;
    }

     /** Handles CCS messages. */
    private final class CcsMessageHandler extends Handler {
        private CcsMessageHandler(Looper looper) {
            super(looper);
        }
         @Override
        public void handleMessage(Message msg) {
           if (DBG) Log.v(TAG, "CcsMessageHandler: received message=" + messageWhatToString(msg.what));
           ArrayList<CallControlState> listOfValues = null;
           switch (msg.what) {
               case UPDATE_BEARER_NAME:
                   String bName = (String)msg.obj;
                   mNativeInterface.updateBearerProviderName(bName);
                   break;
               case UPDATE_BEARER_TECH:
                   int tech_type = (int)msg.arg1;
                   mNativeInterface.updateBearerTechnology(tech_type);
                   break;
               case UPDATE_SIGNAL_STRENGTH:
                   int signal = (int)msg.arg1;
                   mNativeInterface.updateSignalStrength(signal);
                   break;
               case UPDATE_STATUS_FLAGS:
                   int statusFlags = (int)msg.arg1;
                   mNativeInterface.updateStatusFlags(statusFlags);
                   break;
               case UPDATE_BEARERLIST_SUPPORTED :
                   String bSList = (String)msg.obj;
                   mNativeInterface.updateSupportedBearerList(bSList);
                   break;
               case UPDATE_CONTENT_CONTROL_ID:
                   int ccid = (int)msg.arg1;
                   mNativeInterface.contentControlId(ccid);
                   break;
               case UPDATE_CALL_STATE:
                   listOfValues = (ArrayList<CallControlState>)msg.obj;
                   Log.d(TAG, "Call list size : " + listOfValues.size());
                   boolean status = mNativeInterface.callState(listOfValues);
                   if (mCallOriginatedDevice != null && callListContainsDialingCall(listOfValues)) {
                       Log.e(TAG, "push the pending Originate response");
                       //Stack will pick the right index
                       updateCallControlResponse(CCHalConstants.BTCC_OP_ORIGINATE,
                          CCHalConstants.BTCC_DEF_INDEX_FOR_FAILURES,
                          CCHalConstants.BTCC_OP_SUCCESS, mCallOriginatedDevice);
                       mCallOriginatedDevice = null;
                   }
                   break;
               case UPDATE_CALL_CONTROL_OPCODES_SUPPORTED :
                   int feature = (int)msg.arg1;
                   mNativeInterface.callControlOptionalFeatures(feature);
                   break;
               case UPDATE_CALL_CONTROL_RESPONSE :
                   int op = (int)msg.arg1;
                   int ind = (int)msg.arg2;
                   int st = (int)msg.obj;
                   mNativeInterface.callControlResponse(op, ind, st, null);
                   break;
               case UPDATE_INCOMING_CALL :
                   int index = (int)msg.arg1;
                   String uri = (String)msg.obj;
                   mNativeInterface.updateIncomingCall(index, uri);
                   break;
               case PROCESS_PHONE_STATE_CHANGED:
                   getBlcc();
                   break;
               case PROCESS_CALL_STATE:
                   listOfValues = (ArrayList<CallControlState>)msg.obj;
                   processAndUpdateCallState(listOfValues);
                   break;
               case ACTIVE_DEVICE_CHANGED:
                   BluetoothDevice device = (BluetoothDevice)msg.obj;
                   mNativeInterface.setActiveDevice(device,-1);
                   break;
               case EVENT_TYPE_CONNECTION_STATE_CHANGED:
                   break;
               default:
                 Log.e(TAG, "unknown message! msg.what=" + messageWhatToString(msg.what));
                 break;
           }
           Log.v(TAG, "Exit handleMessage");
      }
}

    public static String messageWhatToString(int what) {
        switch (what) {
            case UPDATE_BEARER_NAME :
                return "UPDATE_BEARER_NAME";
            case UPDATE_BEARER_TECH :
                return "UPDATE_BEARER_TECH";
            case UPDATE_SIGNAL_STRENGTH :
                return "UPDATE_SIGNAL_STRENGTH";
            case UPDATE_BEARERLIST_SUPPORTED :
                return "UPDATE_BEARERLIST_SUPPORTED";
            case UPDATE_CONTENT_CONTROL_ID :
                return "UPDATE_CONTENT_CONTROL_ID";
            case UPDATE_CALL_STATE :
                return "UPDATE_CALL_STATE";
            case UPDATE_CALL_CONTROL_OPCODES_SUPPORTED :
                return "UPDATE_CALL_CONTROL_OPCODES_SUPPORTED ";
            case UPDATE_CALL_CONTROL_RESPONSE :
                return "UPDATE_CALL_CONTROL_RESPONSE";
            case UPDATE_INCOMING_CALL  :
                return "UPDATE_INCOMING_CALL";
            case PROCESS_CALL_STATE :
                return "PROCESS_CALL_STATE";
            case UPDATE_STATUS_FLAGS:
                return "UPDATE_STATUS_FLAGS";
            default:
                break;
        }
        return Integer.toString(what);
    }

    /**
     * Binder object: must be a static class or memory leak may occur.
     */

    static class CcBinder extends Binder implements IProfileServiceBinder {
        private CCService mService;

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

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

        CcBinder(CCService svc) {
            mService = svc;
        }

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