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_manager_proxy.h"
17
18 #include "iservice_registry.h"
19 #include "system_ability.h"
20 #include "system_ability_definition.h"
21
22 #include "call_manager_errors.h"
23 #include "telephony_log_wrapper.h"
24 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
25 #include "core_manager_inner.h"
26 #endif
27
28 namespace OHOS {
29 namespace Telephony {
CallManagerProxy()30 CallManagerProxy::CallManagerProxy()
31 : systemAbilityId_(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID), registerStatus_(false), initStatus_(false)
32 {}
33
34 CallManagerProxy::~CallManagerProxy() = default;
35
36 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
IsServiceStart()37 bool CallManagerProxy::IsServiceStart()
38 {
39 sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
40 if (managerPtr == nullptr) {
41 TELEPHONY_LOGE("GetSystemAbilityManager failed!");
42 return false;
43 }
44 if (managerPtr->CheckSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID) == nullptr) {
45 return false;
46 }
47 return true;
48 }
49
SetInitState(bool status)50 void CallManagerProxy::SetInitState(bool status)
51 {
52 initStatus_ = status;
53 }
54
GetCallBack()55 std::unique_ptr<CallManagerCallback> CallManagerProxy::GetCallBack()
56 {
57 return std::move(callBack_);
58 }
59 #endif
60
Init(int32_t systemAbilityId)61 void CallManagerProxy::Init(int32_t systemAbilityId)
62 {
63 std::lock_guard<std::mutex> lock(mutex_);
64 if (initStatus_) {
65 TELEPHONY_LOGW("you have already initialized");
66 return;
67 }
68 systemAbilityId_ = systemAbilityId;
69 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
70 if (!IsServiceStart()) {
71 EventFwk::MatchingSkills matchingSkills;
72 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_RADIO_STATE_CHANGE);
73 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
74 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
75 std::shared_ptr<CallManagerProxySubcribed> subscriberPtr =
76 std::make_shared<CallManagerProxySubcribed>(subscriberInfo);
77
78 if (subscriberPtr == nullptr) {
79 TELEPHONY_LOGE("CallManagerProxy::Init subscriberPtr is nullptr");
80 return;
81 }
82
83 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr);
84 TELEPHONY_LOGI("CallManagerProxy::Init subscribeResult = %{public}d", subscribeResult);
85 return;
86 }
87 #endif
88 int32_t result = ConnectService();
89 if (result != TELEPHONY_SUCCESS) {
90 TELEPHONY_LOGE("connect service failed,errCode: %{public}d", result);
91 return;
92 }
93 initStatus_ = true;
94 TELEPHONY_LOGI("connected to call manager service successfully!");
95 }
96
97 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
CallManagerProxySubcribed(const EventFwk::CommonEventSubscribeInfo & subscriberInfo)98 CallManagerProxy::CallManagerProxySubcribed::CallManagerProxySubcribed(
99 const EventFwk::CommonEventSubscribeInfo &subscriberInfo)
100 : CommonEventSubscriber(subscriberInfo)
101 {}
102
OnReceiveEvent(const EventFwk::CommonEventData & data)103 void CallManagerProxy::CallManagerProxySubcribed::OnReceiveEvent(const EventFwk::CommonEventData &data)
104 {
105 std::shared_ptr<CallManagerProxy> proxy = DelayedSingleton<CallManagerProxy>::GetInstance();
106 if (proxy == nullptr) {
107 TELEPHONY_LOGE("proxy is nullptr");
108 return;
109 }
110 int32_t result = proxy->ConnectService();
111 if (result != TELEPHONY_SUCCESS) {
112 TELEPHONY_LOGE("OnReceiveEvent connect service failed,errCode: %{public}d", result);
113 return;
114 }
115 result = proxy->RegisterCallBack(proxy->GetCallBack());
116 if (result != TELEPHONY_SUCCESS) {
117 TELEPHONY_LOGE("OnReceiveEvent register callback failed,errCode: %{public}d", result);
118 return;
119 }
120 proxy->SetInitState(true);
121 TELEPHONY_LOGI("OnReceiveEvent connected to call manager service successfully!");
122 bool unsubscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(shared_from_this());
123 TELEPHONY_LOGI("OnReceiveEvent UnSubscribeCommonEvent unsubscribeResult: %{public}d", unsubscribeResult);
124 }
125 #endif
126
UnInit()127 void CallManagerProxy::UnInit()
128 {
129 DisconnectService();
130 std::lock_guard<std::mutex> lock(mutex_);
131 initStatus_ = false;
132 TELEPHONY_LOGI("disconnect service\n");
133 }
134
135 /**
136 * Register a callback with the CallManager, through which the CallManager's data is notified to the NAPI.
137 */
RegisterCallBack(std::unique_ptr<CallManagerCallback> callback)138 int32_t CallManagerProxy::RegisterCallBack(std::unique_ptr<CallManagerCallback> callback)
139 {
140 std::lock_guard<std::mutex> lock(mutex_);
141 if (registerStatus_) {
142 TELEPHONY_LOGE("you have already register callback yet!");
143 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
144 }
145 if (callManagerServicePtr_ == nullptr) {
146 TELEPHONY_LOGE("callManagerServicePtr_ is null");
147 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
148 callBack_ = std::move(callback);
149 #endif
150 return TELEPHONY_ERR_LOCAL_PTR_NULL;
151 }
152 callAbilityCallbackPtr_ = new (std::nothrow) CallAbilityCallback();
153 if (callAbilityCallbackPtr_ == nullptr) {
154 TELEPHONY_LOGE("create CallAbilityCallback object failed!");
155 return TELEPHONY_ERR_LOCAL_PTR_NULL;
156 }
157 int32_t ret = callManagerServicePtr_->RegisterCallBack(callAbilityCallbackPtr_);
158 if (ret != TELEPHONY_SUCCESS) {
159 callAbilityCallbackPtr_.clear();
160 callAbilityCallbackPtr_ = nullptr;
161 TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
162 if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
163 return TELEPHONY_ERR_PERMISSION_ERR;
164 } else if (ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API) {
165 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
166 }
167 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
168 }
169 TELEPHONY_LOGI("register call ability callback success!");
170 callAbilityCallbackPtr_->SetProcessCallback(std::move(callback));
171 registerStatus_ = true;
172 return TELEPHONY_SUCCESS;
173 }
174
UnRegisterCallBack()175 int32_t CallManagerProxy::UnRegisterCallBack()
176 {
177 std::lock_guard<std::mutex> lock(mutex_);
178 if (!registerStatus_) {
179 TELEPHONY_LOGE("you haven't register callback yet, please RegisterCallBack first!");
180 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
181 }
182 if (callManagerServicePtr_ == nullptr) {
183 TELEPHONY_LOGE("callManagerServicePtr_ is null");
184 return TELEPHONY_ERR_LOCAL_PTR_NULL;
185 }
186 int32_t ret = callManagerServicePtr_->UnRegisterCallBack();
187 if (ret != TELEPHONY_SUCCESS) {
188 TELEPHONY_LOGE("UnRegisterCallBack failed,result: %{public}d", ret);
189 if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
190 return TELEPHONY_ERR_PERMISSION_ERR;
191 } else if (ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API) {
192 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
193 }
194 return TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL;
195 }
196 if (callAbilityCallbackPtr_ == nullptr) {
197 TELEPHONY_LOGE("callAbilityCallbackPtr_ is nullptr!");
198 return TELEPHONY_ERR_LOCAL_PTR_NULL;
199 }
200 callAbilityCallbackPtr_.clear();
201 callAbilityCallbackPtr_ = nullptr;
202 registerStatus_ = false;
203 TELEPHONY_LOGI("UnRegisterCallBack success!");
204 return TELEPHONY_SUCCESS;
205 }
206
ConnectService()207 int32_t CallManagerProxy::ConnectService()
208 {
209 Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
210 if (callManagerServicePtr_ != nullptr) {
211 return TELEPHONY_SUCCESS;
212 }
213 sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
214 if (managerPtr == nullptr) {
215 TELEPHONY_LOGE("GetSystemAbilityManager failed!");
216 return TELEPHONY_ERR_LOCAL_PTR_NULL;
217 }
218 sptr<ICallManagerService> callManagerServicePtr = nullptr;
219 sptr<IRemoteObject> iRemoteObjectPtr = managerPtr->GetSystemAbility(systemAbilityId_);
220 if (iRemoteObjectPtr == nullptr) {
221 TELEPHONY_LOGE("GetSystemAbility failed!");
222 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
223 }
224
225 std::unique_ptr<CallManagerServiceDeathRecipient> recipient =
226 std::make_unique<CallManagerServiceDeathRecipient>(*this);
227 if (recipient == nullptr) {
228 TELEPHONY_LOGE("recipient is null");
229 return TELEPHONY_ERROR;
230 }
231 sptr<IRemoteObject::DeathRecipient> dr(recipient.release());
232 if ((iRemoteObjectPtr->IsProxyObject()) && (!iRemoteObjectPtr->AddDeathRecipient(dr))) {
233 TELEPHONY_LOGE("Failed to add death recipient");
234 return TELEPHONY_ERROR;
235 }
236 callManagerServicePtr = iface_cast<ICallManagerService>(iRemoteObjectPtr);
237 if (!callManagerServicePtr) {
238 TELEPHONY_LOGE("iface_cast<ICallManagerService> failed!");
239 return TELEPHONY_ERR_LOCAL_PTR_NULL;
240 }
241 callManagerServicePtr_ = callManagerServicePtr;
242 deathRecipient_ = dr;
243 return TELEPHONY_SUCCESS;
244 }
245
DisconnectService()246 void CallManagerProxy::DisconnectService()
247 {
248 UnRegisterCallBack();
249 Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
250 if (callManagerServicePtr_ != nullptr) {
251 callManagerServicePtr_.clear();
252 callManagerServicePtr_ = nullptr;
253 }
254 }
255
ReConnectService()256 int32_t CallManagerProxy::ReConnectService()
257 {
258 if (callManagerServicePtr_ == nullptr) {
259 TELEPHONY_LOGI("try to reconnect call manager service now...");
260 int32_t result = ConnectService();
261 if (result != TELEPHONY_SUCCESS) {
262 TELEPHONY_LOGE("Connect service: %{public}d", result);
263 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
264 }
265 if (registerStatus_) {
266 ReRegisterCallBack();
267 }
268 }
269 return TELEPHONY_SUCCESS;
270 }
271
ReRegisterCallBack()272 int32_t CallManagerProxy::ReRegisterCallBack()
273 {
274 std::lock_guard<std::mutex> lock(mutex_);
275 if (callManagerServicePtr_ == nullptr) {
276 TELEPHONY_LOGE("callManagerServicePtr_ is null");
277 return TELEPHONY_ERR_LOCAL_PTR_NULL;
278 }
279 if (callAbilityCallbackPtr_ == nullptr) {
280 TELEPHONY_LOGE("create CallAbilityCallback object failed!");
281 return TELEPHONY_ERR_LOCAL_PTR_NULL;
282 }
283 int32_t ret = callManagerServicePtr_->RegisterCallBack(callAbilityCallbackPtr_);
284 if (ret != TELEPHONY_SUCCESS) {
285 callAbilityCallbackPtr_.clear();
286 callAbilityCallbackPtr_ = nullptr;
287 TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
288 if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
289 return TELEPHONY_ERR_PERMISSION_ERR;
290 }
291 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
292 }
293 TELEPHONY_LOGI("register call ability callback again success!");
294 return TELEPHONY_SUCCESS;
295 }
296
ObserverOnCallDetailsChange()297 int32_t CallManagerProxy::ObserverOnCallDetailsChange()
298 {
299 if (callManagerServicePtr_ == nullptr) {
300 TELEPHONY_LOGE("callManagerServicePtr_ is null");
301 return TELEPHONY_ERR_LOCAL_PTR_NULL;
302 }
303 int32_t ret = callManagerServicePtr_->ObserverOnCallDetailsChange();
304 if (ret != TELEPHONY_SUCCESS) {
305 TELEPHONY_LOGE("report call state info failed when observe OnCallDetailsChange, result: %{public}d", ret);
306 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
307 }
308 return TELEPHONY_SUCCESS;
309 }
310
RegisterVoipCallManagerCallback()311 int32_t CallManagerProxy::RegisterVoipCallManagerCallback()
312 {
313 if (callManagerServicePtr_ == nullptr) {
314 TELEPHONY_LOGE("callManagerServicePtr_ is null");
315 return TELEPHONY_ERR_LOCAL_PTR_NULL;
316 }
317 int32_t ret = callManagerServicePtr_->RegisterVoipCallManagerCallback();
318 if (ret != TELEPHONY_SUCCESS) {
319 TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
320 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
321 }
322 return TELEPHONY_SUCCESS;
323 }
324
UnRegisterVoipCallManagerCallback()325 int32_t CallManagerProxy::UnRegisterVoipCallManagerCallback()
326 {
327 if (callManagerServicePtr_ == nullptr) {
328 TELEPHONY_LOGE("callManagerServicePtr_ is null");
329 return TELEPHONY_ERR_LOCAL_PTR_NULL;
330 }
331 int32_t ret = callManagerServicePtr_->UnRegisterVoipCallManagerCallback();
332 if (ret != TELEPHONY_SUCCESS) {
333 TELEPHONY_LOGE("unregister callback to call manager service failed,result: %{public}d", ret);
334 return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
335 }
336 return TELEPHONY_SUCCESS;
337 }
338
DialCall(std::u16string number,AppExecFwk::PacMap & extras)339 int32_t CallManagerProxy::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
340 {
341 if (ReConnectService() != TELEPHONY_SUCCESS) {
342 TELEPHONY_LOGE("ipc reconnect failed!");
343 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
344 }
345 std::lock_guard<std::mutex> lock(mutex_);
346 int32_t errCode = callManagerServicePtr_->DialCall(number, extras);
347 if (errCode != TELEPHONY_SUCCESS) {
348 TELEPHONY_LOGE("DialCall failed, errcode:%{public}d", errCode);
349 return errCode;
350 }
351 return TELEPHONY_SUCCESS;
352 }
353
AnswerCall(int32_t callId,int32_t videoState)354 int32_t CallManagerProxy::AnswerCall(int32_t callId, int32_t videoState)
355 {
356 if (ReConnectService() != TELEPHONY_SUCCESS) {
357 TELEPHONY_LOGE("ipc reconnect failed!");
358 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
359 }
360 std::lock_guard<std::mutex> lock(mutex_);
361 int32_t errCode = callManagerServicePtr_->AnswerCall(callId, videoState);
362 if (errCode != TELEPHONY_SUCCESS) {
363 TELEPHONY_LOGE("AnswerCall failed, errcode:%{public}d", errCode);
364 return errCode;
365 }
366 return TELEPHONY_SUCCESS;
367 }
368
RejectCall(int32_t callId,bool isSendSms,std::u16string content)369 int32_t CallManagerProxy::RejectCall(int32_t callId, bool isSendSms, std::u16string content)
370 {
371 if (ReConnectService() != TELEPHONY_SUCCESS) {
372 TELEPHONY_LOGE("ipc reconnect failed!");
373 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
374 }
375 std::lock_guard<std::mutex> lock(mutex_);
376 int32_t errCode = callManagerServicePtr_->RejectCall(callId, isSendSms, content);
377 if (errCode != TELEPHONY_SUCCESS) {
378 TELEPHONY_LOGE("RejectCall failed, errcode:%{public}d", errCode);
379 return errCode;
380 }
381 return TELEPHONY_SUCCESS;
382 }
383
HangUpCall(int32_t callId)384 int32_t CallManagerProxy::HangUpCall(int32_t callId)
385 {
386 if (ReConnectService() != TELEPHONY_SUCCESS) {
387 TELEPHONY_LOGE("ipc reconnect failed!");
388 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
389 }
390 std::lock_guard<std::mutex> lock(mutex_);
391 int32_t errCode = callManagerServicePtr_->HangUpCall(callId);
392 if (errCode != TELEPHONY_SUCCESS) {
393 TELEPHONY_LOGE("HangUpCall failed, errcode:%{public}d", errCode);
394 return errCode;
395 }
396 return TELEPHONY_SUCCESS;
397 }
398
GetCallState()399 int32_t CallManagerProxy::GetCallState()
400 {
401 if (ReConnectService() != TELEPHONY_SUCCESS) {
402 TELEPHONY_LOGE("ipc reconnect failed!");
403 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
404 }
405 std::lock_guard<std::mutex> lock(mutex_);
406 int32_t errCode = callManagerServicePtr_->GetCallState();
407 if (errCode != TELEPHONY_SUCCESS) {
408 TELEPHONY_LOGE("GetCallState failed, errcode:%{public}d", errCode);
409 return errCode;
410 }
411 return TELEPHONY_SUCCESS;
412 }
413
HoldCall(int32_t callId)414 int32_t CallManagerProxy::HoldCall(int32_t callId)
415 {
416 if (ReConnectService() != TELEPHONY_SUCCESS) {
417 TELEPHONY_LOGE("ipc reconnect failed!");
418 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
419 }
420 std::lock_guard<std::mutex> lock(mutex_);
421 int32_t errCode = callManagerServicePtr_->HoldCall(callId);
422 if (errCode != TELEPHONY_SUCCESS) {
423 TELEPHONY_LOGE("HoldCall failed, errcode:%{public}d", errCode);
424 return errCode;
425 }
426 return TELEPHONY_SUCCESS;
427 }
428
UnHoldCall(int32_t callId)429 int32_t CallManagerProxy::UnHoldCall(int32_t callId)
430 {
431 if (ReConnectService() != TELEPHONY_SUCCESS) {
432 TELEPHONY_LOGE("ipc reconnect failed!");
433 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
434 }
435 std::lock_guard<std::mutex> lock(mutex_);
436 int32_t errCode = callManagerServicePtr_->UnHoldCall(callId);
437 if (errCode != TELEPHONY_SUCCESS) {
438 TELEPHONY_LOGE("UnHoldCall failed, errcode:%{public}d", errCode);
439 return errCode;
440 }
441 return TELEPHONY_SUCCESS;
442 }
443
SwitchCall(int32_t callId)444 int32_t CallManagerProxy::SwitchCall(int32_t callId)
445 {
446 if (ReConnectService() != TELEPHONY_SUCCESS) {
447 TELEPHONY_LOGE("ipc reconnect failed!");
448 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
449 }
450 std::lock_guard<std::mutex> lock(mutex_);
451 int32_t errCode = callManagerServicePtr_->SwitchCall(callId);
452 if (errCode != TELEPHONY_SUCCESS) {
453 TELEPHONY_LOGE("SwitchCall failed, errcode:%{public}d", errCode);
454 return errCode;
455 }
456 return TELEPHONY_SUCCESS;
457 }
458
CombineConference(int32_t callId)459 int32_t CallManagerProxy::CombineConference(int32_t callId)
460 {
461 if (ReConnectService() != TELEPHONY_SUCCESS) {
462 TELEPHONY_LOGE("ipc reconnect failed!");
463 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
464 }
465 std::lock_guard<std::mutex> lock(mutex_);
466 int32_t errCode = callManagerServicePtr_->CombineConference(callId);
467 if (errCode != TELEPHONY_SUCCESS) {
468 TELEPHONY_LOGE("CombineConference failed, errcode:%{public}d", errCode);
469 return errCode;
470 }
471 return TELEPHONY_SUCCESS;
472 }
473
SeparateConference(int32_t callId)474 int32_t CallManagerProxy::SeparateConference(int32_t callId)
475 {
476 if (ReConnectService() != TELEPHONY_SUCCESS) {
477 TELEPHONY_LOGE("ipc reconnect failed!");
478 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
479 }
480 std::lock_guard<std::mutex> lock(mutex_);
481 int32_t errCode = callManagerServicePtr_->SeparateConference(callId);
482 if (errCode != TELEPHONY_SUCCESS) {
483 TELEPHONY_LOGE("SeparateConference failed, errcode:%{public}d", errCode);
484 return errCode;
485 }
486 return TELEPHONY_SUCCESS;
487 }
488
KickOutFromConference(int32_t callId)489 int32_t CallManagerProxy::KickOutFromConference(int32_t callId)
490 {
491 if (ReConnectService() != TELEPHONY_SUCCESS) {
492 TELEPHONY_LOGE("ipc reconnect failed!");
493 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
494 }
495 std::lock_guard<std::mutex> lock(mutex_);
496 int32_t errCode = callManagerServicePtr_->KickOutFromConference(callId);
497 if (errCode != TELEPHONY_SUCCESS) {
498 TELEPHONY_LOGE("KickOutFromConference failed, errcode:%{public}d", errCode);
499 return errCode;
500 }
501 return TELEPHONY_SUCCESS;
502 }
503
GetMainCallId(int32_t & callId,int32_t & mainCallId)504 int32_t CallManagerProxy::GetMainCallId(int32_t &callId, int32_t &mainCallId)
505 {
506 if (ReConnectService() != TELEPHONY_SUCCESS) {
507 TELEPHONY_LOGE("ipc reconnect failed!");
508 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
509 }
510 std::lock_guard<std::mutex> lock(mutex_);
511 int32_t errCode = callManagerServicePtr_->GetMainCallId(callId, mainCallId);
512 if (errCode != TELEPHONY_SUCCESS) {
513 TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
514 return errCode;
515 }
516 return TELEPHONY_SUCCESS;
517 }
518
GetSubCallIdList(int32_t callId,std::vector<std::u16string> & callIdList)519 int32_t CallManagerProxy::GetSubCallIdList(int32_t callId, std::vector<std::u16string> &callIdList)
520 {
521 if (ReConnectService() != TELEPHONY_SUCCESS) {
522 TELEPHONY_LOGE("ipc reconnect failed!");
523 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
524 }
525 std::lock_guard<std::mutex> lock(mutex_);
526 int32_t errCode = callManagerServicePtr_->GetSubCallIdList(callId, callIdList);
527 if (errCode != TELEPHONY_SUCCESS) {
528 TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
529 return errCode;
530 }
531 return TELEPHONY_SUCCESS;
532 }
533
GetCallIdListForConference(int32_t callId,std::vector<std::u16string> & callIdList)534 int32_t CallManagerProxy::GetCallIdListForConference(int32_t callId, std::vector<std::u16string> &callIdList)
535 {
536 if (ReConnectService() != TELEPHONY_SUCCESS) {
537 TELEPHONY_LOGE("ipc reconnect failed!");
538 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
539 }
540 std::lock_guard<std::mutex> lock(mutex_);
541 int32_t errCode = callManagerServicePtr_->GetCallIdListForConference(callId, callIdList);
542 if (errCode != TELEPHONY_SUCCESS) {
543 TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
544 return errCode;
545 }
546 return TELEPHONY_SUCCESS;
547 }
548
GetCallWaiting(int32_t slotId)549 int32_t CallManagerProxy::GetCallWaiting(int32_t slotId)
550 {
551 if (ReConnectService() != TELEPHONY_SUCCESS) {
552 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
553 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
554 }
555 std::lock_guard<std::mutex> lock(mutex_);
556 int32_t errCode = callManagerServicePtr_->GetCallWaiting(slotId);
557 if (errCode != TELEPHONY_SUCCESS) {
558 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
559 return errCode;
560 }
561 return TELEPHONY_SUCCESS;
562 }
563
SetCallWaiting(int32_t slotId,bool activate)564 int32_t CallManagerProxy::SetCallWaiting(int32_t slotId, bool activate)
565 {
566 if (ReConnectService() != TELEPHONY_SUCCESS) {
567 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
568 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
569 }
570 std::lock_guard<std::mutex> lock(mutex_);
571 int32_t errCode = callManagerServicePtr_->SetCallWaiting(slotId, activate);
572 if (errCode != TELEPHONY_SUCCESS) {
573 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
574 return errCode;
575 }
576 return TELEPHONY_SUCCESS;
577 }
578
GetCallRestriction(int32_t slotId,CallRestrictionType type)579 int32_t CallManagerProxy::GetCallRestriction(int32_t slotId, CallRestrictionType type)
580 {
581 if (ReConnectService() != TELEPHONY_SUCCESS) {
582 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
583 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
584 }
585 std::lock_guard<std::mutex> lock(mutex_);
586 int32_t errCode = callManagerServicePtr_->GetCallRestriction(slotId, type);
587 if (errCode != TELEPHONY_SUCCESS) {
588 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
589 return errCode;
590 }
591 return TELEPHONY_SUCCESS;
592 }
593
SetCallRestriction(int32_t slotId,CallRestrictionInfo & info)594 int32_t CallManagerProxy::SetCallRestriction(int32_t slotId, CallRestrictionInfo &info)
595 {
596 if (ReConnectService() != TELEPHONY_SUCCESS) {
597 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
598 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
599 }
600 std::lock_guard<std::mutex> lock(mutex_);
601 int32_t errCode = callManagerServicePtr_->SetCallRestriction(slotId, info);
602 if (errCode != TELEPHONY_SUCCESS) {
603 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
604 return errCode;
605 }
606 return TELEPHONY_SUCCESS;
607 }
608
SetCallRestrictionPassword(int32_t slotId,CallRestrictionType fac,const char * oldPassword,const char * newPassword)609 int32_t CallManagerProxy::SetCallRestrictionPassword(
610 int32_t slotId, CallRestrictionType fac, const char *oldPassword, const char *newPassword)
611 {
612 if (ReConnectService() != TELEPHONY_SUCCESS) {
613 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
614 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
615 }
616 std::lock_guard<std::mutex> lock(mutex_);
617 int32_t errCode = callManagerServicePtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
618 if (errCode != TELEPHONY_SUCCESS) {
619 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
620 return errCode;
621 }
622 return TELEPHONY_SUCCESS;
623 }
624
GetCallTransferInfo(int32_t slotId,CallTransferType type)625 int32_t CallManagerProxy::GetCallTransferInfo(int32_t slotId, CallTransferType type)
626 {
627 if (ReConnectService() != TELEPHONY_SUCCESS) {
628 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
629 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
630 }
631 std::lock_guard<std::mutex> lock(mutex_);
632 int32_t errCode = callManagerServicePtr_->GetCallTransferInfo(slotId, type);
633 if (errCode != TELEPHONY_SUCCESS) {
634 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
635 return errCode;
636 }
637 return TELEPHONY_SUCCESS;
638 }
639
SetCallTransferInfo(int32_t slotId,CallTransferInfo & info)640 int32_t CallManagerProxy::SetCallTransferInfo(int32_t slotId, CallTransferInfo &info)
641 {
642 if (ReConnectService() != TELEPHONY_SUCCESS) {
643 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
644 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
645 }
646 std::lock_guard<std::mutex> lock(mutex_);
647 int32_t errCode = callManagerServicePtr_->SetCallTransferInfo(slotId, info);
648 if (errCode != TELEPHONY_SUCCESS) {
649 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
650 return errCode;
651 }
652 return TELEPHONY_SUCCESS;
653 }
654
CanSetCallTransferTime(int32_t slotId,bool & result)655 int32_t CallManagerProxy::CanSetCallTransferTime(int32_t slotId, bool &result)
656 {
657 if (ReConnectService() != TELEPHONY_SUCCESS) {
658 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
659 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
660 }
661 std::lock_guard<std::mutex> lock(mutex_);
662 return callManagerServicePtr_->CanSetCallTransferTime(slotId, result);
663 }
664
SetCallPreferenceMode(int32_t slotId,int32_t mode)665 int32_t CallManagerProxy::SetCallPreferenceMode(int32_t slotId, int32_t mode)
666 {
667 if (ReConnectService() != TELEPHONY_SUCCESS) {
668 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
669 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
670 }
671 std::lock_guard<std::mutex> lock(mutex_);
672 int32_t errCode = callManagerServicePtr_->SetCallPreferenceMode(slotId, mode);
673 if (errCode != TELEPHONY_SUCCESS) {
674 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
675 return errCode;
676 }
677 return TELEPHONY_SUCCESS;
678 }
679
StartDtmf(int32_t callId,char str)680 int32_t CallManagerProxy::StartDtmf(int32_t callId, char str)
681 {
682 if (ReConnectService() != TELEPHONY_SUCCESS) {
683 TELEPHONY_LOGE("ipc reconnect failed!");
684 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
685 }
686 std::lock_guard<std::mutex> lock(mutex_);
687 int32_t errCode = callManagerServicePtr_->StartDtmf(callId, str);
688 if (errCode != TELEPHONY_SUCCESS) {
689 TELEPHONY_LOGE("StartDtmf failed, errcode:%{public}d", errCode);
690 return errCode;
691 }
692 return TELEPHONY_SUCCESS;
693 }
694
StopDtmf(int32_t callId)695 int32_t CallManagerProxy::StopDtmf(int32_t callId)
696 {
697 if (ReConnectService() != TELEPHONY_SUCCESS) {
698 TELEPHONY_LOGE("ipc reconnect failed!");
699 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
700 }
701 std::lock_guard<std::mutex> lock(mutex_);
702 int32_t errCode = callManagerServicePtr_->StopDtmf(callId);
703 if (errCode != TELEPHONY_SUCCESS) {
704 TELEPHONY_LOGE("StopDtmf failed, errcode:%{public}d", errCode);
705 return errCode;
706 }
707 return TELEPHONY_SUCCESS;
708 }
709
PostDialProceed(int32_t callId,bool proceed)710 int32_t CallManagerProxy::PostDialProceed(int32_t callId, bool proceed)
711 {
712 if (ReConnectService() != TELEPHONY_SUCCESS) {
713 TELEPHONY_LOGE("ipc reconnect failed!");
714 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
715 }
716 std::lock_guard<std::mutex> lock(mutex_);
717 int32_t errCode = callManagerServicePtr_->PostDialProceed(callId, proceed);
718 if (errCode != TELEPHONY_SUCCESS) {
719 TELEPHONY_LOGE("PostDialProceed failed, errcode:%{public}d", errCode);
720 return errCode;
721 }
722 return TELEPHONY_SUCCESS;
723 }
724
IsRinging(bool & enabled)725 int32_t CallManagerProxy::IsRinging(bool &enabled)
726 {
727 if (ReConnectService() != TELEPHONY_SUCCESS) {
728 TELEPHONY_LOGE("ipc reconnect failed!");
729 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
730 }
731 std::lock_guard<std::mutex> lock(mutex_);
732 return callManagerServicePtr_->IsRinging(enabled);
733 }
734
HasCall()735 bool CallManagerProxy::HasCall()
736 {
737 if (ReConnectService() != TELEPHONY_SUCCESS) {
738 TELEPHONY_LOGE("ipc reconnect failed!");
739 return false;
740 }
741 std::lock_guard<std::mutex> lock(mutex_);
742 return callManagerServicePtr_->HasCall();
743 }
744
IsNewCallAllowed(bool & enabled)745 int32_t CallManagerProxy::IsNewCallAllowed(bool &enabled)
746 {
747 if (ReConnectService() != TELEPHONY_SUCCESS) {
748 TELEPHONY_LOGE("ipc reconnect failed!");
749 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
750 }
751 std::lock_guard<std::mutex> lock(mutex_);
752 return callManagerServicePtr_->IsNewCallAllowed(enabled);
753 }
754
IsInEmergencyCall(bool & enabled)755 int32_t CallManagerProxy::IsInEmergencyCall(bool &enabled)
756 {
757 if (ReConnectService() != TELEPHONY_SUCCESS) {
758 TELEPHONY_LOGE("ipc reconnect failed!");
759 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
760 }
761 std::lock_guard<std::mutex> lock(mutex_);
762 return callManagerServicePtr_->IsInEmergencyCall(enabled);
763 }
764
IsEmergencyPhoneNumber(std::u16string & number,int32_t slotId,bool & enabled)765 int32_t CallManagerProxy::IsEmergencyPhoneNumber(std::u16string &number, int32_t slotId, bool &enabled)
766 {
767 if (ReConnectService() != TELEPHONY_SUCCESS) {
768 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
769 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
770 }
771 std::lock_guard<std::mutex> lock(mutex_);
772 return callManagerServicePtr_->IsEmergencyPhoneNumber(number, slotId, enabled);
773 }
774
FormatPhoneNumber(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)775 int32_t CallManagerProxy::FormatPhoneNumber(
776 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
777 {
778 if (ReConnectService() != TELEPHONY_SUCCESS) {
779 TELEPHONY_LOGE("ipc reconnect failed!");
780 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
781 }
782 std::lock_guard<std::mutex> lock(mutex_);
783 int32_t errCode = callManagerServicePtr_->FormatPhoneNumber(number, countryCode, formatNumber);
784 if (errCode != TELEPHONY_SUCCESS) {
785 TELEPHONY_LOGE("FormatPhoneNumber failed, errcode:%{public}d", errCode);
786 return errCode;
787 }
788 return TELEPHONY_SUCCESS;
789 }
790
FormatPhoneNumberToE164(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)791 int32_t CallManagerProxy::FormatPhoneNumberToE164(
792 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
793 {
794 if (ReConnectService() != TELEPHONY_SUCCESS) {
795 TELEPHONY_LOGE("ipc reconnect failed!");
796 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
797 }
798 std::lock_guard<std::mutex> lock(mutex_);
799 int32_t errCode = callManagerServicePtr_->FormatPhoneNumberToE164(number, countryCode, formatNumber);
800 if (errCode != TELEPHONY_SUCCESS) {
801 TELEPHONY_LOGE("FormatPhoneNumberToE164 failed, errcode:%{public}d", errCode);
802 return errCode;
803 }
804 return TELEPHONY_SUCCESS;
805 }
806
SetMuted(bool isMute)807 int32_t CallManagerProxy::SetMuted(bool isMute)
808 {
809 if (ReConnectService() != TELEPHONY_SUCCESS) {
810 TELEPHONY_LOGE("ipc reconnect failed!");
811 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
812 }
813 std::lock_guard<std::mutex> lock(mutex_);
814 int32_t errCode = callManagerServicePtr_->SetMuted(isMute);
815 if (errCode != TELEPHONY_SUCCESS) {
816 TELEPHONY_LOGE("SetMute failed, errcode:%{public}d", errCode);
817 return errCode;
818 }
819 return TELEPHONY_SUCCESS;
820 }
821
MuteRinger()822 int32_t CallManagerProxy::MuteRinger()
823 {
824 if (ReConnectService() != TELEPHONY_SUCCESS) {
825 TELEPHONY_LOGE("ipc reconnect failed!");
826 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
827 }
828 std::lock_guard<std::mutex> lock(mutex_);
829 int32_t errCode = callManagerServicePtr_->MuteRinger();
830 if (errCode != TELEPHONY_SUCCESS) {
831 TELEPHONY_LOGE("MuteRinger failed, errcode:%{public}d", errCode);
832 return errCode;
833 }
834 return TELEPHONY_SUCCESS;
835 }
836
SetAudioDevice(const AudioDevice & audioDevice)837 int32_t CallManagerProxy::SetAudioDevice(const AudioDevice &audioDevice)
838 {
839 if (ReConnectService() != TELEPHONY_SUCCESS) {
840 TELEPHONY_LOGE("ipc reconnect failed!");
841 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
842 }
843 std::lock_guard<std::mutex> lock(mutex_);
844 int32_t errCode = callManagerServicePtr_->SetAudioDevice(audioDevice);
845 if (errCode != TELEPHONY_SUCCESS) {
846 TELEPHONY_LOGE("SetAudioDevice failed, errcode:%{public}d", errCode);
847 return errCode;
848 }
849 return TELEPHONY_SUCCESS;
850 }
851
ControlCamera(int32_t callId,std::u16string & cameraId)852 int32_t CallManagerProxy::ControlCamera(int32_t callId, std::u16string &cameraId)
853 {
854 if (ReConnectService() != TELEPHONY_SUCCESS) {
855 TELEPHONY_LOGE("ipc reconnect failed!");
856 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
857 }
858 std::lock_guard<std::mutex> lock(mutex_);
859 int32_t errCode = callManagerServicePtr_->ControlCamera(callId, cameraId);
860 if (errCode != TELEPHONY_SUCCESS) {
861 TELEPHONY_LOGE("ControlCamera failed, errcode:%{public}d", errCode);
862 return errCode;
863 }
864 return TELEPHONY_SUCCESS;
865 }
866
SetPreviewWindow(int32_t callId,std::string & surfaceId)867 int32_t CallManagerProxy::SetPreviewWindow(int32_t callId, std::string &surfaceId)
868 {
869 if (ReConnectService() != TELEPHONY_SUCCESS) {
870 TELEPHONY_LOGE("ipc reconnect failed!");
871 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
872 }
873 std::lock_guard<std::mutex> lock(mutex_);
874 TELEPHONY_LOGI("surfaceId is %{public}s", surfaceId.c_str());
875 int32_t errCode = TELEPHONY_SUCCESS;
876 if (surfaceId.empty() || surfaceId[0] < '0' || surfaceId[0] > '9') {
877 TELEPHONY_LOGI("surfaceId is invalid, set surface nullptr");
878 surfaceId = "";
879 errCode = callManagerServicePtr_->SetPreviewWindow(callId, surfaceId, nullptr);
880 } else {
881 uint64_t previewSurfaceId = std::stoull(surfaceId);
882 auto surface = SurfaceUtils::GetInstance()->GetSurface(previewSurfaceId);
883 if (surface == nullptr) {
884 TELEPHONY_LOGI("surface is null");
885 surfaceId = "";
886 }
887 errCode = callManagerServicePtr_->SetPreviewWindow(callId, surfaceId, surface);
888 }
889 if (errCode != TELEPHONY_SUCCESS) {
890 TELEPHONY_LOGE("SetPreviewWindow failed, errcode:%{public}d", errCode);
891 return errCode;
892 }
893 return TELEPHONY_SUCCESS;
894 }
895
SetDisplayWindow(int32_t callId,std::string & surfaceId)896 int32_t CallManagerProxy::SetDisplayWindow(int32_t callId, std::string &surfaceId)
897 {
898 if (ReConnectService() != TELEPHONY_SUCCESS) {
899 TELEPHONY_LOGE("ipc reconnect failed!");
900 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
901 }
902 std::lock_guard<std::mutex> lock(mutex_);
903 TELEPHONY_LOGI("surfaceId is %{public}s", surfaceId.c_str());
904 int32_t errCode = TELEPHONY_SUCCESS;
905 if (surfaceId.empty() || surfaceId[0] < '0' || surfaceId[0] > '9') {
906 TELEPHONY_LOGI("surfaceId is invalid, set surface nullptr");
907 surfaceId = "";
908 errCode = callManagerServicePtr_->SetDisplayWindow(callId, surfaceId, nullptr);
909 } else {
910 uint64_t displaySurfaceId = std::stoull(surfaceId);
911 auto surface = SurfaceUtils::GetInstance()->GetSurface(displaySurfaceId);
912 if (surface == nullptr) {
913 TELEPHONY_LOGI("surface is null");
914 surfaceId = "";
915 }
916 errCode = callManagerServicePtr_->SetDisplayWindow(callId, surfaceId, surface);
917 }
918 if (errCode != TELEPHONY_SUCCESS) {
919 TELEPHONY_LOGE("SetDisplayWindow failed, errcode:%{public}d", errCode);
920 return errCode;
921 }
922 return TELEPHONY_SUCCESS;
923 }
924
SetCameraZoom(float zoomRatio)925 int32_t CallManagerProxy::SetCameraZoom(float zoomRatio)
926 {
927 if (ReConnectService() != TELEPHONY_SUCCESS) {
928 TELEPHONY_LOGE("ipc reconnect failed!");
929 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
930 }
931 std::lock_guard<std::mutex> lock(mutex_);
932 int32_t errCode = callManagerServicePtr_->SetCameraZoom(zoomRatio);
933 if (errCode != TELEPHONY_SUCCESS) {
934 TELEPHONY_LOGE("SetCameraZoom failed, errcode:%{public}d", errCode);
935 return errCode;
936 }
937 return TELEPHONY_SUCCESS;
938 }
939
SetPausePicture(int32_t callId,std::u16string & path)940 int32_t CallManagerProxy::SetPausePicture(int32_t callId, std::u16string &path)
941 {
942 if (ReConnectService() != TELEPHONY_SUCCESS) {
943 TELEPHONY_LOGE("ipc reconnect failed!");
944 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
945 }
946 std::lock_guard<std::mutex> lock(mutex_);
947 int32_t errCode = callManagerServicePtr_->SetPausePicture(callId, path);
948 if (errCode != TELEPHONY_SUCCESS) {
949 TELEPHONY_LOGE("SetPausePicture failed, errcode:%{public}d", errCode);
950 return errCode;
951 }
952 return TELEPHONY_SUCCESS;
953 }
954
SetDeviceDirection(int32_t callId,int32_t rotation)955 int32_t CallManagerProxy::SetDeviceDirection(int32_t callId, int32_t rotation)
956 {
957 if (ReConnectService() != TELEPHONY_SUCCESS) {
958 TELEPHONY_LOGE("ipc reconnect failed!");
959 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
960 }
961 std::lock_guard<std::mutex> lock(mutex_);
962 int32_t errCode = callManagerServicePtr_->SetDeviceDirection(callId, rotation);
963 if (errCode != TELEPHONY_SUCCESS) {
964 TELEPHONY_LOGE("SetDeviceDirection failed, errcode:%{public}d", errCode);
965 return errCode;
966 }
967 return TELEPHONY_SUCCESS;
968 }
969
GetImsConfig(int32_t slotId,ImsConfigItem item)970 int32_t CallManagerProxy::GetImsConfig(int32_t slotId, ImsConfigItem item)
971 {
972 if (ReConnectService() != TELEPHONY_SUCCESS) {
973 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
974 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
975 }
976 std::lock_guard<std::mutex> lock(mutex_);
977 int32_t errCode = callManagerServicePtr_->GetImsConfig(slotId, item);
978 if (errCode != TELEPHONY_SUCCESS) {
979 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
980 return errCode;
981 }
982 return TELEPHONY_SUCCESS;
983 }
984
SetImsConfig(int32_t slotId,ImsConfigItem item,std::u16string & value)985 int32_t CallManagerProxy::SetImsConfig(int32_t slotId, ImsConfigItem item, std::u16string &value)
986 {
987 if (ReConnectService() != TELEPHONY_SUCCESS) {
988 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
989 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
990 }
991 std::lock_guard<std::mutex> lock(mutex_);
992 int32_t errCode = callManagerServicePtr_->SetImsConfig(slotId, item, value);
993 if (errCode != TELEPHONY_SUCCESS) {
994 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
995 return errCode;
996 }
997 return TELEPHONY_SUCCESS;
998 }
999
GetImsFeatureValue(int32_t slotId,FeatureType type)1000 int32_t CallManagerProxy::GetImsFeatureValue(int32_t slotId, FeatureType type)
1001 {
1002 if (ReConnectService() != TELEPHONY_SUCCESS) {
1003 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1004 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1005 }
1006 std::lock_guard<std::mutex> lock(mutex_);
1007 int32_t errCode = callManagerServicePtr_->GetImsFeatureValue(slotId, type);
1008 if (errCode != TELEPHONY_SUCCESS) {
1009 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1010 return errCode;
1011 }
1012 return TELEPHONY_SUCCESS;
1013 }
1014
SetImsFeatureValue(int32_t slotId,FeatureType type,int32_t value)1015 int32_t CallManagerProxy::SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value)
1016 {
1017 if (ReConnectService() != TELEPHONY_SUCCESS) {
1018 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1019 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1020 }
1021 std::lock_guard<std::mutex> lock(mutex_);
1022 int32_t errCode = callManagerServicePtr_->SetImsFeatureValue(slotId, type, value);
1023 if (errCode != TELEPHONY_SUCCESS) {
1024 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1025 return errCode;
1026 }
1027 return TELEPHONY_SUCCESS;
1028 }
1029
UpdateImsCallMode(int32_t callId,ImsCallMode mode)1030 int32_t CallManagerProxy::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1031 {
1032 if (ReConnectService() != TELEPHONY_SUCCESS) {
1033 TELEPHONY_LOGE("ipc reconnect failed!");
1034 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1035 }
1036 std::lock_guard<std::mutex> lock(mutex_);
1037 int32_t errCode = callManagerServicePtr_->UpdateImsCallMode(callId, mode);
1038 if (errCode != TELEPHONY_SUCCESS) {
1039 TELEPHONY_LOGE("UpdateImsCallMode failed, errcode:%{public}d", errCode);
1040 return errCode;
1041 }
1042 return TELEPHONY_SUCCESS;
1043 }
1044
EnableImsSwitch(int32_t slotId)1045 int32_t CallManagerProxy::EnableImsSwitch(int32_t slotId)
1046 {
1047 if (ReConnectService() != TELEPHONY_SUCCESS) {
1048 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1049 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1050 }
1051 std::lock_guard<std::mutex> lock(mutex_);
1052 int32_t errCode = callManagerServicePtr_->EnableImsSwitch(slotId);
1053 if (errCode != TELEPHONY_SUCCESS) {
1054 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1055 return errCode;
1056 }
1057 return TELEPHONY_SUCCESS;
1058 }
1059
DisableImsSwitch(int32_t slotId)1060 int32_t CallManagerProxy::DisableImsSwitch(int32_t slotId)
1061 {
1062 if (ReConnectService() != TELEPHONY_SUCCESS) {
1063 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1064 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1065 }
1066 std::lock_guard<std::mutex> lock(mutex_);
1067 int32_t errCode = callManagerServicePtr_->DisableImsSwitch(slotId);
1068 if (errCode != TELEPHONY_SUCCESS) {
1069 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1070 return errCode;
1071 }
1072 return TELEPHONY_SUCCESS;
1073 }
1074
IsImsSwitchEnabled(int32_t slotId,bool & enabled)1075 int32_t CallManagerProxy::IsImsSwitchEnabled(int32_t slotId, bool &enabled)
1076 {
1077 if (ReConnectService() != TELEPHONY_SUCCESS) {
1078 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1079 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1080 }
1081 std::lock_guard<std::mutex> lock(mutex_);
1082 int32_t errCode = callManagerServicePtr_->IsImsSwitchEnabled(slotId, enabled);
1083 if (errCode != TELEPHONY_SUCCESS) {
1084 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1085 return errCode;
1086 }
1087 return TELEPHONY_SUCCESS;
1088 }
1089
SetVoNRState(int32_t slotId,int32_t state)1090 int32_t CallManagerProxy::SetVoNRState(int32_t slotId, int32_t state)
1091 {
1092 if (ReConnectService() != TELEPHONY_SUCCESS) {
1093 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1094 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1095 }
1096 std::lock_guard<std::mutex> lock(mutex_);
1097 int32_t errCode = callManagerServicePtr_->SetVoNRState(slotId, state);
1098 if (errCode != TELEPHONY_SUCCESS) {
1099 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1100 return errCode;
1101 }
1102 return TELEPHONY_SUCCESS;
1103 }
1104
GetVoNRState(int32_t slotId,int32_t & state)1105 int32_t CallManagerProxy::GetVoNRState(int32_t slotId, int32_t &state)
1106 {
1107 if (ReConnectService() != TELEPHONY_SUCCESS) {
1108 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1109 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1110 }
1111 std::lock_guard<std::mutex> lock(mutex_);
1112 int32_t errCode = callManagerServicePtr_->GetVoNRState(slotId, state);
1113 if (errCode != TELEPHONY_SUCCESS) {
1114 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1115 return errCode;
1116 }
1117 return TELEPHONY_SUCCESS;
1118 }
1119
StartRtt(int32_t callId,std::u16string & msg)1120 int32_t CallManagerProxy::StartRtt(int32_t callId, std::u16string &msg)
1121 {
1122 if (ReConnectService() != TELEPHONY_SUCCESS) {
1123 TELEPHONY_LOGE("ipc reconnect failed!");
1124 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1125 }
1126 std::lock_guard<std::mutex> lock(mutex_);
1127 int32_t errCode = callManagerServicePtr_->StartRtt(callId, msg);
1128 if (errCode != TELEPHONY_SUCCESS) {
1129 TELEPHONY_LOGE("StartRtt failed, errcode:%{public}d", errCode);
1130 return errCode;
1131 }
1132 return TELEPHONY_SUCCESS;
1133 }
1134
StopRtt(int32_t callId)1135 int32_t CallManagerProxy::StopRtt(int32_t callId)
1136 {
1137 if (ReConnectService() != TELEPHONY_SUCCESS) {
1138 TELEPHONY_LOGE("ipc reconnect failed!");
1139 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1140 }
1141 std::lock_guard<std::mutex> lock(mutex_);
1142 int32_t errCode = callManagerServicePtr_->StopRtt(callId);
1143 if (errCode != TELEPHONY_SUCCESS) {
1144 TELEPHONY_LOGE("StopRtt failed, errcode:%{public}d", errCode);
1145 return errCode;
1146 }
1147 return TELEPHONY_SUCCESS;
1148 }
1149
JoinConference(int32_t callId,std::vector<std::u16string> & numberList)1150 int32_t CallManagerProxy::JoinConference(int32_t callId, std::vector<std::u16string> &numberList)
1151 {
1152 if (ReConnectService() != TELEPHONY_SUCCESS) {
1153 TELEPHONY_LOGE("ipc reconnect failed!");
1154 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1155 }
1156 std::lock_guard<std::mutex> lock(mutex_);
1157 int32_t errCode = callManagerServicePtr_->JoinConference(callId, numberList);
1158 if (errCode != TELEPHONY_SUCCESS) {
1159 TELEPHONY_LOGE("JoinConference failed, errcode:%{public}d", errCode);
1160 return errCode;
1161 }
1162 return TELEPHONY_SUCCESS;
1163 }
1164
ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> & ottVec)1165 int32_t CallManagerProxy::ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> &ottVec)
1166 {
1167 if (ReConnectService() != TELEPHONY_SUCCESS) {
1168 TELEPHONY_LOGE("ipc reconnect failed!");
1169 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1170 }
1171 std::lock_guard<std::mutex> lock(mutex_);
1172 int32_t errCode = callManagerServicePtr_->ReportOttCallDetailsInfo(ottVec);
1173 if (errCode != TELEPHONY_SUCCESS) {
1174 TELEPHONY_LOGE("ReportOttCallInfo failed, errcode:%{public}d", errCode);
1175 return errCode;
1176 }
1177 return TELEPHONY_SUCCESS;
1178 }
1179
ReportOttCallEventInfo(OttCallEventInfo & eventInfo)1180 int32_t CallManagerProxy::ReportOttCallEventInfo(OttCallEventInfo &eventInfo)
1181 {
1182 if (ReConnectService() != TELEPHONY_SUCCESS) {
1183 TELEPHONY_LOGE("ipc reconnect failed!");
1184 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1185 }
1186 std::lock_guard<std::mutex> lock(mutex_);
1187 int32_t errCode = callManagerServicePtr_->ReportOttCallEventInfo(eventInfo);
1188 if (errCode != TELEPHONY_SUCCESS) {
1189 TELEPHONY_LOGE("ReportOttCallEventInfo failed, errcode:%{public}d", errCode);
1190 return errCode;
1191 }
1192 return TELEPHONY_SUCCESS;
1193 }
1194
CloseUnFinishedUssd(int32_t slotId)1195 int32_t CallManagerProxy::CloseUnFinishedUssd(int32_t slotId)
1196 {
1197 if (ReConnectService() != TELEPHONY_SUCCESS) {
1198 TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1199 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1200 }
1201 std::lock_guard<std::mutex> lock(mutex_);
1202 int32_t errCode = callManagerServicePtr_->CloseUnFinishedUssd(slotId);
1203 if (errCode != TELEPHONY_SUCCESS) {
1204 TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1205 return errCode;
1206 }
1207 return TELEPHONY_SUCCESS;
1208 }
1209
InputDialerSpecialCode(const std::string & specialCode)1210 int32_t CallManagerProxy::InputDialerSpecialCode(const std::string &specialCode)
1211 {
1212 if (ReConnectService() != TELEPHONY_SUCCESS) {
1213 TELEPHONY_LOGE("ipc reconnect failed!");
1214 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1215 }
1216
1217 std::lock_guard<std::mutex> lock(mutex_);
1218 int32_t errCode = callManagerServicePtr_->InputDialerSpecialCode(specialCode);
1219 if (errCode != TELEPHONY_SUCCESS) {
1220 TELEPHONY_LOGE("InputDialerSpecialCode failed, errcode:%{public}d", errCode);
1221 return errCode;
1222 }
1223 return TELEPHONY_SUCCESS;
1224 }
1225
RemoveMissedIncomingCallNotification()1226 int32_t CallManagerProxy::RemoveMissedIncomingCallNotification()
1227 {
1228 if (ReConnectService() != TELEPHONY_SUCCESS) {
1229 TELEPHONY_LOGE("ipc reconnect failed!");
1230 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1231 }
1232
1233 std::lock_guard<std::mutex> lock(mutex_);
1234 int32_t errCode = callManagerServicePtr_->RemoveMissedIncomingCallNotification();
1235 if (errCode != TELEPHONY_SUCCESS) {
1236 TELEPHONY_LOGE("RemoveMissedIncomingCallNotification failed, errcode:%{public}d", errCode);
1237 return errCode;
1238 }
1239 return TELEPHONY_SUCCESS;
1240 }
1241
SetVoIPCallState(int32_t state)1242 int32_t CallManagerProxy::SetVoIPCallState(int32_t state)
1243 {
1244 if (ReConnectService() != TELEPHONY_SUCCESS) {
1245 TELEPHONY_LOGE("ipc reconnect failed!");
1246 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1247 }
1248 std::lock_guard<std::mutex> lock(mutex_);
1249 int32_t errCode = callManagerServicePtr_->SetVoIPCallState(state);
1250 if (errCode != TELEPHONY_SUCCESS) {
1251 TELEPHONY_LOGE("failed, errcode:%{public}d", errCode);
1252 return errCode;
1253 }
1254 return TELEPHONY_SUCCESS;
1255 }
1256
GetVoIPCallState(int32_t & state)1257 int32_t CallManagerProxy::GetVoIPCallState(int32_t &state)
1258 {
1259 if (ReConnectService() != TELEPHONY_SUCCESS) {
1260 TELEPHONY_LOGE("ipc reconnect failed!");
1261 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1262 }
1263 std::lock_guard<std::mutex> lock(mutex_);
1264 int32_t errCode = callManagerServicePtr_->GetVoIPCallState(state);
1265 if (errCode != TELEPHONY_SUCCESS) {
1266 TELEPHONY_LOGE("failed, errcode:%{public}d", errCode);
1267 return errCode;
1268 }
1269 return TELEPHONY_SUCCESS;
1270 }
1271
GetProxyObjectPtr(CallManagerProxyType proxyType)1272 sptr<IRemoteObject> CallManagerProxy::GetProxyObjectPtr(CallManagerProxyType proxyType)
1273 {
1274 if (ReConnectService() != TELEPHONY_SUCCESS) {
1275 TELEPHONY_LOGE("ipc reconnect failed!");
1276 return nullptr;
1277 }
1278 std::lock_guard<std::mutex> lock(mutex_);
1279 sptr<IRemoteObject> ptr = callManagerServicePtr_->GetProxyObjectPtr(proxyType);
1280 if (ptr == nullptr) {
1281 TELEPHONY_LOGE("GetProxyObjectPtr failed");
1282 return nullptr;
1283 }
1284 return ptr;
1285 }
1286
OnRemoteDied(const wptr<IRemoteObject> & remote)1287 void CallManagerProxy::OnRemoteDied(const wptr<IRemoteObject> &remote)
1288 {
1289 if (remote == nullptr) {
1290 TELEPHONY_LOGE("OnRemoteDied failed, remote is nullptr");
1291 return;
1292 }
1293 std::lock_guard<std::mutex> lock(mutex_);
1294 if (callManagerServicePtr_ == nullptr) {
1295 TELEPHONY_LOGE("OnRemoteDied failed, callManagerServicePtr_ is nullptr");
1296 return;
1297 }
1298 auto serviceRemote = callManagerServicePtr_->AsObject();
1299 if (serviceRemote != nullptr && serviceRemote == remote.promote()) {
1300 serviceRemote->RemoveDeathRecipient(deathRecipient_);
1301 callManagerServicePtr_ = nullptr;
1302 initStatus_ = false;
1303 TELEPHONY_LOGE("on remote died");
1304 }
1305 }
1306
ReportAudioDeviceInfo()1307 int32_t CallManagerProxy::ReportAudioDeviceInfo()
1308 {
1309 if (ReConnectService() != TELEPHONY_SUCCESS) {
1310 TELEPHONY_LOGE("ipc reconnect failed!");
1311 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1312 }
1313 std::lock_guard<std::mutex> lock(mutex_);
1314 int32_t errCode = callManagerServicePtr_->ReportAudioDeviceInfo();
1315 if (errCode != TELEPHONY_SUCCESS) {
1316 TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1317 return errCode;
1318 }
1319 return TELEPHONY_SUCCESS;
1320 }
1321
CancelCallUpgrade(int32_t callId)1322 int32_t CallManagerProxy::CancelCallUpgrade(int32_t callId)
1323 {
1324 if (ReConnectService() != TELEPHONY_SUCCESS) {
1325 TELEPHONY_LOGE("ipc reconnect failed!");
1326 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1327 }
1328 std::lock_guard<std::mutex> lock(mutex_);
1329 int32_t errCode = callManagerServicePtr_->CancelCallUpgrade(callId);
1330 if (errCode != TELEPHONY_SUCCESS) {
1331 TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1332 return errCode;
1333 }
1334 return TELEPHONY_SUCCESS;
1335 }
1336
RequestCameraCapabilities(int32_t callId)1337 int32_t CallManagerProxy::RequestCameraCapabilities(int32_t callId)
1338 {
1339 if (ReConnectService() != TELEPHONY_SUCCESS) {
1340 TELEPHONY_LOGE("ipc reconnect failed!");
1341 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1342 }
1343 std::lock_guard<std::mutex> lock(mutex_);
1344 int32_t errCode = callManagerServicePtr_->RequestCameraCapabilities(callId);
1345 if (errCode != TELEPHONY_SUCCESS) {
1346 TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1347 return errCode;
1348 }
1349 return TELEPHONY_SUCCESS;
1350 }
1351 } // namespace Telephony
1352 } // namespace OHOS
1353