前言
电话子系统各子模块业务比较繁杂，本文解析梳理的侧重点不是理清电话子系统详细业务流程，重点是明晰ui层（js或ets）到modem层各类节点的框架交互衔接。具体以拨号为引子梳理代码是如何从js层到达厂商库的。源码追踪中使用的是OpenHarmony 3.1Beta版本。
源码流程分析中粗略的穿插梳理了以下知识点：
- js接口层如何与js UI界面对接
- js接口层对上提供的服务从哪里来
- Napi接口提供了哪些服务输出
- Napi接口的服务从哪里来
- 以callmanager为例，介绍client通过何种形式与service通讯
- SA服务配置文件在哪，有哪些配置项，怎么对外提供服务的
- 介绍一下提供服务时的IPC序列化和反序列化怎么使用
- 以modem HDF驱动介绍一下UHDF驱动的配置以及怎么对外提供服务
- coreservice层怎么使用的HDF
- HDF服务怎么与厂商库业务代码打通
概述
电话子系统为OpenHarmony系统提供基础的通信功能，包括CS域的语音短信业务，PS域的多媒体消息、数据业务，SIM管理，network驻网管理和RIL的业务等。
下面将以打电话的拨号（Dial指令）指令为引子，通过代码追踪向大家介绍JS UI层指令是如何一层一层到达modem的。
电话子系统在OpenHarmony框架中的位置图
源码位于源码根目录下的base/telephony/：
电话子系统通话管理主流程图以及分层说明
通话模块->蜂窝模块->coreservice模块->riladapter以及厂商库模块
通话模块：
蜂窝模块：
CoreService模块：
riladapter以及厂商库模块：
分层说明：APP（js应用）->callservice层（上层业务层：权限判断，铃音，蓝牙，视频，cs域、ps域、OTT语音电话分类分发等）->CellularCall（蜂窝业务层：针对蜂窝业务相关：GSM，CDMA，IMS等）->coreService（电话设备管理：电话卡，驻网，短彩信，RIL层等等）->hril层（HDF驱动交互，电话子系统对厂商库接口的统一抽象层）->vendorlib层（厂商库层，针对不同modem可替换）->modem芯片层（手机modem硬件，里面有各厂商固化的协议、以及功能固件）
代码仓库模块分类简介：
call_manager:管理各种类型的通话连接
status registry:实现APP对telephony相关状态信息的管理
sms_mms:负责短彩信相关功能
core_service:电话基础服务模块主要功能实现实现各模块与RIL Adapter进行交互对接
ril_adapter:无线接入适配层，抽象统一底层厂商库对上提供的接口，并负责与modem通信
data_storage:负责telephony持久化数据存储，提供DataAbility访问接口
cellular_data：负责建立蜂窝数据连接
CellularCall：负责运营商网络的基础通话实现
Dial文件关联以及流程解析
1.js接口层
1.1 js接口层的库文件在哪里，怎么编译安装到系统的
./system/lib/module/telephony/libcall.z.so
//这里有一点说明就是追踪OpenHarmony代码时，build.gn中的ohos_shared_library("call") 对应的so名称要添加上lib和.z.so，直接搜索call.so是搜索不到的
编译以及安装位置：call_manager\frameworks\js\BUILD.gn
1.2 js模块怎么被加载，加载时怎么注册接口以及init，init做了什么
js层：import call from '@ohos.telephony.call';
js接口层：
call_manager\frameworks\js\napi\src\napi_call_manager.cpp
extern "C" __attribute__((constructor)) void RegisterModule(void)
{//__attribute__((constructor))在main函数之前运行的，因为这个js UI所在的进程调用了这个js接口库，这个函数在js UI所在的进程的main函数启动之前运行
napi_module_register(&g_nativeCallManagerModule);
}
static napi_module g_nativeCallManagerModule = {
.nm_version = NATIVE_VERSION,
.nm_flags = NATIVE_FLAGS,
.nm_filename = nullptr,
.nm_register_func = NapiCallManager::RegisterCallManagerFunc,//import call from '@ohos.telephony.call'执行导入时先执行这个函数
.nm_modname = "telephony.call",
.nm_priv = ((void *)0),
.reserved = {0},
};
napi_value NapiCallManager::RegisterCallManagerFunc(napi_env env, napi_value exports)
{
// Interface initialization
DeclareCallBasisInterface(env, exports);//在这个函数里将napi的Dial函数封装成js层能调用的函数接口
DeclareCallConferenceInterface(env, exports);
DeclareCallSupplementInterface(env, exports);
DeclareCallExtendInterface(env, exports);
DeclareCallMultimediaInterface(env, exports);
// Enumeration class initialization
DeclareCallMediaEnum(env, exports);
DeclareCallDialEnum(env, exports);//在这里封装napi的Dial函数参数以及枚举类型为js层形式的属性
DeclareCallStateEnum(env, exports);
DeclareCallEventEnum(env, exports);
DeclareCallRestrictionEnum(env, exports);
DeclareCallWaitingEnum(env, exports);
DeclareCallTransferEnum(env, exports);
DeclareCallImsInterface(env, exports);
// Enumeration class extension initialization
DeclareAudioDeviceEnum(env, exports);
DeclareVideoStateTypeEnum(env, exports);
DeclareImsCallModeEnum(env, exports);
DeclareDialSceneEnum(env, exports);
DeclareCallTypeEnum(env, exports);
DeclareDialTypeEnum(env, exports);
DeclareTelCallStateEnum(env, exports);
DeclareConferenceStateEnum(env, exports);
DeclareCallStateToAppEnum(env, exports);
DeclareCallEventEnumEx(env, exports);
DeclareRestrictionTypeEnum(env, exports);
DeclareRestrictionModeEnum(env, exports);
DeclareRestrictionStatusEnum(env, exports);
DeclareCallWaitingEnumEx(env, exports);
DeclareTransferStatusEnum(env, exports);
DeclareTransferTypeEnum(env, exports);
DeclareTransferSettingTypeEnum(env, exports);
Init();//创建客户端去连接CallManagerSA服务
return exports;
}
void Init()
{
// Establish a connection with call_manager
DelayedSingleton<CallManagerClient>::GetInstance()->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
}
用到了CallManagerClient去获取callmanagerSA服务
1.3 CallManagerClient从哪里引入
call_manager\frameworks\js\BUILD.gn
ohos_shared_library("call") {
sources = [
"napi/src/napi_call_ability_callback.cpp",
"napi/src/napi_call_manager.cpp",
"napi/src/napi_call_manager_callback.cpp",
"napi/src/napi_call_manager_utils.cpp",
]
configs = [ "//base/telephony/core_service/utils:telephony_log_config" ]
public_configs = [ ":call_manager_js_config" ]
deps = [
"//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native",
"//foundation/ace/napi:ace_napi",
"//third_party/libuv:uv_static",
"//utils/native/base:utils",
]
external_deps = [
"ability_base:want",
"ability_runtime:ability_manager",
"bundle_framework:appexecfwk_base",
"bundle_framework:appexecfwk_core",
"call_manager:tel_call_manager_api",//这里引入CallManagerClient，tel_call_manager_api就是NAPI 接口层库，js接口层库是针对js特性，对NAPI 接口层的再封装。
"core_service:tel_core_service_api",
"eventhandler:libeventhandler",
"ipc:ipc_core",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
]
2.NAPI 接口层
NAPI 接口层的库文件在哪里，怎么编译安装到系统的，怎么使用NAPI开发
./system/lib/module/libtel_call_manager_api.z.so
call_manager\frameworks\native\BUILD.gn
通过call_manager\interfaces\innerkits\call_manager_client.h头文件导入接口函数，来做NAPI开发
DelayedSingleton<CallManagerClient>::GetInstance()- >Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
用到了CallManagerClient去获取callmanagerSA服务
3.接口归一，CallManager客户端以及代理层
3.1 JS层接口是对NAPI层接口的再封装，最终都通过CallManagerClient::Init(int32_t systemAbilityId)创建代理
call_manager\frameworks\native\src\call_manager_client.cpp
void CallManagerClient::Init(int32_t systemAbilityId)
{
if (g_callManagerProxy == nullptr) {
g_callManagerProxy = DelayedSingleton<CallManagerProxy>::GetInstance();
if (g_callManagerProxy == nullptr) {
TELEPHONY_LOGE("g_callManagerProxy is nullptr");
return;
}
g_callManagerProxy->Init(systemAbilityId);
}
TELEPHONY_LOGI("CallManagerClient init success!");
}
这里调用到了CallManagerProxy： g_callManagerProxy->Init(systemAbilityId);
3.2、通过代理去连接CallManagerSA服务
call_manager\frameworks\native\src\call_manager_proxy.cpp
void CallManagerProxy::Init(int32_t systemAbilityId)//该函数调用ConnectService()去连接一个CallManagerSA服务
int32_t CallManagerProxy::ConnectService()
{
Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
if (callManagerServicePtr_ != nullptr) {
return TELEPHONY_SUCCESS;
}
sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
//获取SA服务管理器对象
if (managerPtr == nullptr) {
TELEPHONY_LOGE("GetSystemAbilityManager failed!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
sptr<ICallManagerService> callManagerServicePtr = nullptr;
sptr<IRemoteObject> iRemoteObjectPtr = managerPtr->GetSystemAbility(systemAbilityId_);
//SA服务管理器对象通过SA服务id，拿到一个能与该SA服务交互的RemoteObject。
if (iRemoteObjectPtr == nullptr) {
TELEPHONY_LOGE("GetSystemAbility failed!");
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
callManagerServicePtr = iface_cast<ICallManagerService>(iRemoteObjectPtr);
if (!callManagerServicePtr) {
TELEPHONY_LOGE("iface_cast<ICallManagerService> failed!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
callManagerServicePtr_ = callManagerServicePtr;
return TELEPHONY_SUCCESS;
}
4.CallManagerSA服务的配置、建立与使用
4.1 SA服务ID定义
foundation\distributedschedule\samgr\interfaces\innerkits\samgr_proxy\include\system_ability_definition.h
TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID：4005
system_ability_definition.h头文件中定义有各种SA服务的ID枚举值。
服务对应的配置文件名：SA id值结合.xml扩展名；例如：4005.xml。
4.2 sa_profile编译构建与配置文件
call_manager\sa_profile\BUILD.gn
call_manager\sa_profile\4005.xml
<info>
<process>foundation</process>
<systemability> <!-- Declare a system ability and its profile -->
<name>4005</name> <!-- Declare the id of system ability. Must be same with system_ability_definition.h -->
<libpath>libtel_call_manager.z.so</libpath>
<run-on-create>true</run-on-create> <!-- "true" means the system ability would start immediately, "false" means the system ability would start on demand. -->
<distributed>false</distributed> <!-- "true" means the system ability supports distributed scheduling while "false" is not. -->
<dump-level>1</dump-level> <!-- Declare the dump level. 1-high; 2-media; 3-low -->
</systemability>
</info>
4.3 SA服务注册创建
call_manager\services\call_manager_service\src\call_manager_service.cpp
const bool g_registerResult =
SystemAbility::MakeAndRegisterAbility(DelayedSingleton<CallManagerService>::GetInstance().get());
CallManagerService::CallManagerService()
: SystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID, true), callControlManagerPtr_(nullptr)
{}
上面创建callmanagerSA服务
4.4 通过CallManagerProxy调用服务接口
举例：下面使用callmanagerSA服务的DialCall接口：
call_manager\frameworks\native\src\call_manager_proxy.cpp
int32_t CallManagerProxy::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
{
if (ReConnectService() != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("ipc reconnect failed!");
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
std::lock_guard<std::mutex> lock(mutex_);
int32_t errCode = callManagerServicePtr_->DialCall(number, extras);//跳转到callManagerServiceProxy类里的DialCall函数
if (errCode != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("DialCall failed, errcode:%{public}d", errCode);
return errCode;
}
return TELEPHONY_SUCCESS;
}
送到callManagerServiceProxy：
5. SA服务过程中的IPC数据序列化与反序列
5.1 序列化数据通过远端对象发送信息到SA服务端
callManagerServicePtr_->DialCall(number, extras);
call_manager\frameworks\native\src\call_manager_service_proxy.cpp
int32_t CallManagerServiceProxy::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
{
MessageOption option;
MessageParcel dataParcel;
MessageParcel replyParcel;
//对下发的参数数据进行IPC序列化
if (!dataParcel.WriteInterfaceToken(CallManagerServiceProxy::GetDescriptor())) {
TELEPHONY_LOGE("write descriptor fail");
return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
}
if (number.empty()) {
TELEPHONY_LOGE("number is empty");
return TELEPHONY_ERR_ARGUMENT_INVALID;
}
dataParcel.WriteString16(number);
dataParcel.WriteInt32(extras.GetIntValue("accountId"));
dataParcel.WriteInt32(extras.GetIntValue("videoState"));
dataParcel.WriteInt32(extras.GetIntValue("dialScene"));
dataParcel.WriteInt32(extras.GetIntValue("dialType"));
dataParcel.WriteInt32(extras.GetIntValue("callType"));
if (Remote() == nullptr) {
TELEPHONY_LOGE("function Remote() return nullptr!");
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
//调用远端对象的SendRequest函数将请求以及相应的参数通过IPC发送出去
int32_t error = Remote()->SendRequest(INTERFACE_DIAL_CALL, dataParcel, replyParcel, option);
if (error != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("function DialCall call failed! errCode:%{public}d", error);
return error;
}
return replyParcel.ReadInt32();//返回IPC对端反馈的返回码
}
5.2 数据到达callManagerServiceSA服务层STUB,反序列化并拆解成对应到具体函数处理通道
call_manager\services\call_manager_service\src\call_manager_service_stub.cpp
//当有数据从IPC发送过来以后，IPC会调用CallManagerServiceStub端的OnRemoteRequest函数;
int32_t CallManagerServiceStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
std::u16string myDescriptor = CallManagerServiceStub::GetDescriptor();
std::u16string remoteDescriptor = data.ReadInterfaceToken();
if (myDescriptor != remoteDescriptor) {
TELEPHONY_LOGE("descriptor checked fail !");
return TELEPHONY_ERR_DESCRIPTOR_MISMATCH;
}
TELEPHONY_LOGI("OnReceived, cmd = %{public}u", code);
auto itFunc = memberFuncMap_.find(code);//通过请求类型枚举值关键字在memberFuncMap_找请求类型对应的处理函数：
if (itFunc != memberFuncMap_.end()) {
auto memberFunc = itFunc->second;
if (memberFunc != nullptr) {
return (this->*memberFunc)(data, reply);//找请求类型对应的处理函数后调用该函数
}
}
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
void CallManagerServiceStub::InitCallBasicRequest()
{
//初始化请求类型枚举值与请求类型处理函数一一对应的memberFuncMap_
memberFuncMap_[INTERFACE_REGISTER_CALLBACK] = &CallManagerServiceStub::OnRegisterCallBack;
memberFuncMap_[INTERFACE_UNREGISTER_CALLBACK] = &CallManagerServiceStub::OnUnRegisterCallBack;
memberFuncMap_[INTERFACE_DIAL_CALL] = &CallManagerServiceStub::OnDialCall;//DIAL_CALL对应于OnDialCall
memberFuncMap_[INTERFACE_ANSWER_CALL] = &CallManagerServiceStub::OnAcceptCall;
memberFuncMap_[INTERFACE_REJECT_CALL] = &CallManagerServiceStub::OnRejectCall;
memberFuncMap_[INTERFACE_HOLD_CALL] = &CallManagerServiceStub::OnHoldCall;
memberFuncMap_[INTERFACE_UNHOLD_CALL] = &CallManagerServiceStub::OnUnHoldCall;
memberFuncMap_[INTERFACE_DISCONNECT_CALL] = &CallManagerServiceStub::OnHangUpCall;
memberFuncMap_[INTERFACE_GET_CALL_STATE] = &CallManagerServiceStub::OnGetCallState;
memberFuncMap_[INTERFACE_SWAP_CALL] = &CallManagerServiceStub::OnSwitchCall;
}
int32_t CallManagerServiceStub::OnDialCall(MessageParcel &data, MessageParcel &reply)
{
int32_t result = TELEPHONY_ERR_FAIL;
AppExecFwk::PacMap dialInfo;
//IPC反序列化数据，并将OnDialCall中的数据组织到dialInfo中
std::u16string callNumber = data.ReadString16();
dialInfo.PutIntValue("accountId", data.ReadInt32());
dialInfo.PutIntValue("videoState", data.ReadInt32());
dialInfo.PutIntValue("dialScene", data.ReadInt32());
dialInfo.PutIntValue("dialType", data.ReadInt32());//这里带有拨号类型，用于后面的拨号策略判定
dialInfo.PutIntValue("callType", data.ReadInt32());
dialInfo.PutStringValue("bundleName", data.ReadString());
if (callNumber.length() > ACCOUNT_NUMBER_MAX_LENGTH) {
TELEPHONY_LOGE("the account number length exceeds the limit");
return CALL_ERR_NUMBER_OUT_OF_RANGE;
}
result = DialCall(callNumber, dialInfo);//调用CallManagerService里的DialCall函数，CallManagerService是CallManagerServiceStub的子类
TELEPHONY_LOGI("result:%{public}d", result);
if (!reply.WriteInt32(result)) {
TELEPHONY_LOGE("fail to write parcel");
return TELEPHONY_ERR_WRITE_REPLY_FAIL;
}
return result;
}
6. 被反序列化的数据到达SA服务中进行权限判断，根据业务进行处理通道的具体分配
6.1 到达callManagerServiceSA服务层，进行权限判断检查
call_manager\services\call_manager_service\src\call_manager_service.cpp
int32_t CallManagerService::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
{
int32_t uid = IPCSkeleton::GetCallingUid();
std::string bundleName = "";
TelephonyPermission::GetBundleNameByUid(uid, bundleName);
extras.PutStringValue("bundleName", bundleName);
if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {//权限判断
TELEPHONY_LOGE("Permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
if (callControlManagerPtr_ != nullptr) {
return callControlManagerPtr_->DialCall(number, extras);//调用CallControlManager::DialCall
} else {
TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
}
6.2 整理传入的DialCall参数：包括号码是否是紧急号码，处理拨号策略
call_manager\services\call\src\call_control_manager.cpp
int32_t CallControlManager::DialCall(std::u16string &number, AppExecFwk::PacMap &extras)
{
int32_t errorCode = TELEPHONY_ERR_FAIL;
sptr<CallBase> callObjectPtr = nullptr;
std::string accountNumber(Str16ToStr8(number));
int32_t ret = NumberLegalityCheck(accountNumber);
if (ret != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("Invalid number!");
return ret;
}
bool isEcc = DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(
accountNumber, extras.GetIntValue("accountId"), errorCode);
ret = DialPolicy(number, extras, isEcc);//处理拨号策略
if (ret != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("dial policy result：%{public}d", ret);
return ret;
}
// temporarily save dial information
{
std::lock_guard<std::mutex> lock(mutex_);//这里加互斥锁写入保护，而DialCall事件被发送到EventRunner线程，被这个线程处理时取数据调用GetDialParaInfo时再加互斥锁进行读取保护，两个线程共用这段数据，所以要加互斥锁
dialSrcInfo_.callId = ERR_ID;
dialSrcInfo_.number = accountNumber;
dialSrcInfo_.isDialing = true;
dialSrcInfo_.isEcc = isEcc;
dialSrcInfo_.callType = (CallType)extras.GetIntValue("callType");
dialSrcInfo_.accountId = extras.GetIntValue("accountId");
dialSrcInfo_.dialType = (DialType)extras.GetIntValue("dialType");
dialSrcInfo_.videoState = (VideoStateType)extras.GetIntValue("videoState");
dialSrcInfo_.bundleName = extras.GetStringValue("bundleName");
extras_.Clear();
extras_ = extras;
}
if (callRequestHandlerServicePtr_ == nullptr) {
TELEPHONY_LOGE("callRequestHandlerServicePtr_ is nullptr!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
ret = callRequestHandlerServicePtr_->DialCall();//调用CallRequestHandlerService::DialCall
if (ret != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("DialCall failed!");
return ret;
}
return TELEPHONY_SUCCESS;
}
6.3 创建一个新的线程CallRequestHandler来处理call相关业务，可以支持事情排队优先级
base\telephony\call_manager\services\call\src\call_request_handler.cpp
void CallRequestHandlerService::Start()
{
eventLoop_ = AppExecFwk::EventRunner::Create("CallRequestHandler");//<AppExecFwk::EventRunner>指针
if (eventLoop_.get() == nullptr) {
TELEPHONY_LOGE("failed to create EventRunner");
return;
}
handler_ = std::make_shared<CallRequestHandler>(eventLoop_);//创建事件线程eventLoop_的EventHandler事件处理器
if (handler_.get() == nullptr) {
TELEPHONY_LOGE("failed to create CallRequestHandler");
return;
}
handler_->Init();//对事件处理器进行初始化
eventLoop_->Run();//执行run循环接收发送过来的事件并分发到对应的事件处理器CallRequestHandler去处理
return;
}
6.4 采用SendEvent方式将指令发送到call相关事件处理线程
int32_t CallRequestHandlerService::DialCall()
{
if (handler_.get() == nullptr) {
TELEPHONY_LOGE("handler_ is nullptr");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
if (!handler_->SendEvent(HANDLER_DIAL_CALL_REQUEST)) {//发送给EventRunner线程eventLoop_来处理
TELEPHONY_LOGE("send dial event failed!");
return CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE;
}
return TELEPHONY_SUCCESS;
}
6.5 call相关事件处理线程对DialCallEvent的处理
上面发出的event会被同一个文件中的CallRequestHandler类捕获，触发ProcessEvent处理（转换了线程，可以对到这里的call事件进行优先级排队）。
memberFuncMap会根据event的id从memberFuncMap_拿到对应的memberFunc，然后进入对应的处理函数DialCallEvent：
void CallRequestHandler::DialCallEvent(const AppExecFwk::InnerEvent::Pointer &event)
{
if (event == nullptr) {
TELEPHONY_LOGE("CallRequestHandler::ProcessEvent parameter error");
return;
}
if (callRequestProcessPtr_ == nullptr) {
TELEPHONY_LOGE("callRequestProcessPtr_ is nullptr");
return;
}
callRequestProcessPtr_->DialRequest();//调用CallRequestProcess::DialRequest函数
}
6.6 根据拨号类型转换为2G cs域Dial，判断是4G运营商ip域多媒体Dial，还是OTT（over the top等应用通话）等Dial业务
如果是用到运营商蜂窝基站来打电话，还要蜂窝通话的核心服务CoreServiceConnection会被拉起来
call_manager\services\call\src\call_request_process.cpp
void CallRequestProcess::DialRequest()
{
DialParaInfo info;
DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(info);//这里面会加互斥锁然后获取另一个线程写入的参数信息
if (!info.isDialing) {
TELEPHONY_LOGE("the device is not dialing!");
return;
}
if (info.dialType == DialType::DIAL_CARRIER_TYPE) {
std::vector<std::u16string> fdnNumberList =
DelayedSingleton<CoreServiceConnection>::GetInstance()->GetFdnNumberList(info.accountId);
if (!fdnNumberList.empty() && !IsFdnNumber(fdnNumberList, info.number)) {
CallEventInfo eventInfo;
(void)memset_s(eventInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen);
eventInfo.eventId = CallAbilityEventId::EVENT_INVALID_FDN_NUMBER;
(void)memcpy_s(eventInfo.phoneNum, kMaxNumberLen, info.number.c_str(), info.number.length());
DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
TELEPHONY_LOGW("invalid fdn number!");
return;
}
}
TELEPHONY_LOGI("dialType:%{public}d", info.dialType);
switch (info.dialType) {//根据拨号类型分发到不同的分支进行处理，这里以2G CS域电话拨号为例进行分析
case DialType::DIAL_CARRIER_TYPE:
CarrierDialProcess(info);//2G CS域电话拨号
break;
case DialType::DIAL_VOICE_MAIL_TYPE:
VoiceMailDialProcess(info);
break;
case DialType::DIAL_OTT_TYPE:
OttDialProcess(info);
break;
default:
TELEPHONY_LOGE("invalid dialType:%{public}d", info.dialType);
break;
}
}
6.7 2G cs域Dial是怎么转到运营商CellularCall业务（蜂窝通话里还要处理gsm,CDMA等这些信息）处理的
2G cs域Dial，还是4G运营商ip域多媒体Dial最后都会转到手机蜂窝基站连接处理相关部分区
void CallRequestProcess::CarrierDialProcess(DialParaInfo &info)
{
CellularCallInfo callInfo;
int32_t ret = PackCellularCallInfo(info, callInfo);
if (ret != TELEPHONY_SUCCESS) {
TELEPHONY_LOGW("PackCellularCallInfo failed!");
}
// Obtain gateway information
ret = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(callInfo);//转到CellularCallConnection
if (ret != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("Dial failed!");
return;
}
}
base\telephony\call_manager\services\telephony_interaction\src\cellular_call_connection.cpp
int CellularCallConnection::Dial(const CellularCallInfo &callInfo)
{
if (ReConnectService() != TELEPHONY_SUCCESS) {//判断CellularCallConnection这边是否有连接到CellularCall SA服务端，没有则会去连接
TELEPHONY_LOGE("ipc reconnect failed!");
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
std::lock_guard<std::mutex> lock(mutex_);
TELEPHONY_LOGI("callType:%{public}d", callInfo.callType);
int errCode = cellularCallInterfacePtr_->Dial(callInfo);//通过远端对象调用Dial
if (errCode != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("dial failed, errcode:%{public}d", errCode);
return errCode;
}
return TELEPHONY_SUCCESS;
}
int32_t CellularCallConnection::ReConnectService()
{
#ifdef CELLULAR_SUPPORT
if (cellularCallInterfacePtr_ == nullptr) {
TELEPHONY_LOGI("try to reconnect cellular call service now...");
int32_t result = ConnectService();
if (result != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("Connect service: %{public}d", result);
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
}
#endif
return TELEPHONY_SUCCESS;
}
6.8 CellularCallConnection::ReConnectService()创建了连接cellular_callSA服务的远端对象（CellularCallProxy代理）
int32_t CellularCallConnection::ConnectService()
{//与cellular_callSA服务通讯前先连接它，获取能与它通讯的远端对象
Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
if (cellularCallInterfacePtr_ != nullptr) {
return TELEPHONY_SUCCESS;
}
//获取系统的SA服务管理器
sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (managerPtr == nullptr) {
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
sptr<CellularCallInterface> cellularCallInterfacePtr = nullptr;
//使用系统的SA服务管理器通过SA ID获取能与这个SA服务端通讯的远端对象
sptr<IRemoteObject> iRemoteObjectPtr = managerPtr->GetSystemAbility(systemAbilityId_);
if (iRemoteObjectPtr == nullptr) {
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
cellularCallInterfacePtr = iface_cast<CellularCallInterface>(iRemoteObjectPtr);
if (!cellularCallInterfacePtr) {
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::weak_ptr<CellularCallConnection> weakPtr = shared_from_this();
auto deathCallback = [weakPtr](const wptr<IRemoteObject> &object) {
auto sharedPtr = weakPtr.lock();
if (sharedPtr) {
sharedPtr->OnDeath();
}
};
cellularCallRecipient_ = (std::make_unique<CellularCallDeathRecipient>(deathCallback)).release();
if (cellularCallRecipient_ == nullptr) {
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
if (!iRemoteObjectPtr->AddDeathRecipient(cellularCallRecipient_)) {
return TELEPHONY_ERR_ADD_DEATH_RECIPIENT_FAIL;
}
cellularCallInterfacePtr_ = cellularCallInterfacePtr;
int32_t ret = RegisterCallBackFun();
if (ret != TELEPHONY_SUCCESS) {
return ret;
}
connectState_ = true;
return TELEPHONY_SUCCESS;
}
6.9 通过cellular_call SA服务的远端对象发出了Dial信息
int CellularCallConnection::Dial(const CellularCallInfo &callInfo)
{
if (ReConnectService() != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("ipc reconnect failed!");
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
std::lock_guard<std::mutex> lock(mutex_);
TELEPHONY_LOGI("callType:%{public}d", callInfo.callType);
int errCode = cellularCallInterfacePtr_->Dial(callInfo);//调用CellularCallProxy::Dial
if (errCode != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("dial failed, errcode:%{public}d", errCode);
return errCode;
}
return TELEPHONY_SUCCESS;
}
6.10 通过CellularCallProxy的序列化后发送出Dial信息
如何跳转到cellular_callSA服务，通过class CellularCallProxy : public IRemoteProxy<CellularCallInterface>
call_manager\services\telephony_interaction\include\cellular_call_interface.h
call_manager\services\telephony_interaction\include\cellular_call_proxy.h
通过CellularCallConnection::ConnectService()获取到SA服务的远端对象（proxy）。
通过远端对象的IPC通讯与CellularCallservice打通联系：
int32_t CellularCallProxy::Dial(const CellularCallInfo &callInfo)
{
MessageOption option;
MessageParcel in;
MessageParcel out;
//IPC序列化数据
if (!in.WriteInterfaceToken(CellularCallProxy::GetDescriptor())) {
return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
}
if (!in.WriteInt32(MAX_SIZE)) {
return TELEPHONY_ERR_WRITE_DATA_FAIL;
}
if (!in.WriteRawData((const void *)&callInfo, sizeof(CellularCallInfo))) {
return TELEPHONY_ERR_WRITE_DATA_FAIL;
}
//通过IPC发送数据
int32_t error = Remote()->SendRequest(static_cast<uint32_t>(OperationType::DIAL), in, out, option);
if (error == ERR_NONE) {
return out.ReadInt32();
}
return error;
}
6.11 通过cellular_call_stub的反序列拆解分发Dial信息
base\telephony\cellular_call\services\manager\src\cellular_call_stub.cpp
//在IPC收到给cellular_call这个SA的数据以后调用CellularCallStub::OnRemoteRequest
int32_t CellularCallStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
std::u16string myDescriptor = CellularCallStub::GetDescriptor();
std::u16string remoteDescriptor = data.ReadInterfaceToken();
if (myDescriptor != remoteDescriptor) {
TELEPHONY_LOGE("descriptor checked fail");
return TELEPHONY_ERR_DESCRIPTOR_MISMATCH;
}
auto itFunc = requestFuncMap_.find(static_cast<OperationType>(code));//根据请求code来查找处理函数，并调用这个处理函数
if (itFunc != requestFuncMap_.end()) {
auto requestFunc = itFunc->second;
if (requestFunc != nullptr) {
return (this->*requestFunc)(data, reply);
}
}
TELEPHONY_LOGI("CellularCallStub::OnRemoteRequest, default case, need check.");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
CellularCallStub::CellularCallStub()
{
//构造函数中会进行请求枚举关键值与对应的处理函数的一一映射，并存储到requestFuncMap_中
TELEPHONY_LOGI("CellularCallStub::CellularCallStub");
requestFuncMap_[OperationType::DIAL] = &CellularCallStub::OnDialInner;//拨号请求映射到了CellularCallStub::OnDialInner
requestFuncMap_[OperationType::HANG_UP] = &CellularCallStub::OnHangUpInner;
requestFuncMap_[OperationType::REJECT] = &CellularCallStub::OnRejectInner;
requestFuncMap_[OperationType::ANSWER] = &CellularCallStub::OnAnswerInner;
requestFuncMap_[OperationType::EMERGENCY_CALL] = &CellularCallStub::OnIsEmergencyPhoneNumberInner;
requestFuncMap_[OperationType::HOLD_CALL] = &CellularCallStub::OnHoldCallInner;
requestFuncMap_[OperationType::UN_HOLD_CALL] = &CellularCallStub::OnUnHoldCallInner;
requestFuncMap_[OperationType::SWITCH_CALL] = &CellularCallStub::OnSwitchCallInner;
requestFuncMap_[OperationType::COMBINE_CONFERENCE] = &CellularCallStub::OnCombineConferenceInner;
requestFuncMap_[OperationType::SEPARATE_CONFERENCE] = &CellularCallStub::OnSeparateConferenceInner;
requestFuncMap_[OperationType::INVITE_TO_CONFERENCE] = &CellularCallStub::OnInviteToConferenceInner;
requestFuncMap_[OperationType::KICK_OUT_CONFERENCE] = &CellularCallStub::OnKickOutFromConferenceInner;
requestFuncMap_[OperationType::HANG_UP_ALL_CONNECTION] = &CellularCallStub::OnHangUpAllConnectionInner;
requestFuncMap_[OperationType::UPDATE_CALL_MEDIA_MODE] = &CellularCallStub::OnUpdateCallMediaModeInner;
requestFuncMap_[OperationType::REGISTER_CALLBACK] = &CellularCallStub::OnRegisterCallBackInner;
requestFuncMap_[OperationType::UNREGISTER_CALLBACK] = &CellularCallStub::OnUnRegisterCallBackInner;
requestFuncMap_[OperationType::START_DTMF] = &CellularCallStub::OnStartDtmfInner;
requestFuncMap_[OperationType::STOP_DTMF] = &CellularCallStub::OnStopDtmfInner;
requestFuncMap_[OperationType::SEND_DTMF] = &CellularCallStub::OnSendDtmfInner;
requestFuncMap_[OperationType::START_RTT] = &CellularCallStub::OnStartRttInner;
requestFuncMap_[OperationType::STOP_RTT] = &CellularCallStub::OnStopRttInner;
requestFuncMap_[OperationType::SET_CALL_TRANSFER] = &CellularCallStub::OnSetCallTransferInner;
requestFuncMap_[OperationType::GET_CALL_TRANSFER] = &CellularCallStub::OnGetCallTransferInner;
requestFuncMap_[OperationType::SET_CALL_WAITING] = &CellularCallStub::OnSetCallWaitingInner;
requestFuncMap_[OperationType::GET_CALL_WAITING] = &CellularCallStub::OnGetCallWaitingInner;
requestFuncMap_[OperationType::SET_CALL_RESTRICTION] = &CellularCallStub::OnSetCallRestrictionInner;
requestFuncMap_[OperationType::GET_CALL_RESTRICTION] = &CellularCallStub::OnGetCallRestrictionInner;
requestFuncMap_[OperationType::SET_DOMAIN_PREFERENCE_MODE] = &CellularCallStub::OnSetDomainPreferenceModeInner;
requestFuncMap_[OperationType::GET_DOMAIN_PREFERENCE_MODE] = &CellularCallStub::OnGetDomainPreferenceModeInner;
requestFuncMap_[OperationType::SET_LTE_IMS_SWITCH_STATUS] = &CellularCallStub::OnSetLteImsSwitchStatusInner;
requestFuncMap_[OperationType::GET_LTE_IMS_SWITCH_STATUS] = &CellularCallStub::OnGetLteImsSwitchStatusInner;
requestFuncMap_[OperationType::SET_IMS_CONFIG_STRING] = &CellularCallStub::OnSetImsConfigStringInner;
requestFuncMap_[OperationType::SET_IMS_CONFIG_INT] = &CellularCallStub::OnSetImsConfigIntInner;
requestFuncMap_[OperationType::GET_IMS_CONFIG] = &CellularCallStub::OnGetImsConfigInner;
requestFuncMap_[OperationType::SET_IMS_FEATURE] = &CellularCallStub::OnSetImsFeatureValueInner;
requestFuncMap_[OperationType::GET_IMS_FEATURE] = &CellularCallStub::OnGetImsFeatureValueInner;
requestFuncMap_[OperationType::SET_IMS_SWITCH_ENHANCE_MODE] = &CellularCallStub::OnSetImsSwitchEnhanceModeInner;
requestFuncMap_[OperationType::GET_IMS_SWITCH_ENHANCE_MODE] = &CellularCallStub::OnGetImsSwitchEnhanceModeInner;
requestFuncMap_[OperationType::CTRL_CAMERA] = &CellularCallStub::OnCtrlCameraInner;
requestFuncMap_[OperationType::SET_PREVIEW_WINDOW] = &CellularCallStub::OnSetPreviewWindowInner;
requestFuncMap_[OperationType::SET_DISPLAY_WINDOW] = &CellularCallStub::OnSetDisplayWindowInner;
requestFuncMap_[OperationType::SET_CAMERA_ZOOM] = &CellularCallStub::OnSetCameraZoomInner;
requestFuncMap_[OperationType::SET_PAUSE_IMAGE] = &CellularCallStub::OnSetPauseImageInner;
requestFuncMap_[OperationType::SET_DEVICE_DIRECTION] = &CellularCallStub::OnSetDeviceDirectionInner;
requestFuncMap_[OperationType::SET_MUTE] = &CellularCallStub::OnSetMuteInner;
requestFuncMap_[OperationType::GET_MUTE] = &CellularCallStub::OnGetMuteInner;
}
int32_t CellularCallStub::OnDialInner(MessageParcel &data, MessageParcel &reply)
{
TELEPHONY_LOGI("CellularCallStub::OnDialInner entry");
int32_t size = data.ReadInt32();//IPC数据反序列化
size = ((size > MAX_SIZE) ? 0 : size);
if (size <= 0) {
TELEPHONY_LOGE("CellularCallStub::OnRemoteRequest data size error");
return TELEPHONY_ERR_FAIL;
}
auto pCallInfo = (CellularCallInfo *)data.ReadRawData(sizeof(CellularCallInfo));//IPC数据反序列化
if (pCallInfo == nullptr) {
TELEPHONY_LOGE("OnDialInner return, pCallInfo is nullptr.");
return TELEPHONY_ERR_ARGUMENT_INVALID;
}
reply.WriteInt32(Dial(*pCallInfo));//调用CellularCallService的Dial函数并返回反馈码
return TELEPHONY_SUCCESS;
}
6.12 通过cellular_call_stub的分发Dial信息到CellularCallService，再分发到cs域dial
class CellularCallService : public SystemAbility,
public CellularCallStub,//继承了CellularCallStub
public std::enable_shared_from_this<CellularCallService>
cellular_call\services\manager\src\cellular_call_service.cpp
int32_t CellularCallService::Dial(const CellularCallInfo &callInfo)
{
return csControl->Dial(callInfo);//调用了csControl->Dial
}
6.13 cs域dial再根据拨号类型分发到gsm或者CDMA
cellular_call\services\control\src\cs_control.cpp
int32_t CSControl::Dial(const CellularCallInfo &callInfo)
{
TELEPHONY_LOGI("Dial start");
int32_t ret = DialPreJudgment(callInfo);
if (ret != TELEPHONY_SUCCESS) {
return ret;
}
ModuleServiceUtils moduleServiceUtils;
PhoneType netType = moduleServiceUtils.GetNetworkStatus(callInfo.slotId);
if (netType == PhoneType::PHONE_TYPE_IS_GSM) {
return DialGsm(callInfo);//根据netType来决定调用GSM拨号，还是其它。我们以DialGsm来拉通流程
}
if (netType == PhoneType::PHONE_TYPE_IS_CDMA) {
return DialCdma(callInfo);//调用Cdma拨号
}
TELEPHONY_LOGE("Dial return, net type error.");
return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
}
int32_t CSControl::DialGsm(const CellularCallInfo &callInfo)
{//
TELEPHONY_LOGI("DialGsm entry.");
StandardizeUtils standardizeUtils;
// Remove the phone number separator
std::string newPhoneNum = standardizeUtils.RemoveSeparatorsPhoneNumber(callInfo.phoneNum);
CLIRMode clirMode = CLIRMode::DEFAULT;
if (IsNeedExecuteMMI(callInfo.slotId, newPhoneNum, clirMode)) {
TELEPHONY_LOGI("DialGsm return, mmi code type.");
return RETURN_TYPE_MMI;
}
if (!CanCall(connectionMap_)) {
TELEPHONY_LOGE("DialGsm return, error type: call state error.");
return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
}
// Calls can be put on hold, recovered, released, added to conversation,
// and transferred similarly as defined in 3GPP TS 22.030 [19].
if (IsInState(connectionMap_, TelCallState::CALL_STATUS_ACTIVE)) {
// New calls must be active, so other calls need to be hold
TELEPHONY_LOGI("DialGsm, GSM is have connection in active state.");
CellularCallConnectionCS pConnection;
// Delay dialing to prevent failure to add a new call while making a multi-party call
// Will it block the main thread or other threads? Will the reception of messages be blocked during sleep?
// - a call can be temporarily disconnected from the ME but the connection is retained by the network
pConnection.SwitchCallRequest(callInfo.slotId);
}
return EncapsulateDialCommon(callInfo.slotId, newPhoneNum, clirMode);//调用了CSControl::EncapsulateDialCommon
}
int32_t CSControl::EncapsulateDialCommon(int32_t slotId, const std::string &phoneNum, CLIRMode &clirMode)
{
DialRequestStruct dialRequest;
/**
* <idx>: integer type;
* call identification number as described in 3GPP TS 22.030 [19] subclause 4.5.5.1
* this number can be used in +CHLD command operations
* <dir>:
*/
dialRequest.phoneNum = phoneNum;
/**
* <n> (parameter sets the adjustment for outgoing calls):
* 0 presentation indicator is used according to the subscription of the CLIR service
* 1 CLIR invocation
* 2 CLIR suppression
*/
dialRequest.clirMode = clirMode;
/**
* An example of voice group call service request usage:
* ATD*17*753#500; (originate voice group call with the priority level 3)
* OK (voice group call setup was successful)
*/
CellularCallConnectionCS csConnection;
return csConnection.DialRequest(slotId, dialRequest);//调用了CellularCallConnectionCS下DialRequest函数
}
6.14 cellular_call_connection_cs将Dial请求分发到coreservice层的CoreManagerInner::GetInstance().Dial以及布局Dial的响应处理handler
cellular_call\services\connection\src\cellular_call_connection_cs.cpp
int32_t CellularCallConnectionCS::DialRequest(int32_t slotId, const DialRequestStruct &dialRequest)
{
TELEPHONY_LOGE("CellularCallConnectionCS::DialRequest start.");
if (DelayedSingleton<CellularCallService>::GetInstance() == nullptr) {
TELEPHONY_LOGE("DialRequest return, error type: GetInstance() is nullptr.");
return CALL_ERR_RESOURCE_UNAVAILABLE;
}
*************base\telephony\cellular_call\services\manager\src\cellular_call_handler.cpp******
*************生产事件处理handler产生Dial请求的响应事件处理者CellularCallHandler******
*************requestFuncMap_[RadioEvent::RADIO_DIAL] = &CellularCallHandler::DialResponse;******
auto handle = DelayedSingleton<CellularCallService>::GetInstance()->GetHandler(slotId);//这个handle用来处理Dial请求下发后，下层的处理请求以后的反馈上来的信息
if (handle == nullptr) {
TELEPHONY_LOGE("DialRequest return, error type: handle is nullptr.");
return CALL_ERR_RESOURCE_UNAVAILABLE;
}
CoreManagerInner::GetInstance().Dial(//离开CellularCall这一层，CoreManagerInner::GetInstance().Dial进入到了CoreService层了
slotId, RadioEvent::RADIO_DIAL, dialRequest.phoneNum, dialRequest.clirMode, handle);
return TELEPHONY_SUCCESS;
}
7. coreservice层信号处理后调用到厂商库
7.1 生产事件处理handler,并传递到rilmanager中去处理
core_service\frameworks\native\src\core_manager_inner.cpp
int32_t CoreManagerInner::Dial(int32_t slotId, int32_t eventId, std::string address, int clirMode,
const std::shared_ptr<AppExecFwk::EventHandler> &handler)
{
if (telRilManager_ == nullptr) {
TELEPHONY_LOGE("telRilManager is null!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(eventId);//获取一个与Dial请求ID（eventId）值绑定的内部事件指针
response->SetOwner(handler);//将事件处理器对象绑定到内部事件指针的Owner上
return telRilManager_->Dial(slotId, address, clirMode, response);//将绑定了Dial请求ID以及对应的事件处理器内部事件指针与Dial参数一起分发给telRilManager_->Dial处理
}
7.2 TelRilManager转到TelRilCall中，通过IPC下发到了去处理
core_service\services\tel_ril\src\tel_ril_manager.cpp
int32_t TelRilManager::Dial(
int32_t slotId, std::string address, int32_t clirMode, const AppExecFwk::InnerEvent::Pointer &response)
{
return TaskSchedule(response, "TelRilCall", GetTelRilCall(slotId), &TelRilCall::Dial, address, clirMode);//通过这个函数进一步分发到TelRilCall::Dial函数处理
}
int32_t TelRilCall::Dial(const std::string address, int32_t clirMode, const AppExecFwk::InnerEvent::Pointer &result)
{
std::shared_ptr<TelRilRequest> telRilRequest = CreateTelRilRequest(HREQ_CALL_DIAL, result);
//通过这里创建一个唯一序列号telRilRequest->serialId_绑定到该请求，并保存到requestMap_，该序号用于FindTelRilRequest时（被响应处理或超时后）把该请求的从requestMap_移除。
if (telRilRequest == nullptr) {
TELEPHONY_LOGE("telRilRequest is nullptr");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
if (cellularRadio_ == nullptr) {
TELEPHONY_LOGE("%{public}s cellularRadio_ == nullptr", __func__);
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
DialInfo dialInfo;
dialInfo.address = address;
dialInfo.clir = clirMode;
dialInfo.serial = telRilRequest->serialId_;
int32_t ret = SendBufferEvent(HREQ_CALL_DIAL, dialInfo);//通过IPC发送Dial请求到modem的HDF驱动服务去，最终经过modem的HDF驱动服务的分发会调用HRilCall::Dial函数
TELEPHONY_LOGI("Send (ID:%{public}d) return: %{public}d", HREQ_CALL_DIAL, ret);
return ret;
}
7.3 TelRilCall中的HREQ_CALL_DIAL响应绑定以及响应函数
memberFuncMap_[HREQ_CALL_DIAL] = &TelRilCall::DialResponse;//coreservice这个层级的Dial响应处理函数
int32_t TelRilCall::DialResponse(MessageParcel &data)
{
//IPC反序列化读取读取modem Hdf驱动服务端反馈的数据
const size_t readSpSize = sizeof(struct HRilRadioResponseInfo);
const uint8_t *spBuffer = data.ReadUnpadBuffer(readSpSize);
if (spBuffer == nullptr) {
TELEPHONY_LOGE("TelRilCall DialResponse read spBuffer failed");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
const struct HRilRadioResponseInfo *radioResponseInfo =
reinterpret_cast<const struct HRilRadioResponseInfo *>(spBuffer);
if (radioResponseInfo == nullptr) {
TELEPHONY_LOGE("ERROR :radioResponseInfo == nullptr !!!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::shared_ptr<TelRilRequest> telRilRequest = FindTelRilRequest(*radioResponseInfo);
//从requestMap_成员变量中移除与radioResponseInfo->serial对应的telRilRequest，并返回该telRilRequest，当telRilRequest使用完后就被释放了。
if (telRilRequest == nullptr || telRilRequest->pointer_ == nullptr) {
TELEPHONY_LOGE("ERROR : telRilRequest or telRilRequest->pointer_ == nullptr !!!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
//获取这个Dial请求对应的响应事件处理器（蜂窝调用时通过pointer_传递下来的）
const std::shared_ptr<OHOS::AppExecFwk::EventHandler> &handler = telRilRequest->pointer_->GetOwner();
if (handler == nullptr) {
TELEPHONY_LOGE("ERROR :handler == nullptr !!!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
//获取这个Dial请求对应的事件ID
uint32_t eventId = telRilRequest->pointer_->GetInnerEventId();
std::shared_ptr<HRilRadioResponseInfo> result = std::make_shared<HRilRadioResponseInfo>();
result->error = radioResponseInfo->error;
handler->SendEvent(eventId, result);//通过响应事件处理器的SendEvent发送结果给响应事件处理器的处理函数，并指定该结果为eventId事件的响应数据
return TELEPHONY_ERR_SUCCESS;
}
7.4 HRilManager收到请求后拆解转到HRilCall中直接调用厂商库函数去处理
ril_adapter\services\hril\src\hril_call.cpp
int32_t HRilCall::Dial(struct HdfSBuf *data)
{
if (callFuncs_ == nullptr || callFuncs_->Dial == nullptr || data == nullptr) {
TELEPHONY_LOGE("callFuncs_:%{public}p or callFuncs_->Dial or data:%{public}p is nullptr!", callFuncs_, data);
return HRIL_ERR_NULL_POINT;
}
DialInfo dialInfo = DialInfo();
MessageParcel *parcel = nullptr;
//IPC反序列化coreservice层级发送过来的数据
if (SbufToParcel(data, &parcel)) {
TELEPHONY_LOGE("RilAdapter failed to do SbufToParcel");
return HRIL_ERR_INVALID_PARAMETER;
}
if (!dialInfo.ReadFromParcel(*parcel)) {
TELEPHONY_LOGE("RilAdapter failed to do ReadFromParcel!");
return HRIL_ERR_INVALID_PARAMETER;
}
HRilDial dial = {};
dial.address = StringToCString(dialInfo.address);
dial.clir = (int32_t)dialInfo.clir;
ReqDataInfo *requestInfo = CreateHRilRequest(dialInfo.serial, HREQ_CALL_DIAL);
if (requestInfo == nullptr) {
TELEPHONY_LOGE("RilAdapter failed to do Create Dial HRilRequest!");
return HRIL_ERR_NULL_POINT;
}
//callFuncs_存储厂商库call相关接口函数的结构体指针，通过这个指针里的Dial函数指针调用厂商库Dial函数
callFuncs_->Dial(requestInfo, &dial, sizeof(HRilDial));
return HRIL_ERR_SUCCESS;
}
8. 通过HDF服务的初始化以及配置，来曝漏厂商库接口
8.1 配置并确定hdf驱动对外提供服务的名称
vendor\hisilicon\Hi3516DV300\hdf_config\uhdf\device_info.hcs
riladapter :: host {
hostName = "riladapter_host";//HDF驱动的进程名称
priority = 50;
riladapter_device :: device {
device0 :: deviceNode {
policy = 2;
priority = 100;
moduleName = "libhril_hdf.z.so";//提供modem HDF驱动服务的库文件名称
serviceName = "cellular_radio1";//提供modem HDF驱动服务对外曝露的服务名称
}
}
}
8.2 驱动入口注册
base\telephony\ril_adapter\services\hril_hdf\src\hril_hdf.c
struct HdfDriverEntry g_rilAdapterDevEntry = {
.moduleVersion = 1,
.moduleName = "hril_hdf",
.Bind = RilAdapterBind,//modem HDF驱动绑定函数，在这个函数里绑定了HDF的服务对象，服务对象里保存有服务提供的各种功能分发处理函数，在这个分发处理函数中进行功能函数分派Dispatch
.Init = RilAdapterInit,//modem HDF驱动初始化函数
.Release = RilAdapterRelease,
};
HDF_INIT(g_rilAdapterDevEntry);
8.3 初始化加载厂商库
static int32_t RilAdapterInit(struct HdfDeviceObject *device)
{
...
TELEPHONY_LOGI("sbuf IPC obtain success!");
LoadVendor();//加载厂商库
return HDF_SUCCESS;
}
8.4 通过bind将具体的服务函数绑定到HDF驱动服务上
static int32_t RilAdapterDispatch(
struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
{
int32_t ret;
static pthread_mutex_t dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&dispatchMutex);
TELEPHONY_LOGI("RilAdapterDispatch cmd:%{public}d", cmd);
ret = DispatchRequest(cmd, data);//请求下来以后通过服务的Dispatch接口函数到这里，通过DispatchRequest函数在按服务的功能进行分类分发到不同处理函数进行处理
pthread_mutex_unlock(&dispatchMutex);
return ret;
}
static struct IDeviceIoService g_rilAdapterService = {
.Dispatch = RilAdapterDispatch,//服务对象里绑定服务功能分派函数
.Open = NULL,
.Release = NULL,
};
static int32_t RilAdapterBind(struct HdfDeviceObject *device)
{
if (device == NULL) {
return HDF_ERR_INVALID_OBJECT;
}
device->service = &g_rilAdapterService;//绑定服务对象
return HDF_SUCCESS;
}
9. coreservice中的ril管理层怎么使用riladapter hdf服务
9.1 ril管理层怎么获取 hdf服务，通过什么与HDF服务通讯
base\telephony\core_service\services\tel_ril\src\tel_ril_manager.cpp
bool TelRilManager::OnInit()
{
bool res = false;
int32_t i = 0;
telRilCallback_ = this;
death_ = sptr<OHOS::IPCObjectStub::DeathRecipient>(new HdfDeathRecipient(this));
do {
res = ConnectRilAdapterService();//连接modem的HDF驱动服务，拿到能与modem的HDF驱动服务通讯的远端对象，并将自己告诉服务端，这样服务端的反馈信息也可以发送给自己（telRilCallback_，this）
if (!res) {
i++;
sleep(1);
}
} while (!res && (i < RIL_INIT_COUNT_MAX));
if (res) {
for (int32_t slotId = SIM_SLOT_0; slotId < SIM_SLOT_COUNT; slotId++) {
InitTelModule(slotId);
}
}
return res;
}
bool TelRilManager::ConnectRilAdapterService()
{
std::lock_guard<std::mutex> lock_l(mutex_);
rilAdapterRemoteObj_ = nullptr;
//获取驱动服务管理器
auto servMgr_ = OHOS::HDI::ServiceManager::V1_0::IServiceManager::Get();
if (servMgr_ == nullptr) {
TELEPHONY_LOGI("Get service manager error!");
return false;
}
//通过服务名称获取能与该驱动服务通讯的远端对象
rilAdapterRemoteObj_ = servMgr_->GetService(RIL_ADAPTER_SERVICE_NAME.c_str());
if (rilAdapterRemoteObj_ == nullptr) {
TELEPHONY_LOGE("bind hdf error!");
return false;
}
if (death_ == nullptr) {
TELEPHONY_LOGE("create HdfDeathRecipient object failed!");
rilAdapterRemoteObj_ = nullptr;
return false;
}
if (!rilAdapterRemoteObj_->AddDeathRecipient(death_)) {
TELEPHONY_LOGE("AddDeathRecipient hdf failed!");
rilAdapterRemoteObj_ = nullptr;
return false;
}
int32_t ret = SetCellularRadioIndication();//将自己发送给驱动服务端，告诉驱动服务端，通知消息发回给自己
if (ret != CORE_SERVICE_SUCCESS) {
TELEPHONY_LOGE("SetCellularRadioIndication error, ret:%{public}d", ret);
return false;
}
ret = SetCellularRadioResponse();//将自己发送给驱动服务端，告诉驱动服务端，响应消息发回给自己
if (ret != CORE_SERVICE_SUCCESS) {
TELEPHONY_LOGE("SetCellularRadioResponse error, ret:%{public}d", ret);
return false;
}
return true;
}
9.2 调用Dial接口
base\telephony\core_service\services\tel_ril\src\tel_ril_base.cpp
TelRilBase::TelRilBase(
int32_t slotId, sptr<IRemoteObject> rilAdapterObj, std::shared_ptr<ObserverHandler> observerHandler)
{
observerHandler_ = observerHandler;
cellularRadio_ = rilAdapterObj;//保存远端对象为成员变量
slotId_ = slotId;
}
base\telephony\core_service\services\tel_ril\src\tel_ril_call.cpp
int32_t TelRilCall::Dial(const std::string address, int32_t clirMode, const AppExecFwk::InnerEvent::Pointer &result)
{
std::shared_ptr<TelRilRequest> telRilRequest = CreateTelRilRequest(HREQ_CALL_DIAL, result);
if (telRilRequest == nullptr) {
TELEPHONY_LOGE("telRilRequest is nullptr");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
if (cellularRadio_ == nullptr) {
TELEPHONY_LOGE("%{public}s cellularRadio_ == nullptr", __func__);
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
DialInfo dialInfo;
dialInfo.address = address;
dialInfo.clir = clirMode;
dialInfo.serial = telRilRequest->serialId_;
int32_t ret = SendBufferEvent(HREQ_CALL_DIAL, dialInfo);//调用的基类TelRilBase的SendBufferEvent发送IPC数据到HDF驱动服务端
TELEPHONY_LOGI("Send (ID:%{public}d) return: %{public}d", HREQ_CALL_DIAL, ret);
return ret;
}
base\telephony\core_service\services\tel_ril\src\tel_ril_base.h
template<typename T>
int32_t SendBufferEvent(int32_t dispatchId, const T &eventData)
{
if (cellularRadio_ == nullptr) {
TELEPHONY_LOGE("cellularRadio_ is nullptr!!!");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
//序列化数据
MessageParcel data;
MessageParcel reply;
data.WriteInt32(slotId_);
eventData.Marshalling(data);
OHOS::MessageOption option = {OHOS::MessageOption::TF_ASYNC};
TELEPHONY_LOGI("Send event, dispatchId:%{public}d", dispatchId);
//通过IPC发送序列化数据到服务端
return cellularRadio_->SendRequest(dispatchId, data, reply, option);
}
base\telephony\ril_adapter\services\hril_hdf\src\hril_hdf.c
static int32_t RilAdapterDispatch(
struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
{
int32_t ret;
static pthread_mutex_t dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&dispatchMutex);
TELEPHONY_LOGI("RilAdapterDispatch cmd:%{public}d", cmd);
//HDF驱动收到IPC请求后通过这里分派出去处理
ret = DispatchRequest(cmd, data);
pthread_mutex_unlock(&dispatchMutex);
return ret;
}
10. 厂商库与HDF互调函数数据交换
10.1 厂商库将自己对外提供的接口函数数据绑定一个结构体对象
ril_adapter\services\vendor\src\vendor_adapter.c
static const HRilCallReq g_callReqOps = {
.GetCallList = ReqGetCallList,
.Dial = ReqDial,//这里将g_callReqOps的.Dial绑定到了厂商库ReqDial函数
.Hangup = ReqHangup,
.Reject = ReqReject,
.Answer = ReqAnswer,
.GetClip = ReqGetClip,
.SetClip = ReqSetClip,
.HoldCall = ReqHoldCall,
.UnHoldCall = ReqUnHoldCall,
.SwitchCall = ReqSwitchCall,
.CombineConference = ReqCombineConference,
.SeparateConference = ReqSeparateConference,
.CallSupplement = ReqCallSupplement,
.GetCallWaiting = ReqGetCallWaiting,
.SetCallWaiting = ReqSetCallWaiting,
.GetCallTransferInfo = ReqGetCallTransferInfo,
.SetCallTransferInfo = ReqSetCallTransferInfo,
.GetCallRestriction = ReqGetCallRestriction,
.SetCallRestriction = ReqSetCallRestriction,
.GetClir = ReqGetClir,
.SetClir = ReqSetClir,
.StartDtmf = ReqStartDtmf,
.SendDtmf = ReqSendDtmf,
.StopDtmf = ReqStopDtmf,
.GetImsCallList = ReqGetImsCallList,
.GetCallPreferenceMode = ReqGetCallPreferenceMode,
.SetCallPreferenceMode = ReqSetCallPreferenceMode,
.GetLteImsSwitchStatus = ReqGetLteImsSwitchStatus,
.SetLteImsSwitchStatus = ReqSetLteImsSwitchStatus,
.SetUssd = ReqSetUssd,
.GetUssd = ReqGetUssd,
.GetMute = ReqGetMute,
.SetMute = ReqSetMute,
.GetEmergencyCallList = ReqGetEmergencyCallList,
.GetCallFailReason = ReqGetCallFailReason,
};
10.2 加载厂商库通过rilInitOps并完成厂商库对外服务函数与HDF驱动数据接收处理函数的函数结构体对象交换
base\telephony\ril_adapter\services\hril_hdf\hril_hdf.c
static void LoadVendor(void)
{
const char *rilLibPath = NULL;
char vendorLibPath[PARAMETER_SIZE] = {0};
// Pointer to ril init function in vendor ril
const HRilOps *(*rilInitOps)(const struct HRilReport *) = NULL;
// functions returned by ril init function in vendor ril
const HRilOps *ops = NULL;
if (GetVendorLibPath(vendorLibPath) == HDF_SUCCESS) {
rilLibPath = vendorLibPath;
} else {
rilLibPath = g_modem_list[MODEM_INDEX].path;
}
if (rilLibPath == NULL) {
TELEPHONY_LOGE("dynamic library path is empty");
return;
}
g_dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (g_dlHandle == NULL) {
TELEPHONY_LOGE("dlopen %{public}s is fail. %{public}s", rilLibPath, dlerror());
return;
}
//拿到厂商库的rilInitOps函数指针
rilInitOps = (const HRilOps *(*)(const struct HRilReport *))dlsym(g_dlHandle, "RilInitOps");
if (rilInitOps == NULL) {
dlclose(g_dlHandle);
TELEPHONY_LOGE("RilInit not defined or exported");
return;
}
ops = rilInitOps(&g_reportOps);//通过rilInitOps函数将存储厂商库的函数接口的对象交给HDF驱动服务端，并将HDF驱动服务端提供的信息上报函数接口交给厂商库。
HRilRegOps(ops);//将ops里存放的厂商库对外提供的功能接口函数指针保存到HDF驱动服务端，这样HDF驱动服务端就可以通过这些函数接口调用厂商库里的函数。
}
10.3 具体的厂商库执行接口函数ReqDial
ril_adapter\services\vendor\src\at_call.c
void ReqDial(const ReqDataInfo *requestInfo, const HRilDial *data, size_t dataLen)
{
HRilDial *pDial = NULL;
char cmd[MAX_CMD_LENGTH] = {0};
const char *clir = NULL;
int32_t ret;
int32_t err = HRIL_ERR_SUCCESS;
struct ReportInfo reportInfo = {0};
ResponseInfo *pResponse = NULL;
if (data == NULL) {
TELEPHONY_LOGE("data is null!!!");
return;
}
pDial = (HRilDial *)data;
switch (pDial->clir) {
case CALL_CLIR_INVOCATION:
clir = "I";
break; /* invocation */
case CALL_CLIR_SUPPRESSION:
clir = "i";
break; /* suppression */
case CALL_CLIR_SUBSCRIPTION_DEFAULT:
default:
clir = "";
break; /* subscription default */
}
//根据Dial参数生成AT指令
ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "ATD%s%s;", pDial->address, clir);
if (ret < 0) {
TELEPHONY_LOGE("GenerateCommand is failed!");
OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
return;
}
//发送AT指令并等待，直到拿到反馈信息或者超时
ret = SendCommandLock(cmd, NULL, 0, &pResponse);
if (ret != 0) {
err = HRIL_ERR_CMD_SEND_FAILURE;
TELEPHONY_LOGE("ATD send failed");
} else {
if (!pResponse->success) {
TELEPHONY_LOGE("ReqDial return ERROR");
err = HRIL_ERR_CMD_NO_CARRIER;
}
}
//创建上报的报告数据
reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
//上报报告数据
OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
FreeResponseInfo(pResponse);
}
10.4 厂商库执行接口函数ReqDial往modem写指令
ril_adapter\services\vendor\src\at_support.c
int32_t SendCommandLock(const char *command, const char *prefix, long long timeout, ResponseInfo **outResponse)
{
const char *atCmd = "AT";
int32_t err;
if (pthread_equal(g_reader, pthread_self()) != 0) {
TELEPHONY_LOGE("The read thread prohibits sending commands.");
return AT_ERR_INVALID_THREAD;
}
TELEPHONY_LOGI("command %{public}s, NeedATPause:%{public}d, atCmd:%{public}s", command, g_isNeedATPause, atCmd);
pthread_mutex_lock(&g_commandmutex);
if (g_isNeedATPause) {
pthread_cond_signal(&g_commandcond);
err = SendCommandNoLock(atCmd, timeout, outResponse);
if (err != 0) {
TELEPHONY_LOGI("NeedATPause err = %{public}d cmd:%{public}s", err, command);
}
if (g_atWatch != NULL) {
g_atWatch();
}
g_isNeedATPause = false;
alarm(0);
}
g_prefix = prefix;
//发送数据到下一层，并设置等待数据响应的超时时长
err = SendCommandNoLock(command, timeout, outResponse);
pthread_mutex_unlock(&g_commandmutex);
TELEPHONY_LOGI("err = %{public}d, cmd:%{public}s", err, command);
// when timeout to process
if (err == AT_ERR_TIMEOUT && g_onTimeout != NULL) {
g_onTimeout();
} else if (err == AT_ERR_GENERIC) {
TELEPHONY_LOGI("OnReaderClosed() err = %{public}d", err);
OnReaderClosed();
}
return err;
}
int32_t SendCommandNoLock(const char *command, long long timeout, ResponseInfo **outResponse)
{
long long defaultTimeOut = DEFAULT_LONG_TIMEOUT;
int32_t err = 0;
struct timespec time;
err = NewResponseInfo();
if (err != VENDOR_SUCCESS) {
TELEPHONY_LOGE("New responseInfo is fail, err:%{public}d.", err);
return err;
}
//继续往下发送数据（这个函数调用了C库的write函数）
err = WriteATCommand(command, 0, g_atFd);
if (err != VENDOR_SUCCESS) {
TELEPHONY_LOGE("send AT cmd is fail, err:%{public}d.", err);
ClearCurCommand();
return err;
}
SetWaitTimeout(&time, (timeout != 0) ? timeout : defaultTimeOut);
while (g_response->result == NULL && g_readerClosed == 0) {
err = pthread_cond_timedwait(&g_commandcond, &g_commandmutex, &time);
if (err == ETIMEDOUT) {
err = AT_ERR_TIMEOUT;
TELEPHONY_LOGE("pthread cond timedwait is timeout, err:%{public}d.", err);
ClearCurCommand();
return err;
}
}
if (outResponse == NULL) {
FreeResponseInfo((ResponseInfo *)g_response);
} else {
*outResponse = (ResponseInfo *)g_response;
}
g_response = NULL;
if (g_readerClosed > 0) {
err = AT_ERR_CHANNEL_CLOSED;
TELEPHONY_LOGE("g_readerClosed is closed, err:%{public}d.", err);
ClearCurCommand();
return err;
}
err = 0;
return err;
}
ril_adapter\services\vendor\src\vendor_channel.c
int32_t WriteATCommand(const char *s, int32_t isPdu, int32_t atFd)
{
TELEPHONY_LOGI("cmd:%{public}s", s);
ssize_t ret;
size_t i = 0;
size_t len = strlen(s);
if (atFd < 0) {
return AT_ERR_CHANNEL_CLOSED;
}
while (i < len) {
do {
//写数据到串口
ret = write(atFd, s + i, len - i);
} while (ret < 0 && errno == EINTR);
if (ret < 0) {
return AT_ERR_GENERIC;
}
i += ret;
}
if (isPdu != 0) {
do {
ret = write(atFd, "\x1A", 1);
} while ((ret < 0 && errno == EINTR) || (ret == 0));
} else {
do {
ret = write(atFd, "\r", 1);
} while ((ret < 0 && errno == EINTR) || (ret == 0));
}
if (ret < 0) {
return AT_ERR_GENERIC;
}
return VENDOR_SUCCESS;
}
10.5 厂商库循环读取modem的信息并处理
D:\OpenHarmony\base\telephony\ril_adapter\services\vendor\src\at_support.c
int32_t ATStartReadLoop(int32_t fd, OnNotify func)
{
int32_t ret = 0;
g_atFd = fd;
g_onNotifyFunc = func;
pthread_attr_t t;
pthread_attr_init(&t);
pthread_attr_setdetachstate(&t, PTHREAD_CREATE_DETACHED);
ret = pthread_create(&g_reader, &t, (void *(*)(void *))ReaderLoop, &t);
if (ret < 0) {
TELEPHONY_LOGE("create pthread error code： %{public}d", ret);
return VENDOR_ERR_PROCESS;
}
return VENDOR_SUCCESS;
}
void ReaderLoop(void)
{//循环读取串口的，获取modem对请求的响应信息以及主动上报信息
TELEPHONY_LOGI("%{public}s enter", __func__);
g_readerClosed = 0;
while (1) {
const char *str = NULL;
const char *pdu = NULL;
str = ReadResponse(g_atFd);//读取modem的响应反馈信息或主动上报信息。
if (str == NULL) {
TELEPHONY_LOGE("str is null");
break;
}
if (IsSmsNotify(str)) {//如果是短信，会继续读取拿到短信PDU内容数据
TELEPHONY_LOGI("new sms notify :%{public}s", str);
pdu = ReadResponse(g_atFd);//读取PDU信息
TELEPHONY_LOGI("pdu :%{public}s", pdu);
}
ProcessResponse(str, pdu);//对信息进行拆解，分析，最后根据信息具体类型进行对应分发（主动上报或请求的响应反馈）。
}
OnReaderClosed();
}
发布问题
发布文章
