Android13 BluetoothHeadsetClient terminateCall流程分析

已于 2024-05-23 20:54:50 修改
阅读量187 收藏 4
点赞数 2
分类专栏： Android Framework Android 蓝牙 文章标签： android
于 2024-05-09 21:39:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuning1985622/article/details/138632917
版权

BluetoothHeadsetClient terminateCall用于挂断电话，代码如下:

//packages/modules/Bluetooth/framework/java/android/bluetooth/BluetoothHeadsetClient.java
public final class BluetoothHeadsetClient implements BluetoothProfile, AutoCloseable {
    public boolean terminateCall(BluetoothDevice device, BluetoothHeadsetClientCall call) {
        if (DBG) log("terminateCall()");
        final IBluetoothHeadsetClient service = getService();
        final boolean defaultValue = false;
        if (service == null) {
            Log.w(TAG, "Proxy not attached to service");
            if (DBG) log(Log.getStackTraceString(new Throwable()));
        } else if (isEnabled() && isValidDevice(device)) {
            try {
                final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();
                service.terminateCall(device, call, mAttributionSource, recv);
                return recv.awaitResultNoInterrupt(getSyncTimeout()).getValue(defaultValue);
            } catch (RemoteException | TimeoutException e) {
                Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable()));
            }
        }
        return defaultValue;
    }
}

调用IBluetoothHeadsetClient的terminateCall，IBluetoothHeadsetClient是一个接口由HeadsetClientService的内部类BluetoothHeadsetClientBinder实现：

//packages/modules/Bluetooth/android/app/src/com/android/bluetooth/hfpclient/HeadsetClientService.java
public class HeadsetClientService extends ProfileService {
    private static class BluetoothHeadsetClientBinder extends IBluetoothHeadsetClient.Stub
            implements IProfileServiceBinder {
        private HeadsetClientService mService;
        @Override
    public boolean terminateCall(BluetoothDevice device, UUID uuid) {
        HeadsetClientStateMachine sm = getStateMachine(device);
        if (sm == null) {
            Log.e(TAG, "SM does not exist for device " + device);
            return false;
        }


        int connectionState = sm.getConnectionState(device);
        if (connectionState != BluetoothProfile.STATE_CONNECTED
                && connectionState != BluetoothProfile.STATE_CONNECTING) {
            return false;
        }


        Message msg = sm.obtainMessage(HeadsetClientStateMachine.TERMINATE_CALL);
        msg.obj = uuid;
        sm.sendMessage(msg);  //发送TERMINATE_CALL消息
        return true;
    }
}

发送TERMINATE_CALL消息，发送的消息会在HeadsetClientStateMachine内部类Connected的processMessage中处理：

//packages/modules/Bluetooth/android/app/srv/com/android/bluetooth/hfpclient/HeadsetClientStateMachine.java
public class HeadsetClientStateMachine extends StateMachine {
    class Connected extends State {
        @Override
        public synchronized boolean processMessage(Message message) {
                case TERMINATE_CALL:
                    terminateCall();
                    break;
            }
        }
    }
}

调用terminateCall方法：

//packages/modules/Bluetooth/android/app/srv/com/android/bluetooth/hfpclient/HeadsetClientStateMachine.java
public class HeadsetClientStateMachine extends StateMachine {
    private final NativeInterface mNativeInterface;
    private void terminateCall() {
        logD("terminateCall");


        int action = HeadsetClientHalConstants.CALL_ACTION_CHUP;


        HfpClientCall c = getCall(HfpClientCall.CALL_STATE_DIALING,
                HfpClientCall.CALL_STATE_ALERTING,
                HfpClientCall.CALL_STATE_ACTIVE); //获取HfpClientCall对象
        if (c == null) {
            // If the call being terminated is currently held, switch the action to CHLD_0
            c = getCall(HfpClientCall.CALL_STATE_HELD);
            action = HeadsetClientHalConstants.CALL_ACTION_CHLD_0;
        }
        if (c != null) {
            if (mNativeInterface.handleCallAction(mCurrentDevice, action, 0)) {
                addQueuedAction(TERMINATE_CALL, action); //添加REJECT_CALL到Action队列
            } else {
                Log.e(TAG, "ERROR: Couldn't terminate outgoing call");
            }
        }
    }
}

调用NativeInterface的handleCallAction方法：

//packages/modules/Bluetooth/android/app/srv/com/android/bluetooth/hfpclient/NativeInterface.java
public class NativeInterface {
    public boolean handleCallAction(BluetoothDevice device, int action, int index) {
        return handleCallActionNative(getByteAddress(device), action, index);
    }
}

调用handleCallActionNative方法，并返回处理结果，handleCallActionNative是Native方法，通过查表调用的是handleCallActionNative方法：

static bthf_client_interface_t* sBluetoothHfpClientInterface = NULL;
//packages/modules/Bluetooth/android/app/jni/com_android_bluetooth_hfpclient.cpp
static jboolean handleCallActionNative(JNIEnv* env, jobject object,
                                       jbyteArray address, jint action,
                                       jint index) {
  std::shared_lock<std::shared_mutex> lock(interface_mutex);
  if (!sBluetoothHfpClientInterface) return JNI_FALSE;


  jbyte* addr = env->GetByteArrayElements(address, NULL);
  if (!addr) {
    jniThrowIOException(env, EINVAL);
    return JNI_FALSE;
  }


  bt_status_t status = sBluetoothHfpClientInterface->handle_call_action(
      (const RawAddress*)addr, (bthf_client_call_action_t)action, (int)index);


  if (status != BT_STATUS_SUCCESS) {
    ALOGE("Failed to enter private mode, status: %d", status);
  }
  env->ReleaseByteArrayElements(address, addr, 0);
  return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
}

调用bthf_client_interface_t的handle_call_action函数，bthf_client_interface_t是个结构体，在bt_hf_client.h中定义，在bt_hf_client.cc中实

//packages/modules/Bluetooth/system/btif/src/bt_hf_client.cc
static bt_status_t handle_call_action(const RawAddress* bd_addr,
                                      bthf_client_call_action_t action,
                                      int idx) {
  btif_hf_client_cb_t* cb = btif_hf_client_get_cb_by_bda(*bd_addr);
  if (cb == NULL || !is_connected(cb)) return BT_STATUS_FAIL;


  CHECK_BTHF_CLIENT_SLC_CONNECTED(cb);


  switch (action) {
    case BTHF_CLIENT_CALL_ACTION_CHLD_0:
      if (cb->chld_feat & BTA_HF_CLIENT_CHLD_REL) {
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 0, 0, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_1:
      // CHLD 1 is mandatory for 3 way calling
      if (cb->peer_feat & BTA_HF_CLIENT_PEER_FEAT_3WAY) {
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 1, 0, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_2:
      // CHLD 2 is mandatory for 3 way calling
      if (cb->peer_feat & BTA_HF_CLIENT_PEER_FEAT_3WAY) {
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 2, 0, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_3:
      if (cb->chld_feat & BTA_HF_CLIENT_CHLD_MERGE) {
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 3, 0, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_4:
      if (cb->chld_feat & BTA_HF_CLIENT_CHLD_MERGE_DETACH) {
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 4, 0, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_1x:
      if (cb->peer_feat & BTA_HF_CLIENT_PEER_ECC) {
        if (idx < 1) {
          return BT_STATUS_FAIL;
        }
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 1, idx, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_CHLD_2x:
      if (cb->peer_feat & BTA_HF_CLIENT_PEER_ECC) {
        if (idx < 1) {
          return BT_STATUS_FAIL;
        }
        BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHLD, 2, idx, NULL);
        break;
      }
      return BT_STATUS_UNSUPPORTED;
    case BTHF_CLIENT_CALL_ACTION_ATA:
      BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_ATA, 0, 0, NULL);
      break;
    case BTHF_CLIENT_CALL_ACTION_CHUP:
      BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_CHUP, 0, 0, NULL);
      break;
    case BTHF_CLIENT_CALL_ACTION_BTRH_0:
      BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_BTRH, 0, 0, NULL);
      break;
    case BTHF_CLIENT_CALL_ACTION_BTRH_1:
      BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_BTRH, 1, 0, NULL);
      break;
    case BTHF_CLIENT_CALL_ACTION_BTRH_2:
      BTA_HfClientSendAT(cb->handle, BTA_HF_CLIENT_AT_CMD_BTRH, 2, 0, NULL);
      break;
    default:
      return BT_STATUS_FAIL;
  }


  return BT_STATUS_SUCCESS;
}

调用BTA_HfClientSendAT方法：

//packages/modules/Bluetooth/system/bta/hf_client/bta_hf_client_api.cc
void BTA_HfClientSendAT(uint16_t handle, tBTA_HF_CLIENT_AT_CMD_TYPE at,
                        uint32_t val1, uint32_t val2, const char* str) {
  tBTA_HF_CLIENT_DATA_VAL* p_buf =
      (tBTA_HF_CLIENT_DATA_VAL*)osi_malloc(sizeof(tBTA_HF_CLIENT_DATA_VAL));


  p_buf->hdr.event = BTA_HF_CLIENT_SEND_AT_CMD_EVT;
  p_buf->uint8_val = at;
  p_buf->uint32_val1 = val1;
  p_buf->uint32_val2 = val2;


  if (str) {
    strlcpy(p_buf->str, str, BTA_HF_CLIENT_NUMBER_LEN + 1);
    p_buf->str[BTA_HF_CLIENT_NUMBER_LEN] = '\0';
  } else {
    p_buf->str[0] = '\0';
  }


  p_buf->hdr.layer_specific = handle;


  bta_sys_sendmsg(p_buf);
}

在之后就是蓝牙协议栈相关内容，在这里就不再分析了。

一个学渣的自我救赎
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 蓝牙连接配对流程源码分析（1）-流程分析
手机-手表蓝牙开发工程师的博客
04-14 2578
蓝牙的连接流程分为9个步骤，如下图所示，在这9个步骤中，实线的步骤是必选的，虚线是可选的，接下来我们就来分析下。蓝牙A2dp hfp opp rfcomm pbap sdp l2cap源代码流程图，请点击下面链接
Android 蓝牙 连接配对流程详细分析-史上最全文档
手机-手表蓝牙开发工程师的博客
04-15 7855
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程图-点击下载 Android 蓝牙配对连接源码分析文档大全-点击下载 1、此篇文档主要对经典蓝牙的扫描配对连接流程进行了分析，并通过实际的耳机配对连接手表的例子进行梳理。主要目的是通过该文档学习，对蓝牙的扫描配对流程有一个清晰的认识。在项目中遇到相关问题，知道从哪方面去入手分析。 2.1Inquiry概念简介 搜索Inquiry顾名思义就是检测和收集周围环境中的蓝牙设备，根据询问的方式可分为......
Android9 蓝牙开发学习（4）——BluetoothHeadsetClient
geniushorse的博客
09-16 4050
BluetoothHeadsetClient 主要实现HFP协议，主要实现拨打、接听、挂断电话（AG侧、HF侧）、切换声道功能。 AG（Audio Gate）音频网关—音频设备输入输出网关 。 HF（Hands Free）免提—该设备作为音频网关的远程音频输入/输出机制，并可提供若干遥控功能。 在车载蓝牙中，手机侧是AG，车载蓝牙侧是HF，在android源代码中，将AG侧称为HFP/AG，将HF侧称为HFPClient/HF。 BluetoothHeadsetClient初始化 // A code blo
通话状态监听-Android13
许浑的博客
12-17 2275
处于无电话活动，相当于电话挂断，不过要先有。主要查看 framework.jar。
Android13 BluetoothHeadsetClient rejectCall流程分析
最新发布
liuning1985622的博客
05-09 228
在之后就是蓝牙协议栈相关内容，在这里就不再分析了。
Android13 BluetoothHeadsetClient dial流程分析
liuning1985622的博客
05-09 873
上面方法主要处理如下：1、创建HfpClientCall对象，HfpClientCall是一个电话实体类信息。该类包含了电话的各种信息，例如电话号码、呼叫状态、通话时间等等。2、发送DIAL_NUMBER消息到HeadsetClientStateMachine状态机。
总结篇：蓝牙开发
万子的博客
09-14 2296
开发维护蓝牙项目已经18个月了，在此做一下总结 蓝牙的开发流程 先以原生的芯片为例，直接通过BluetoothAdapterenable()打开蓝牙 → startDiscovery()开始搜索→ 通过广播接收（action：BluetoothDevice.ACTION_FOUND）找到设备 →getName()获取本地蓝牙名称→getAddress()获取本地蓝牙地址→开始createBond配对→成功之后连接蓝牙 之后就可以正常使用蓝牙功能（蓝牙电话，蓝牙音乐） 一般大公司开发都会有提供蓝牙芯..
Android蓝牙系统框架和代码架构
潇让的博客
12-13 7352
Android蓝牙系统框架和代码架构
Android 13 Wi-Fi状态机流程及Log分析
weixin_51894735的博客
11-26 1726
本文基于Android 13源码解读，对Wi-Fi状态机调用流程进行梳理，并结合Log进行分析，便于大家理解Wi-Fi模块调用流程。
Android Keyguard 亮灭屏流程分析
小码快跑
11-04 2181
文章目录开篇Power灭屏 开篇 PowerManagerService（PMS） 中定义了四种屏幕状态： awake：唤醒状态 dream：屏保状态 doze sleep：休眠状态 Power灭屏 按下Power键时，PhoneWindowManager 接收到按键事件，处理Power键 interceptPowerKeyUp抬起事件时，开始了灭屏流程： powerPress ·· ...
Android 7.0系统启动流程分析
热门推荐
Floating Cat
02-27 1万+
简单的分析Android 7.0系统启动流程
HFP：不活跃的车载设备在打电话时，不能挂断电话
潇让的博客
08-31 648
Android P：Only active device can hung up call . 非 active device 不能挂断电话。 step1：车载先连接 手机 step2：蓝牙耳机再连接手机 step3：辅助机电话呼叫测试机 现象：车载接听和挂断电话按钮触摸无效，蓝牙耳机正常。 原因： ...
Android9 蓝牙开发学习（6）——蓝牙各种广播监听
geniushorse的博客
09-16 2083
蓝牙开关状态变化 BluetoothAdapter.ACTION_STATE_CHANGED if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR); switch (state) { case BluetoothAdap
蓝牙通话功能源码解析
Jack的博客
09-20 8043
3 蓝牙耳机服务 在打开蓝牙过程中,会开启一些对应的服务,在此只将和通话相关的一个服务, HeadsetClientService。手机上只有开启了这个服务,才可以将该手机当作一个蓝牙耳机,通话时声音才可以传输过来。 3.1 准备 首先在启动apk时,会首先启动该apk的Application,然后才是其它组件,因此, Application可以进行一些初始化的操作。Bluetooth.ap
android-hfpclient-电话功能
nilingxi的专栏
07-30 1721
HeadsetClientService: connect –连接 电话操作和状态 bluedroid 对应的电话操作 typedef enum { BTHF_CLIENT_CALL_ACTION_CHLD_0 = 0,//held call release Releases all held calls or sets User Determined User Bus...
蓝牙协议
qq_42171683的博客
05-21 3232
蓝牙相关: 1.蓝牙连接的设备: UI侧 在BtHelper:执行getHFPConnectedAddress,调用BTManager.hfpGetConnectedDevices()触发蓝牙连接 BT侧 BTManager调用BluetoothHeadsetClient.getConnectedDevices(),通过IBluetoothHeadsetClient aidl文件客户端去调用服务端, 调用IBluetoothHeadsetClient服务端HeadsetClientService的getCo
蓝牙之十二-HFP app层
shichaog的专栏
08-23 5123
在android6中，HFP的app层代码位于： /packages/apps/Bluetooth/src/com/android/bluetooth/hfpclient 配置使能代码位于 bool name="profile_supported_hs_hfp">truebool> bool name="profile_supported_hfpclient">true
android 中关于Phone的ACTION_CALL、ACTION_CALL_PRIVILEGED、ACTION_DIAL的区别
shiskyer的专栏
11-30 4245
系统拨打电话可以调用action如下： ACTION_CALL（普通）， ACTION_CALL_EMERGENCY （紧急电话）， ACTION_CALL_PRIVILEGED（系统专属）， 而普通应用要拨打电话只能调用ACTION_CALL。 ACTION_CALL 根据指定的数据执行一次呼叫，不能用于紧急呼叫。 ACTION_CALL_PRIVILEGED 系统专属，是个pri
Android 运行时权限（危险权限）
sky的博客
05-30 1万+
一、说明Android 6.0开始，Google将权限分为两类，一类是Normal Permission, 这类权限一般不涉及用户隐私，是不需要用户进行授权的，比如手机震动、访问网络等；另一类是Dangerous Permission，一般是涉及到用户隐私的，需要用户进行授权，比如读取sdcard、访问通讯录等。二、危险权限列表下表列出了Android所有的危险权限，剩余的权限就都是普通权限需注意...
Android13 MO拨号流程分析及更新步骤详解
需要注意的是，虽然该流程已经被分析和总结，但由于Android系统的不断更新和迭代，拨号流程可能还会有所变化和优化。因此，开发人员需要及时了解最新的开发文档和技术资料，以确保应用程序能够适应最新的系统变化，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值