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 "ims_call.h"
23 #include "telephony_log_wrapper.h"
24 #include "antifraud_service.h"
25 #include "thread"
26
27 namespace OHOS {
28 namespace Telephony {
29 namespace {
30 ffrt::queue reportCallInfoQueue { "report_call_info_queue" };
31 }
ReportCallInfoHandler()32 ReportCallInfoHandler::ReportCallInfoHandler() {}
33
~ReportCallInfoHandler()34 ReportCallInfoHandler::~ReportCallInfoHandler() {}
35
Init()36 void ReportCallInfoHandler::Init()
37 {
38 callStatusManagerPtr_ = std::make_shared<CallStatusManager>();
39 callStatusManagerPtr_->Init();
40 DelayedSingleton<AntiFraudService>::GetInstance()->SetCallStatusManager(callStatusManagerPtr_);
41 DelayedSingleton<CallManagerService>::GetInstance()->SetCallStatusManager(callStatusManagerPtr_);
42 return;
43 }
44
UpdateCallReportInfo(const CallDetailInfo & info)45 int32_t ReportCallInfoHandler::UpdateCallReportInfo(const CallDetailInfo &info)
46 {
47 if (callStatusManagerPtr_ == nullptr) {
48 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
49 return TELEPHONY_ERR_LOCAL_PTR_NULL;
50 }
51 CallDetailInfo callDetailInfo = info;
52 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
53 TELEPHONY_LOGW("UpdateCallReportInfo submit task enter");
54 reportCallInfoQueue.submit([callStatusManagerPtr, callDetailInfo]() {
55 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
56 if (managerPtr == nullptr) {
57 TELEPHONY_LOGE("managerPtr is null");
58 return;
59 }
60 auto ret = managerPtr->HandleCallReportInfo(callDetailInfo);
61 if (ret != TELEPHONY_SUCCESS) {
62 TELEPHONY_LOGE("HandleCallReportInfo failed! ret:%{public}d", ret);
63 }
64 });
65 return TELEPHONY_SUCCESS;
66 }
67
BuildCallDetailsInfo(CallDetailsInfo & info,CallDetailsInfo & callDetailsInfo)68 void ReportCallInfoHandler::BuildCallDetailsInfo(CallDetailsInfo &info, CallDetailsInfo &callDetailsInfo)
69 {
70 CallDetailInfo callDetailInfo;
71 std::vector<CallDetailInfo>::iterator iter = info.callVec.begin();
72 for (; iter != info.callVec.end(); ++iter) {
73 callDetailInfo.callType = (*iter).callType;
74 callDetailInfo.accountId = (*iter).accountId;
75 callDetailInfo.state = (*iter).state;
76 callDetailInfo.callMode = (*iter).callMode;
77 callDetailInfo.index = (*iter).index;
78 callDetailInfo.voiceDomain = (*iter).voiceDomain;
79 callDetailInfo.mpty = (*iter).mpty;
80 callDetailInfo.crsType = (*iter).crsType;
81 callDetailInfo.originalCallType = (*iter).originalCallType;
82 (void)memcpy_s(callDetailInfo.phoneNum, kMaxNumberLen, (*iter).phoneNum, kMaxNumberLen);
83 (void)memcpy_s(callDetailInfo.bundleName, kMaxBundleNameLen, (*iter).bundleName, kMaxBundleNameLen);
84 callDetailInfo.name = (*iter).name;
85 callDetailInfo.namePresentation = (*iter).namePresentation;
86 callDetailInfo.reason = (*iter).reason;
87 callDetailsInfo.callVec.push_back(callDetailInfo);
88 }
89 }
90
UpdateCallsReportInfo(CallDetailsInfo & info)91 int32_t ReportCallInfoHandler::UpdateCallsReportInfo(CallDetailsInfo &info)
92 {
93 if (callStatusManagerPtr_ == nullptr) {
94 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
95 return TELEPHONY_ERR_LOCAL_PTR_NULL;
96 }
97 CallDetailsInfo callDetailsInfo;
98 callDetailsInfo.slotId = info.slotId;
99 (void)memcpy_s(callDetailsInfo.bundleName, kMaxBundleNameLen, info.bundleName, kMaxBundleNameLen);
100 BuildCallDetailsInfo(info, callDetailsInfo);
101 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
102 TELEPHONY_LOGW("UpdateCallsReportInfo submit task enter");
103 reportCallInfoQueue.submit([callStatusManagerPtr, callDetailsInfo]() {
104 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
105 if (managerPtr == nullptr) {
106 TELEPHONY_LOGE("managerPtr is null");
107 return;
108 }
109 int32_t ret = managerPtr->HandleCallsReportInfo(callDetailsInfo);
110 if (ret != TELEPHONY_SUCCESS) {
111 TELEPHONY_LOGE("HandleCallsReportInfo failed! ret:%{public}d", ret);
112 }
113 });
114
115 CallDetailInfo detailInfo;
116 detailInfo.state = TelCallState::CALL_STATUS_UNKNOWN;
117 std::vector<CallDetailInfo>::iterator it = info.callVec.begin();
118 for (; it != info.callVec.end(); ++it) {
119 detailInfo.callType = (*it).callType;
120 detailInfo.accountId = (*it).accountId;
121 detailInfo.state = (*it).state;
122 detailInfo.callMode = (*it).callMode;
123 }
124 if (detailInfo.state == TelCallState::CALL_STATUS_INCOMING) {
125 CallManagerHisysevent::WriteIncomingCallFaultEvent(info.slotId, static_cast<int32_t>(detailInfo.callType),
126 static_cast<int32_t>(detailInfo.callMode), CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE,
127 "ID HANDLER_UPDATE_CALL_INFO_LIST");
128 }
129 return TELEPHONY_SUCCESS;
130 }
131
UpdateDisconnectedCause(const DisconnectedDetails & details)132 int32_t ReportCallInfoHandler::UpdateDisconnectedCause(const DisconnectedDetails &details)
133 {
134 if (callStatusManagerPtr_ == nullptr) {
135 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
136 return TELEPHONY_ERR_LOCAL_PTR_NULL;
137 }
138 DisconnectedDetails disconnectedDetails = details;
139 if (static_cast<RilDisconnectedReason>(details.reason) == RilDisconnectedReason::DISCONNECTED_REASON_NORMAL) {
140 disconnectedDetails.reason = DisconnectedReason::NORMAL_CALL_CLEARING;
141 }
142 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
143 TELEPHONY_LOGI("UpdateDisconnectedCause submit task enter");
144 reportCallInfoQueue.submit([callStatusManagerPtr, disconnectedDetails]() {
145 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
146 if (managerPtr == nullptr) {
147 TELEPHONY_LOGE("managerPtr is null");
148 return;
149 }
150 int32_t ret = managerPtr->HandleDisconnectedCause(disconnectedDetails);
151 if (ret != TELEPHONY_SUCCESS) {
152 TELEPHONY_LOGE("HandleDisconnectedCause failed! ret:%{public}d", ret);
153 }
154 });
155
156 return TELEPHONY_SUCCESS;
157 }
158
UpdateEventResultInfo(const CellularCallEventInfo & info)159 int32_t ReportCallInfoHandler::UpdateEventResultInfo(const CellularCallEventInfo &info)
160 {
161 if (callStatusManagerPtr_ == nullptr) {
162 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
163 return TELEPHONY_ERR_LOCAL_PTR_NULL;
164 }
165 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
166 TELEPHONY_LOGI("UpdateEventResultInfo submit task enter");
167 reportCallInfoQueue.submit([callStatusManagerPtr, info]() {
168 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
169 if (managerPtr == nullptr) {
170 TELEPHONY_LOGE("managerPtr is null");
171 return;
172 }
173 int32_t ret = managerPtr->HandleEventResultReportInfo(info);
174 if (ret != TELEPHONY_SUCCESS) {
175 TELEPHONY_LOGE("HandleEventResultReportInfo failed! ret:%{public}d", ret);
176 }
177 });
178
179 return TELEPHONY_SUCCESS;
180 }
181
UpdateOttEventInfo(const OttCallEventInfo & info)182 int32_t ReportCallInfoHandler::UpdateOttEventInfo(const OttCallEventInfo &info)
183 {
184 if (callStatusManagerPtr_ == nullptr) {
185 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
186 return TELEPHONY_ERR_LOCAL_PTR_NULL;
187 }
188 OttCallEventInfo ottCallEventInfo = info;
189 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
190 TELEPHONY_LOGI("UpdateOttEventInfo submit task enter");
191 reportCallInfoQueue.submit([callStatusManagerPtr, ottCallEventInfo]() {
192 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
193 if (managerPtr == nullptr) {
194 TELEPHONY_LOGE("managerPtr is null");
195 return;
196 }
197 int32_t ret = managerPtr->HandleOttEventReportInfo(ottCallEventInfo);
198 if (ret != TELEPHONY_SUCCESS) {
199 TELEPHONY_LOGE("HandleOttEventReportInfo failed! ret:%{public}d", ret);
200 }
201 });
202
203 return TELEPHONY_SUCCESS;
204 }
205
ReceiveImsCallModeRequest(const CallModeReportInfo & response)206 int32_t ReportCallInfoHandler::ReceiveImsCallModeRequest(const CallModeReportInfo &response)
207 {
208 TELEPHONY_LOGI("ReceiveImsCallModeRequest submit task enter");
209 reportCallInfoQueue.submit([response]() {
210 CallModeReportInfo reportInfo = response;
211 sptr<CallBase> call = CallObjectManager::GetOneCallObjectByIndex(response.callIndex);
212 if (call == nullptr) {
213 TELEPHONY_LOGE("call not exists");
214 return;
215 }
216 if (call->GetCallType() == CallType::TYPE_IMS) {
217 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
218 imsCall->RecieveUpdateCallMediaModeRequest(reportInfo);
219 }
220 });
221 return TELEPHONY_SUCCESS;
222 }
223
ReceiveImsCallModeResponse(const CallModeReportInfo & response)224 int32_t ReportCallInfoHandler::ReceiveImsCallModeResponse(const CallModeReportInfo &response)
225 {
226 TELEPHONY_LOGI("ReceiveImsCallModeResponse submit task enter");
227 reportCallInfoQueue.submit([response]() {
228 CallModeReportInfo reportInfo = response;
229 sptr<CallBase> call = nullptr;
230 if (response.slotId != -1) {
231 call = CallObjectManager::GetOneCallObjectByIndexAndSlotId(response.callIndex, response.slotId);
232 }
233 if (call == nullptr) {
234 call = CallObjectManager::GetOneCallObjectByIndex(response.callIndex);
235 }
236 if (call == nullptr) {
237 TELEPHONY_LOGE("call not exists");
238 return;
239 }
240 if (call->GetCallType() == CallType::TYPE_IMS) {
241 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
242 imsCall->ReceiveUpdateCallMediaModeResponse(reportInfo);
243 }
244 });
245 return TELEPHONY_SUCCESS;
246 }
247
UpdateVoipEventInfo(const VoipCallEventInfo & info)248 int32_t ReportCallInfoHandler::UpdateVoipEventInfo(const VoipCallEventInfo &info)
249 {
250 if (callStatusManagerPtr_ == nullptr) {
251 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
252 return TELEPHONY_ERR_LOCAL_PTR_NULL;
253 }
254 VoipCallEventInfo voipCallEventInfo = info;
255 std::weak_ptr<CallStatusManager> callStatusManagerPtr = callStatusManagerPtr_;
256 TELEPHONY_LOGI("UpdateVoipEventInfo submit task enter");
257 reportCallInfoQueue.submit([callStatusManagerPtr, voipCallEventInfo]() {
258 std::shared_ptr<CallStatusManager> managerPtr = callStatusManagerPtr.lock();
259 if (managerPtr == nullptr) {
260 TELEPHONY_LOGE("managerPtr is null");
261 return;
262 }
263 int32_t ret = managerPtr->HandleVoipEventReportInfo(voipCallEventInfo);
264 if (ret != TELEPHONY_SUCCESS) {
265 TELEPHONY_LOGE("UpdateVoipEventInfo failed! ret:%{public}d", ret);
266 }
267 });
268 return TELEPHONY_SUCCESS;
269 }
270 } // namespace Telephony
271 } // namespace OHOS
272