1 /*
2 * Copyright (C) 2021-2022 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 "call_ability_report_proxy.h"
17
18 #include <string_ex.h>
19
20 #include "call_manager_errors.h"
21 #include "iservice_registry.h"
22 #include "system_ability.h"
23 #include "system_ability_definition.h"
24 #include "telephony_log_wrapper.h"
25
26 namespace OHOS {
27 namespace Telephony {
CallAbilityReportProxy()28 CallAbilityReportProxy::CallAbilityReportProxy()
29 {
30 callbackPtrList_.clear();
31 }
32
~CallAbilityReportProxy()33 CallAbilityReportProxy::~CallAbilityReportProxy()
34 {
35 std::lock_guard<std::mutex> lock(mutex_);
36 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
37 while (it != callbackPtrList_.end()) {
38 if ((*it)) {
39 (*it).clear();
40 (*it) = nullptr;
41 }
42 callbackPtrList_.erase(it++);
43 }
44 }
45
RegisterCallBack(sptr<ICallAbilityCallback> callAbilityCallbackPtr,const std::string & bundleName)46 int32_t CallAbilityReportProxy::RegisterCallBack(
47 sptr<ICallAbilityCallback> callAbilityCallbackPtr, const std::string &bundleName)
48 {
49 if (callAbilityCallbackPtr == nullptr) {
50 TELEPHONY_LOGE("callAbilityCallbackPtr is null");
51 return TELEPHONY_ERR_LOCAL_PTR_NULL;
52 }
53 callAbilityCallbackPtr->SetBundleName(bundleName);
54 std::lock_guard<std::mutex> lock(mutex_);
55 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
56 for (; it != callbackPtrList_.end(); ++it) {
57 if ((*it)->GetBundleName() == bundleName) {
58 if (bundleName == "com.huawei.hmos.meetimeservice") {
59 break;
60 }
61 (*it).clear();
62 (*it) = callAbilityCallbackPtr;
63 TELEPHONY_LOGI("%{public}s RegisterCallBack success", bundleName.c_str());
64 return TELEPHONY_SUCCESS;
65 }
66 }
67 callbackPtrList_.emplace_back(callAbilityCallbackPtr);
68 TELEPHONY_LOGI("%{public}s successfully registered the callback for the first time!", bundleName.c_str());
69 return TELEPHONY_SUCCESS;
70 }
71
UnRegisterCallBack(const std::string & bundleName)72 int32_t CallAbilityReportProxy::UnRegisterCallBack(const std::string &bundleName)
73 {
74 if (callbackPtrList_.empty()) {
75 TELEPHONY_LOGE("callbackPtrList_ is null! %{public}s UnRegisterCallBack failed", bundleName.c_str());
76 return TELEPHONY_ERR_LOCAL_PTR_NULL;
77 }
78 std::lock_guard<std::mutex> lock(mutex_);
79 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
80 for (; it != callbackPtrList_.end(); ++it) {
81 if ((*it)->GetBundleName() == bundleName) {
82 callbackPtrList_.erase(it);
83 TELEPHONY_LOGI("%{public}s UnRegisterCallBack success", bundleName.c_str());
84 return TELEPHONY_SUCCESS;
85 }
86 }
87 TELEPHONY_LOGE("UnRegisterCallBack failure!");
88 return TELEPHONY_ERROR;
89 }
90
CallStateUpdated(sptr<CallBase> & callObjectPtr,TelCallState priorState,TelCallState nextState)91 void CallAbilityReportProxy::CallStateUpdated(
92 sptr<CallBase> &callObjectPtr, TelCallState priorState, TelCallState nextState)
93 {
94 if (callObjectPtr == nullptr) {
95 TELEPHONY_LOGE("callObjectPtr is nullptr!");
96 return;
97 }
98 CallAttributeInfo info;
99 callObjectPtr->GetCallAttributeInfo(info);
100 size_t accountLen = strlen(info.accountNumber);
101 if (accountLen > static_cast<size_t>(kMaxNumberLen)) {
102 accountLen = kMaxNumberLen;
103 }
104 for (size_t i = 0; i < accountLen; i++) {
105 if (info.accountNumber[i] == ',' || info.accountNumber[i] == ';') {
106 info.accountNumber[i] = '\0';
107 break;
108 }
109 }
110 if (nextState == TelCallState::CALL_STATUS_ANSWERED) {
111 TELEPHONY_LOGI("report answered state");
112 info.callState = TelCallState::CALL_STATUS_ANSWERED;
113 }
114 ReportCallStateInfo(info);
115 }
116
CallEventUpdated(CallEventInfo & info)117 void CallAbilityReportProxy::CallEventUpdated(CallEventInfo &info)
118 {
119 ReportCallEvent(info);
120 }
121
CallDestroyed(const DisconnectedDetails & details)122 void CallAbilityReportProxy::CallDestroyed(const DisconnectedDetails &details)
123 {
124 int32_t ret = TELEPHONY_ERR_FAIL;
125 std::lock_guard<std::mutex> lock(mutex_);
126 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
127 for (; it != callbackPtrList_.end(); ++it) {
128 if ((*it)) {
129 ret = (*it)->OnCallDisconnectedCause(details);
130 if (ret != TELEPHONY_SUCCESS) {
131 TELEPHONY_LOGW("OnCallDisconnectedCause failed, errcode:%{public}d, bundleName:%{public}s", ret,
132 ((*it)->GetBundleName()).c_str());
133 continue;
134 }
135 }
136 }
137 TELEPHONY_LOGI("report call disconnected cause[%{public}d] success", details.reason);
138 }
139
ReportCallStateInfo(const CallAttributeInfo & info)140 int32_t CallAbilityReportProxy::ReportCallStateInfo(const CallAttributeInfo &info)
141 {
142 int32_t ret = TELEPHONY_ERR_FAIL;
143 std::string bundleName = "";
144 std::lock_guard<std::mutex> lock(mutex_);
145 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
146 for (; it != callbackPtrList_.end(); ++it) {
147 if ((*it)) {
148 bundleName = (*it)->GetBundleName();
149 ret = (*it)->OnCallDetailsChange(info);
150 if (ret != TELEPHONY_SUCCESS) {
151 TELEPHONY_LOGW(
152 "OnCallDetailsChange failed, errcode:%{public}d, bundleName:%{public}s", ret, bundleName.c_str());
153 continue;
154 } else {
155 TELEPHONY_LOGW("OnCallDetailsChange success, bundleName:%{public}s", bundleName.c_str());
156 }
157 }
158 }
159 TELEPHONY_LOGI("report call state info success, callId[%{public}d] state[%{public}d] conferenceState[%{public}d] "
160 "videoState[%{public}d]",
161 info.callId, info.callState, info.conferenceState, info.videoState);
162 return ret;
163 }
164
ReportCallStateInfo(const CallAttributeInfo & info,std::string bundleName)165 int32_t CallAbilityReportProxy::ReportCallStateInfo(const CallAttributeInfo &info, std::string bundleName)
166 {
167 int32_t ret = TELEPHONY_ERROR;
168 for (auto callback : callbackPtrList_) {
169 if (callback->GetBundleName() == bundleName) {
170 ret = callback->OnCallDetailsChange(info);
171 break;
172 }
173 }
174 if (ret != TELEPHONY_SUCCESS) {
175 TELEPHONY_LOGE(
176 "OnCallDetailsChange failed, errcode:%{public}d, bundleName:%{public}s", ret, bundleName.c_str());
177 } else {
178 TELEPHONY_LOGI("callId[%{public}d] state[%{public}d] conferenceState[%{public}d] "
179 "videoState[%{public}d], report bundleName %{public}s success",
180 info.callId, info.callState, info.conferenceState, info.videoState, bundleName.c_str());
181 }
182 return ret;
183 }
184
ReportCallEvent(const CallEventInfo & info)185 int32_t CallAbilityReportProxy::ReportCallEvent(const CallEventInfo &info)
186 {
187 int32_t ret = TELEPHONY_ERR_FAIL;
188 TELEPHONY_LOGI("report call event, eventId:%{public}d", info.eventId);
189 std::lock_guard<std::mutex> lock(mutex_);
190 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
191 for (; it != callbackPtrList_.end(); ++it) {
192 if ((*it)) {
193 ret = (*it)->OnCallEventChange(info);
194 if (ret != TELEPHONY_SUCCESS) {
195 TELEPHONY_LOGW("OnCallEventChange failed, errcode:%{public}d, bundleName:%{public}s", ret,
196 ((*it)->GetBundleName()).c_str());
197 continue;
198 }
199 }
200 }
201 TELEPHONY_LOGI("report call event[%{public}d] info success", info.eventId);
202 return ret;
203 }
204
ReportAsyncResults(const CallResultReportId reportId,AppExecFwk::PacMap & resultInfo)205 int32_t CallAbilityReportProxy::ReportAsyncResults(
206 const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo)
207 {
208 int32_t ret = TELEPHONY_ERR_FAIL;
209 std::lock_guard<std::mutex> lock(mutex_);
210 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
211 for (; it != callbackPtrList_.end(); ++it) {
212 if ((*it)) {
213 ret = (*it)->OnReportAsyncResults(reportId, resultInfo);
214 if (ret != TELEPHONY_SUCCESS) {
215 TELEPHONY_LOGW("ReportAsyncResults failed, errcode:%{public}d, bundleName:%{public}s", ret,
216 ((*it)->GetBundleName()).c_str());
217 continue;
218 }
219 }
220 }
221 TELEPHONY_LOGI("ReportAsyncResults success, reportId:%{public}d", reportId);
222 return ret;
223 }
224
ReportMmiCodeResult(const MmiCodeInfo & info)225 int32_t CallAbilityReportProxy::ReportMmiCodeResult(const MmiCodeInfo &info)
226 {
227 int32_t ret = TELEPHONY_ERR_FAIL;
228 std::lock_guard<std::mutex> lock(mutex_);
229 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
230 for (; it != callbackPtrList_.end(); ++it) {
231 if ((*it)) {
232 ret = (*it)->OnReportMmiCodeResult(info);
233 if (ret != TELEPHONY_SUCCESS) {
234 TELEPHONY_LOGW("ReportMmiCodeResult failed, errcode:%{public}d, bundleName:%{public}s", ret,
235 ((*it)->GetBundleName()).c_str());
236 continue;
237 }
238 }
239 }
240 TELEPHONY_LOGI("ReportMmiCodeResult success");
241 return ret;
242 }
243
OttCallRequest(OttCallRequestId requestId,AppExecFwk::PacMap & info)244 int32_t CallAbilityReportProxy::OttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
245 {
246 int32_t ret = TELEPHONY_ERR_FAIL;
247 std::lock_guard<std::mutex> lock(mutex_);
248 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
249 for (; it != callbackPtrList_.end(); ++it) {
250 std::string name = (*it)->GetBundleName();
251 if (name == "com.ohos.callservice") {
252 ret = (*it)->OnOttCallRequest(requestId, info);
253 if (ret != TELEPHONY_SUCCESS) {
254 TELEPHONY_LOGW(
255 "OttCallRequest failed, errcode:%{public}d, bundleName:%{public}s", ret, name.c_str());
256 break;
257 }
258 }
259 }
260 TELEPHONY_LOGI("OttCallRequest success, requestId:%{public}d", requestId);
261 return ret;
262 }
263
ReportAudioDeviceChange(const AudioDeviceInfo & info)264 int32_t CallAbilityReportProxy::ReportAudioDeviceChange(const AudioDeviceInfo &info)
265 {
266 int32_t ret = TELEPHONY_ERR_FAIL;
267 std::lock_guard<std::mutex> lock(mutex_);
268 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
269 for (; it != callbackPtrList_.end(); ++it) {
270 if ((*it)) {
271 ret = (*it)->OnReportAudioDeviceChange(info);
272 if (ret != TELEPHONY_SUCCESS) {
273 TELEPHONY_LOGW("ReportAudioDeviceChange failed, errcode:%{public}d, bundleName:%{public}s", ret,
274 ((*it)->GetBundleName()).c_str());
275 continue;
276 }
277 }
278 }
279 TELEPHONY_LOGI("ReportAudioDeviceChange success");
280 return ret;
281 }
282
ReportPostDialDelay(const std::string & str)283 int32_t CallAbilityReportProxy::ReportPostDialDelay(const std::string &str)
284 {
285 int32_t ret = TELEPHONY_ERR_FAIL;
286 std::lock_guard<std::mutex> lock(mutex_);
287 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
288 for (; it != callbackPtrList_.end(); ++it) {
289 if ((*it)) {
290 ret = (*it)->OnReportPostDialDelay(str);
291 if (ret != TELEPHONY_SUCCESS) {
292 TELEPHONY_LOGW("ReportPostDialDelay failed, errcode:%{public}d, bundleName:%{public}s", ret,
293 ((*it)->GetBundleName()).c_str());
294 continue;
295 }
296 }
297 }
298 TELEPHONY_LOGI("ReportPostDialDelay success");
299 return ret;
300 }
301
ReportImsCallModeChange(const CallMediaModeInfo & imsCallModeInfo)302 int32_t CallAbilityReportProxy::ReportImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo)
303 {
304 int32_t ret = TELEPHONY_ERR_FAIL;
305 std::lock_guard<std::mutex> lock(mutex_);
306 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
307 for (; it != callbackPtrList_.end(); ++it) {
308 if ((*it)) {
309 ret = (*it)->OnReportImsCallModeChange(imsCallModeInfo);
310 if (ret != TELEPHONY_SUCCESS) {
311 TELEPHONY_LOGW("ReportImsCallModeReceive failed, errcode:%{public}d, bundleName:%{public}s", ret,
312 ((*it)->GetBundleName()).c_str());
313 continue;
314 }
315 }
316 }
317 TELEPHONY_LOGI("ReportImsCallModeReceive success");
318 return ret;
319 }
320
ReportCallSessionEventChange(const CallSessionEvent & callSessionEventOptions)321 int32_t CallAbilityReportProxy::ReportCallSessionEventChange(
322 const CallSessionEvent &callSessionEventOptions)
323 {
324 int32_t ret = TELEPHONY_ERR_FAIL;
325 std::lock_guard<std::mutex> lock(mutex_);
326 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
327 for (; it != callbackPtrList_.end(); ++it) {
328 if ((*it)) {
329 ret = (*it)->OnReportCallSessionEventChange(callSessionEventOptions);
330 if (ret != TELEPHONY_SUCCESS) {
331 TELEPHONY_LOGW("ReportCallSessionEventChange failed, errcode:%{public}d, bundleName:%{public}s", ret,
332 ((*it)->GetBundleName()).c_str());
333 continue;
334 }
335 }
336 }
337 TELEPHONY_LOGI("ReportCallSessionEventChange success");
338 return ret;
339 }
340
ReportPeerDimensionsChange(const PeerDimensionsDetail & peerDimensionsDetail)341 int32_t CallAbilityReportProxy::ReportPeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail)
342 {
343 int32_t ret = TELEPHONY_ERR_FAIL;
344 std::lock_guard<std::mutex> lock(mutex_);
345 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
346 for (; it != callbackPtrList_.end(); ++it) {
347 if ((*it)) {
348 ret = (*it)->OnReportPeerDimensionsChange(peerDimensionsDetail);
349 if (ret != TELEPHONY_SUCCESS) {
350 TELEPHONY_LOGW("ReportPeerDimensionsChange failed, errcode:%{public}d, bundleName:%{public}s", ret,
351 ((*it)->GetBundleName()).c_str());
352 continue;
353 }
354 }
355 }
356 TELEPHONY_LOGI("ReportPeerDimensionsChange success");
357 return ret;
358 }
359
ReportCallDataUsageChange(const int64_t dataUsage)360 int32_t CallAbilityReportProxy::ReportCallDataUsageChange(const int64_t dataUsage)
361 {
362 int32_t ret = TELEPHONY_ERR_FAIL;
363 std::lock_guard<std::mutex> lock(mutex_);
364 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
365 for (; it != callbackPtrList_.end(); ++it) {
366 if ((*it)) {
367 ret = (*it)->OnReportCallDataUsageChange(dataUsage);
368 if (ret != TELEPHONY_SUCCESS) {
369 TELEPHONY_LOGW("ReportCallDataUsageChange failed, errcode:%{public}d, bundleName:%{public}s", ret,
370 ((*it)->GetBundleName()).c_str());
371 continue;
372 }
373 }
374 }
375 TELEPHONY_LOGI("ReportCallDataUsageChange success");
376 return ret;
377 }
378
ReportCameraCapabilities(const CameraCapabilities & cameraCapabilities)379 int32_t CallAbilityReportProxy::ReportCameraCapabilities(const CameraCapabilities &cameraCapabilities)
380 {
381 int32_t ret = TELEPHONY_ERR_FAIL;
382 std::lock_guard<std::mutex> lock(mutex_);
383 std::list<sptr<ICallAbilityCallback>>::iterator it = callbackPtrList_.begin();
384 for (; it != callbackPtrList_.end(); ++it) {
385 if ((*it)) {
386 ret = (*it)->OnReportCameraCapabilities(cameraCapabilities);
387 if (ret != TELEPHONY_SUCCESS) {
388 TELEPHONY_LOGW("ReportCameraCapabilities failed, errcode:%{public}d, bundleName:%{public}s", ret,
389 ((*it)->GetBundleName()).c_str());
390 continue;
391 }
392 }
393 }
394 TELEPHONY_LOGI("ReportCameraCapabilities success");
395 return ret;
396 }
397 } // namespace Telephony
398 } // namespace OHOS
399