1 /*
2 * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "report_call_info_handler.h"
17
18 #include "call_manager_errors.h"
19 #include "call_manager_hisysevent.h"
20 #include "call_manager_service.h"
21 #include "ffrt.h"
22 #include "ffrt_inner.h"
23 #include "ims_call.h"
24 #include "telephony_log_wrapper.h"
25 #include "antifraud_service.h"
26 #include "thread"
27
28 namespace OHOS {
29 namespace Telephony {
30 namespace {
31 ffrt::queue reportCallInfoQueue { "report_call_info_queue", ffrt::queue_attr().qos(ffrt_qos_user_interactive)};
32 }
ReportCallInfoHandler()33 ReportCallInfoHandler::ReportCallInfoHandler() {}
34
~ReportCallInfoHandler()35 ReportCallInfoHandler::~ReportCallInfoHandler() {}
36
Init()37 void ReportCallInfoHandler::Init()
38 {
39 callStatusManagerPtr_ = std::make_shared<CallStatusManager>();
40 callStatusManagerPtr_->Init();
41 DelayedSingleton<AntiFraudService>::GetInstance()->SetCallStatusManager(callStatusManagerPtr_);
42 DelayedSingleton<CallManagerService>::GetInstance()->SetCallStatusManager(callStatusManagerPtr_);
43 return;
44 }
45
UpdateCallReportInfo(const CallDetailInfo & info)46 int32_t ReportCallInfoHandler::UpdateCallReportInfo(const CallDetailInfo &info)
47 {
48 if (callStatusManagerPtr_ == nullptr) {
49 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
50 return TELEPHONY_ERR_LOCAL_PTR_NULL;
51 }
52
53 if (CallStatusManager::GetDevProvisioned() != DEVICE_PROVISION_VALID &&
54 info.callType == CallType::TYPE_BLUETOOTH) {
55 TELEPHONY_LOGE("BT call not report in OOBE");
56 return TELEPHONY_SUCCESS;
57 }
58
59 CallDetailInfo callDetailInfo = info;
60 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
61 TELEPHONY_LOGW("UpdateCallReportInfo submit task enter");
62 reportCallInfoQueue.submit([callStatusManagerPtr, callDetailInfo]() {
63 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
64 if (managerPtr == nullptr) {
65 TELEPHONY_LOGE("managerPtr is null");
66 return;
67 }
68 auto ret = managerPtr->HandleCallReportInfo(callDetailInfo);
69 if (ret != TELEPHONY_SUCCESS) {
70 TELEPHONY_LOGE("HandleCallReportInfo failed! ret:%{public}d", ret);
71 }
72 });
73 return TELEPHONY_SUCCESS;
74 }
75
BuildCallDetailsInfo(CallDetailsInfo & info,CallDetailsInfo & callDetailsInfo)76 void ReportCallInfoHandler::BuildCallDetailsInfo(CallDetailsInfo &info, CallDetailsInfo &callDetailsInfo)
77 {
78 CallDetailInfo callDetailInfo;
79 std::vector<CallDetailInfo>::iterator iter = info.callVec.begin();
80 for (; iter != info.callVec.end(); ++iter) {
81 callDetailInfo.callType = (*iter).callType;
82 callDetailInfo.accountId = (*iter).accountId;
83 callDetailInfo.state = (*iter).state;
84 callDetailInfo.callMode = (*iter).callMode;
85 callDetailInfo.index = (*iter).index;
86 callDetailInfo.voiceDomain = (*iter).voiceDomain;
87 callDetailInfo.mpty = (*iter).mpty;
88 callDetailInfo.crsType = (*iter).crsType;
89 callDetailInfo.originalCallType = (*iter).originalCallType;
90 (void)memcpy_s(callDetailInfo.phoneNum, kMaxNumberLen, (*iter).phoneNum, kMaxNumberLen);
91 (void)memcpy_s(callDetailInfo.bundleName, kMaxBundleNameLen, (*iter).bundleName, kMaxBundleNameLen);
92 callDetailInfo.name = (*iter).name;
93 callDetailInfo.namePresentation = (*iter).namePresentation;
94 callDetailInfo.reason = (*iter).reason;
95 callDetailInfo.message = (*iter).message;
96 callDetailInfo.newCallUseBox = (*iter).newCallUseBox;
97 callDetailsInfo.callVec.push_back(callDetailInfo);
98 }
99 }
100
UpdateCallsReportInfo(CallDetailsInfo & info)101 int32_t ReportCallInfoHandler::UpdateCallsReportInfo(CallDetailsInfo &info)
102 {
103 if (callStatusManagerPtr_ == nullptr) {
104 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
105 return TELEPHONY_ERR_LOCAL_PTR_NULL;
106 }
107
108 CallDetailsInfo callDetailsInfo;
109 callDetailsInfo.slotId = info.slotId;
110 (void)memcpy_s(callDetailsInfo.bundleName, kMaxBundleNameLen, info.bundleName, kMaxBundleNameLen);
111 BuildCallDetailsInfo(info, callDetailsInfo);
112 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
113 TELEPHONY_LOGW("UpdateCallsReportInfo submit task enter");
114 reportCallInfoQueue.submit([callStatusManagerPtr, callDetailsInfo]() {
115 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
116 if (managerPtr == nullptr) {
117 TELEPHONY_LOGE("managerPtr is null");
118 return;
119 }
120 int32_t ret = managerPtr->HandleCallsReportInfo(callDetailsInfo);
121 if (ret != TELEPHONY_SUCCESS) {
122 TELEPHONY_LOGE("HandleCallsReportInfo failed! ret:%{public}d", ret);
123 }
124 });
125
126 CallDetailInfo detailInfo;
127 detailInfo.state = TelCallState::CALL_STATUS_UNKNOWN;
128 std::vector<CallDetailInfo>::iterator it = info.callVec.begin();
129 for (; it != info.callVec.end(); ++it) {
130 detailInfo.callType = (*it).callType;
131 detailInfo.accountId = (*it).accountId;
132 detailInfo.state = (*it).state;
133 detailInfo.callMode = (*it).callMode;
134 }
135 if (detailInfo.state == TelCallState::CALL_STATUS_INCOMING) {
136 CallManagerHisysevent::WriteIncomingCallFaultEvent(info.slotId, static_cast<int32_t>(detailInfo.callType),
137 static_cast<int32_t>(detailInfo.callMode), CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE,
138 "ID HANDLER_UPDATE_CALL_INFO_LIST");
139 }
140 return TELEPHONY_SUCCESS;
141 }
142
UpdateDisconnectedCause(const DisconnectedDetails & details)143 int32_t ReportCallInfoHandler::UpdateDisconnectedCause(const DisconnectedDetails &details)
144 {
145 if (callStatusManagerPtr_ == nullptr) {
146 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
147 return TELEPHONY_ERR_LOCAL_PTR_NULL;
148 }
149 DisconnectedDetails disconnectedDetails = details;
150 if (static_cast<RilDisconnectedReason>(details.reason) == RilDisconnectedReason::DISCONNECTED_REASON_NORMAL) {
151 disconnectedDetails.reason = DisconnectedReason::NORMAL_CALL_CLEARING;
152 }
153 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
154 TELEPHONY_LOGI("UpdateDisconnectedCause submit task enter");
155 reportCallInfoQueue.submit([callStatusManagerPtr, disconnectedDetails]() {
156 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
157 if (managerPtr == nullptr) {
158 TELEPHONY_LOGE("managerPtr is null");
159 return;
160 }
161 int32_t ret = managerPtr->HandleDisconnectedCause(disconnectedDetails);
162 if (ret != TELEPHONY_SUCCESS) {
163 TELEPHONY_LOGE("HandleDisconnectedCause failed! ret:%{public}d", ret);
164 }
165 });
166
167 return TELEPHONY_SUCCESS;
168 }
169
UpdateEventResultInfo(const CellularCallEventInfo & info)170 int32_t ReportCallInfoHandler::UpdateEventResultInfo(const CellularCallEventInfo &info)
171 {
172 if (callStatusManagerPtr_ == nullptr) {
173 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
174 return TELEPHONY_ERR_LOCAL_PTR_NULL;
175 }
176 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
177 TELEPHONY_LOGI("UpdateEventResultInfo submit task enter");
178 reportCallInfoQueue.submit([callStatusManagerPtr, info]() {
179 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
180 if (managerPtr == nullptr) {
181 TELEPHONY_LOGE("managerPtr is null");
182 return;
183 }
184 int32_t ret = managerPtr->HandleEventResultReportInfo(info);
185 if (ret != TELEPHONY_SUCCESS) {
186 TELEPHONY_LOGE("HandleEventResultReportInfo failed! ret:%{public}d", ret);
187 }
188 });
189
190 return TELEPHONY_SUCCESS;
191 }
192
UpdateOttEventInfo(const OttCallEventInfo & info)193 int32_t ReportCallInfoHandler::UpdateOttEventInfo(const OttCallEventInfo &info)
194 {
195 if (callStatusManagerPtr_ == nullptr) {
196 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
197 return TELEPHONY_ERR_LOCAL_PTR_NULL;
198 }
199 OttCallEventInfo ottCallEventInfo = info;
200 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
201 TELEPHONY_LOGI("UpdateOttEventInfo submit task enter");
202 reportCallInfoQueue.submit([callStatusManagerPtr, ottCallEventInfo]() {
203 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
204 if (managerPtr == nullptr) {
205 TELEPHONY_LOGE("managerPtr is null");
206 return;
207 }
208 int32_t ret = managerPtr->HandleOttEventReportInfo(ottCallEventInfo);
209 if (ret != TELEPHONY_SUCCESS) {
210 TELEPHONY_LOGE("HandleOttEventReportInfo failed! ret:%{public}d", ret);
211 }
212 });
213
214 return TELEPHONY_SUCCESS;
215 }
216
ReceiveImsCallModeRequest(const CallModeReportInfo & response)217 int32_t ReportCallInfoHandler::ReceiveImsCallModeRequest(const CallModeReportInfo &response)
218 {
219 TELEPHONY_LOGI("ReceiveImsCallModeRequest submit task enter");
220 reportCallInfoQueue.submit([response]() {
221 CallModeReportInfo reportInfo = response;
222 sptr<CallBase> call = CallObjectManager::GetOneCallObjectByIndex(response.callIndex);
223 if (call == nullptr) {
224 TELEPHONY_LOGE("call not exists");
225 return;
226 }
227 if (call->GetCallType() == CallType::TYPE_IMS) {
228 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
229 imsCall->RecieveUpdateCallMediaModeRequest(reportInfo);
230 }
231 });
232 return TELEPHONY_SUCCESS;
233 }
234
ReceiveImsCallModeResponse(const CallModeReportInfo & response)235 int32_t ReportCallInfoHandler::ReceiveImsCallModeResponse(const CallModeReportInfo &response)
236 {
237 TELEPHONY_LOGI("ReceiveImsCallModeResponse submit task enter");
238 reportCallInfoQueue.submit([response]() {
239 CallModeReportInfo reportInfo = response;
240 sptr<CallBase> call = nullptr;
241 if (response.slotId != -1) {
242 call = CallObjectManager::GetOneCallObjectByIndexAndSlotId(response.callIndex, response.slotId);
243 }
244 if (call == nullptr) {
245 call = CallObjectManager::GetOneCallObjectByIndex(response.callIndex);
246 }
247 if (call == nullptr) {
248 TELEPHONY_LOGE("call not exists");
249 return;
250 }
251 if (call->GetCallType() == CallType::TYPE_IMS) {
252 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
253 imsCall->ReceiveUpdateCallMediaModeResponse(reportInfo);
254 }
255 });
256 return TELEPHONY_SUCCESS;
257 }
258
UpdateVoipEventInfo(const VoipCallEventInfo & info)259 int32_t ReportCallInfoHandler::UpdateVoipEventInfo(const VoipCallEventInfo &info)
260 {
261 if (callStatusManagerPtr_ == nullptr) {
262 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
263 return TELEPHONY_ERR_LOCAL_PTR_NULL;
264 }
265 VoipCallEventInfo voipCallEventInfo = info;
266 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
267 TELEPHONY_LOGI("UpdateVoipEventInfo submit task enter");
268 reportCallInfoQueue.submit([callStatusManagerPtr, voipCallEventInfo]() {
269 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
270 if (managerPtr == nullptr) {
271 TELEPHONY_LOGE("managerPtr is null");
272 return;
273 }
274 int32_t ret = managerPtr->HandleVoipEventReportInfo(voipCallEventInfo);
275 if (ret != TELEPHONY_SUCCESS) {
276 TELEPHONY_LOGE("UpdateVoipEventInfo failed! ret:%{public}d", ret);
277 }
278 });
279 return TELEPHONY_SUCCESS;
280 }
281 } // namespace Telephony
282 } // namespace OHOS
283