1 /*
2 * Copyright (C) 2021 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 "telephony_log_wrapper.h"
20 #include "ims_call.h"
21
22 namespace OHOS {
23 namespace Telephony {
ReportCallInfoHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner)24 ReportCallInfoHandler::ReportCallInfoHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner)
25 : AppExecFwk::EventHandler(runner)
26 {
27 memberFuncMap_[ReportCallInfoHandlerService::HANDLER_UPDATE_CELLULAR_CALL_INFO] =
28 &ReportCallInfoHandler::ReportCallInfo;
29 memberFuncMap_[ReportCallInfoHandlerService::HANDLER_UPDATE_CALL_INFO_LIST] =
30 &ReportCallInfoHandler::ReportCallsInfo;
31 memberFuncMap_[ReportCallInfoHandlerService::HANDLER_UPDATE_DISCONNECTED_CAUSE] =
32 &ReportCallInfoHandler::ReportDisconnectedCause;
33 memberFuncMap_[ReportCallInfoHandlerService::HANDLER_UPDATE_CELLULAR_EVENT_RESULT_INFO] =
34 &ReportCallInfoHandler::ReportEventInfo;
35 memberFuncMap_[ReportCallInfoHandlerService::HANDLER_UPDATE_OTT_EVENT_RESULT_INFO] =
36 &ReportCallInfoHandler::ReportOttEvent;
37 memberFuncMap_[ReportCallInfoHandlerService::HANDLE_UPDATE_MEDIA_MODE_RESPONSE] =
38 &ReportCallInfoHandler::OnUpdateMediaModeResponse;
39 }
40
~ReportCallInfoHandler()41 ReportCallInfoHandler::~ReportCallInfoHandler()
42 {
43 if (callStatusManagerPtr_) {
44 callStatusManagerPtr_ = nullptr;
45 }
46 }
47
Init()48 void ReportCallInfoHandler::Init()
49 {
50 callStatusManagerPtr_ = std::make_unique<CallStatusManager>();
51 if (callStatusManagerPtr_ == nullptr) {
52 TELEPHONY_LOGE("callStatusManagerPtr_ is null");
53 return;
54 }
55 callStatusManagerPtr_->Init();
56 }
57
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)58 void ReportCallInfoHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
59 {
60 if (event == nullptr) {
61 TELEPHONY_LOGE("ReportCallInfoHandler::ProcessEvent parameter error");
62 return;
63 }
64 TELEPHONY_LOGI("ReportCallInfoHandler::ProcessEvent inner event id: %{public}u.", event->GetInnerEventId());
65 auto itFunc = memberFuncMap_.find(event->GetInnerEventId());
66 if (itFunc != memberFuncMap_.end()) {
67 auto memberFunc = itFunc->second;
68 if (memberFunc != nullptr) {
69 return (this->*memberFunc)(event);
70 }
71 }
72 }
73
ReportCallInfo(const AppExecFwk::InnerEvent::Pointer & event)74 void ReportCallInfoHandler::ReportCallInfo(const AppExecFwk::InnerEvent::Pointer &event)
75 {
76 auto object = event->GetUniqueObject<CallDetailInfo>();
77 if (object == nullptr) {
78 TELEPHONY_LOGE("object is nullptr!");
79 return;
80 }
81 CallDetailInfo info = *object;
82 if (callStatusManagerPtr_ == nullptr) {
83 TELEPHONY_LOGE("callStatusManagerPtr_ is nullptr");
84 return;
85 }
86 int32_t ret = callStatusManagerPtr_->HandleCallReportInfo(info);
87 if (ret != TELEPHONY_SUCCESS) {
88 TELEPHONY_LOGE("HandleCallReportInfo failed! ret:%{public}d", ret);
89 return;
90 }
91 TELEPHONY_LOGI("HandleCallReportInfo success!");
92 }
93
ReportCallsInfo(const AppExecFwk::InnerEvent::Pointer & event)94 void ReportCallInfoHandler::ReportCallsInfo(const AppExecFwk::InnerEvent::Pointer &event)
95 {
96 auto object = event->GetUniqueObject<CallDetailsInfo>();
97 if (object == nullptr) {
98 TELEPHONY_LOGE("object is nullptr!");
99 return;
100 }
101 CallDetailsInfo info = *object;
102 if (callStatusManagerPtr_ == nullptr) {
103 TELEPHONY_LOGE("callStatusManagerPtr_ is nullptr");
104 return;
105 }
106 int32_t ret = callStatusManagerPtr_->HandleCallsReportInfo(info);
107 if (ret != TELEPHONY_SUCCESS) {
108 TELEPHONY_LOGE("HandleCallsReportInfo failed! ret:%{public}d", ret);
109 return;
110 }
111 TELEPHONY_LOGI("HandleCallsReportInfo success!");
112 }
113
ReportDisconnectedCause(const AppExecFwk::InnerEvent::Pointer & event)114 void ReportCallInfoHandler::ReportDisconnectedCause(const AppExecFwk::InnerEvent::Pointer &event)
115 {
116 auto object = event->GetUniqueObject<int32_t>();
117 if (object == nullptr) {
118 TELEPHONY_LOGE("object is nullptr!");
119 return;
120 }
121 int32_t cause = *object;
122 if (callStatusManagerPtr_ == nullptr) {
123 TELEPHONY_LOGE("callStatusManagerPtr_ is nullptr");
124 return;
125 }
126 int32_t ret = callStatusManagerPtr_->HandleDisconnectedCause(cause);
127 if (ret != TELEPHONY_SUCCESS) {
128 TELEPHONY_LOGE("HandleDisconnectedCause failed! ret:%{public}d", ret);
129 return;
130 }
131 TELEPHONY_LOGI("HandleDisconnectedCause success!");
132 }
133
ReportEventInfo(const AppExecFwk::InnerEvent::Pointer & event)134 void ReportCallInfoHandler::ReportEventInfo(const AppExecFwk::InnerEvent::Pointer &event)
135 {
136 auto object = event->GetUniqueObject<CellularCallEventInfo>();
137 if (object == nullptr) {
138 TELEPHONY_LOGE("object is nullptr!");
139 return;
140 }
141 CellularCallEventInfo info = *object;
142 if (callStatusManagerPtr_ == nullptr) {
143 TELEPHONY_LOGE("callStatusManagerPtr_ is nullptr");
144 return;
145 }
146 int32_t ret = callStatusManagerPtr_->HandleEventResultReportInfo(info);
147 if (ret != TELEPHONY_SUCCESS) {
148 TELEPHONY_LOGE("HandleEventResultReportInfo failed! ret:%{public}d", ret);
149 return;
150 }
151 TELEPHONY_LOGI("HandleEventResultReportInfo success!");
152 }
153
ReportOttEvent(const AppExecFwk::InnerEvent::Pointer & event)154 void ReportCallInfoHandler::ReportOttEvent(const AppExecFwk::InnerEvent::Pointer &event)
155 {
156 auto object = event->GetUniqueObject<OttCallEventInfo>();
157 if (object == nullptr) {
158 TELEPHONY_LOGE("object is nullptr!");
159 return;
160 }
161 OttCallEventInfo info = *object;
162 if (callStatusManagerPtr_ == nullptr) {
163 TELEPHONY_LOGE("callStatusManagerPtr_ is nullptr");
164 return;
165 }
166 int32_t ret = callStatusManagerPtr_->HandleOttEventReportInfo(info);
167 if (ret != TELEPHONY_SUCCESS) {
168 TELEPHONY_LOGE("HandleOttEventReportInfo failed! ret:%{public}d", ret);
169 return;
170 }
171 TELEPHONY_LOGI("HandleOttEventReportInfo success!");
172 }
173
OnUpdateMediaModeResponse(const AppExecFwk::InnerEvent::Pointer & event)174 void ReportCallInfoHandler::OnUpdateMediaModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
175 {
176 auto object = event->GetUniqueObject<CallMediaModeResponse>();
177 if (object == nullptr) {
178 TELEPHONY_LOGE("object is nullptr!");
179 return;
180 }
181 std::string phoneNumber(object->phoneNum);
182 sptr<CallBase> call = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
183 if (call == nullptr) {
184 TELEPHONY_LOGE("call not exists");
185 return;
186 }
187 if (call->GetCallType() == CallType::TYPE_IMS) {
188 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
189 imsCall->ReceiveUpdateCallMediaModeResponse(*object);
190 }
191 return;
192 }
193
ReportCallInfoHandlerService()194 ReportCallInfoHandlerService::ReportCallInfoHandlerService() : eventLoop_(nullptr), handler_(nullptr) {}
195
~ReportCallInfoHandlerService()196 ReportCallInfoHandlerService::~ReportCallInfoHandlerService()
197 {
198 if (eventLoop_ != nullptr) {
199 eventLoop_->Stop();
200 eventLoop_ = nullptr;
201 }
202 handler_ = nullptr;
203 }
204
Start()205 void ReportCallInfoHandlerService::Start()
206 {
207 eventLoop_ = AppExecFwk::EventRunner::Create("ReportCallInfoHandlerService");
208 if (eventLoop_.get() == nullptr) {
209 TELEPHONY_LOGE("failed to create EventRunner");
210 return;
211 }
212 handler_ = std::make_shared<ReportCallInfoHandler>(eventLoop_);
213 if (handler_.get() == nullptr) {
214 TELEPHONY_LOGE("failed to create ReportCallInfoHandler");
215 return;
216 }
217 handler_->Init();
218 eventLoop_->Run();
219 return;
220 }
221
UpdateCallReportInfo(const CallDetailInfo & info)222 int32_t ReportCallInfoHandlerService::UpdateCallReportInfo(const CallDetailInfo &info)
223 {
224 if (handler_.get() == nullptr) {
225 TELEPHONY_LOGE("handler_ is nullptr");
226 return TELEPHONY_ERR_LOCAL_PTR_NULL;
227 }
228 std::unique_ptr<CallDetailInfo> para = std::make_unique<CallDetailInfo>();
229 if (para.get() == nullptr) {
230 TELEPHONY_LOGE("make_unique CallDetailInfo failed!");
231 return TELEPHONY_ERR_LOCAL_PTR_NULL;
232 }
233 *para = info;
234 bool ret = handler_->SendEvent(HANDLER_UPDATE_CELLULAR_CALL_INFO, std::move(para));
235 if (!ret) {
236 TELEPHONY_LOGE("SendEvent failed! status update failed, state:%{public}d", info.state);
237 }
238 return TELEPHONY_SUCCESS;
239 }
240
UpdateCallsReportInfo(CallDetailsInfo & info)241 int32_t ReportCallInfoHandlerService::UpdateCallsReportInfo(CallDetailsInfo &info)
242 {
243 if (handler_.get() == nullptr) {
244 TELEPHONY_LOGE("handler_ is nullptr");
245 return TELEPHONY_ERR_LOCAL_PTR_NULL;
246 }
247 std::unique_ptr<CallDetailsInfo> para = std::make_unique<CallDetailsInfo>();
248 if (para.get() == nullptr) {
249 TELEPHONY_LOGE("make_unique CallDetailsInfo failed!");
250 return TELEPHONY_ERR_LOCAL_PTR_NULL;
251 }
252 *para = info;
253 bool ret = handler_->SendEvent(HANDLER_UPDATE_CALL_INFO_LIST, std::move(para));
254 if (!ret) {
255 TELEPHONY_LOGE("SendEvent failed! status update failed, slotId:%{public}d", info.slotId);
256 }
257 return TELEPHONY_SUCCESS;
258 }
259
UpdateDisconnectedCause(const DisconnectedDetails & cause)260 int32_t ReportCallInfoHandlerService::UpdateDisconnectedCause(const DisconnectedDetails &cause)
261 {
262 if (handler_.get() == nullptr) {
263 TELEPHONY_LOGE("handler_ is nullptr");
264 return TELEPHONY_ERR_LOCAL_PTR_NULL;
265 }
266 std::unique_ptr<int32_t> para = std::make_unique<int32_t>();
267 if (para.get() == nullptr) {
268 TELEPHONY_LOGE("make_unique int32_t failed!");
269 return TELEPHONY_ERR_LOCAL_PTR_NULL;
270 }
271 *para = static_cast<int32_t>(cause);
272 bool ret = handler_->SendEvent(HANDLER_UPDATE_DISCONNECTED_CAUSE, std::move(para));
273 if (!ret) {
274 TELEPHONY_LOGE("SendEvent failed! DisconnectedDetails:%{public}d", cause);
275 }
276 TELEPHONY_LOGI("UpdateDisconnectedCause success, cause:%{public}d", cause);
277 return TELEPHONY_SUCCESS;
278 }
279
UpdateEventResultInfo(const CellularCallEventInfo & info)280 int32_t ReportCallInfoHandlerService::UpdateEventResultInfo(const CellularCallEventInfo &info)
281 {
282 if (handler_.get() == nullptr) {
283 TELEPHONY_LOGE("handler_ is nullptr");
284 return TELEPHONY_ERR_LOCAL_PTR_NULL;
285 }
286 std::unique_ptr<CellularCallEventInfo> para = std::make_unique<CellularCallEventInfo>();
287 if (para.get() == nullptr) {
288 TELEPHONY_LOGE("make_unique CellularCallEventInfo failed!");
289 return TELEPHONY_ERR_LOCAL_PTR_NULL;
290 }
291 *para = info;
292 bool ret = handler_->SendEvent(HANDLER_UPDATE_CELLULAR_EVENT_RESULT_INFO, std::move(para));
293 if (!ret) {
294 TELEPHONY_LOGE("SendEvent failed! eventType:%{public}d, eventId:%{public}d", info.eventType, info.eventId);
295 }
296 return TELEPHONY_SUCCESS;
297 }
298
UpdateOttEventInfo(const OttCallEventInfo & info)299 int32_t ReportCallInfoHandlerService::UpdateOttEventInfo(const OttCallEventInfo &info)
300 {
301 if (handler_.get() == nullptr) {
302 TELEPHONY_LOGE("handler_ is nullptr");
303 return TELEPHONY_ERR_LOCAL_PTR_NULL;
304 }
305 std::unique_ptr<OttCallEventInfo> para = std::make_unique<OttCallEventInfo>();
306 if (para.get() == nullptr) {
307 TELEPHONY_LOGE("make_unique OttCallEventInfo failed!");
308 return TELEPHONY_ERR_LOCAL_PTR_NULL;
309 }
310 if (memcpy_s(para->bundleName, kMaxBundleNameLen, 0, kMaxBundleNameLen) != EOK) {
311 TELEPHONY_LOGE("memcpy_s para->phoneNum failed!");
312 return TELEPHONY_ERR_MEMSET_FAIL;
313 }
314 para->ottCallEventId = info.ottCallEventId;
315 bool ret = handler_->SendEvent(HANDLER_UPDATE_OTT_EVENT_RESULT_INFO, std::move(para));
316 if (!ret) {
317 TELEPHONY_LOGE("SendEvent failed! eventId:%{public}d", info.ottCallEventId);
318 }
319 return TELEPHONY_SUCCESS;
320 }
321
UpdateMediaModeResponse(const CallMediaModeResponse & response)322 int32_t ReportCallInfoHandlerService::UpdateMediaModeResponse(const CallMediaModeResponse &response)
323 {
324 if (handler_.get() == nullptr) {
325 TELEPHONY_LOGE("handler_ is nullptr");
326 return TELEPHONY_ERR_LOCAL_PTR_NULL;
327 }
328 std::unique_ptr<CallMediaModeResponse> para = std::make_unique<CallMediaModeResponse>();
329 if (para.get() == nullptr) {
330 TELEPHONY_LOGE("make_unique CellularCallEventInfo failed!");
331 return TELEPHONY_ERR_LOCAL_PTR_NULL;
332 }
333 (void)memcpy_s(para->phoneNum, kMaxNumberLen, 0, kMaxNumberLen);
334 para->result = response.result;
335 bool ret = handler_->SendEvent(HANDLE_UPDATE_MEDIA_MODE_RESPONSE, std::move(para));
336 if (!ret) {
337 TELEPHONY_LOGE("SendEvent failed! errno: %{public}d", ret);
338 }
339 return TELEPHONY_SUCCESS;
340 }
341 } // namespace Telephony
342 } // namespace OHOS
343