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::unique_lock<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     lock.unlock();
89     int32_t result = ConnectService();
90     if (result != TELEPHONY_SUCCESS) {
91         TELEPHONY_LOGE("connect service failed,errCode: %{public}d", result);
92         return;
93     }
94     initStatus_ = true;
95     TELEPHONY_LOGD("connected to call manager service successfully!");
96 }
97 
98 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
CallManagerProxySubcribed(const EventFwk::CommonEventSubscribeInfo & subscriberInfo)99 CallManagerProxy::CallManagerProxySubcribed::CallManagerProxySubcribed(
100     const EventFwk::CommonEventSubscribeInfo &subscriberInfo)
101     : CommonEventSubscriber(subscriberInfo)
102 {}
103 
OnReceiveEvent(const EventFwk::CommonEventData & data)104 void CallManagerProxy::CallManagerProxySubcribed::OnReceiveEvent(const EventFwk::CommonEventData &data)
105 {
106     std::shared_ptr<CallManagerProxy> proxy = DelayedSingleton<CallManagerProxy>::GetInstance();
107     if (proxy == nullptr) {
108         TELEPHONY_LOGE("proxy is nullptr");
109         return;
110     }
111     int32_t result = proxy->ConnectService();
112     if (result != TELEPHONY_SUCCESS) {
113         TELEPHONY_LOGE("OnReceiveEvent connect service failed,errCode: %{public}d", result);
114         return;
115     }
116     result = proxy->RegisterCallBack(proxy->GetCallBack());
117     if (result != TELEPHONY_SUCCESS) {
118         TELEPHONY_LOGE("OnReceiveEvent register callback failed,errCode: %{public}d", result);
119         return;
120     }
121     proxy->SetInitState(true);
122     TELEPHONY_LOGI("OnReceiveEvent connected to call manager service successfully!");
123     bool unsubscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(shared_from_this());
124     TELEPHONY_LOGI("OnReceiveEvent UnSubscribeCommonEvent unsubscribeResult: %{public}d", unsubscribeResult);
125 }
126 #endif
127 
UnInit()128 void CallManagerProxy::UnInit()
129 {
130     DisconnectService();
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     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
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         if (ret != TELEPHONY_ERR_PERMISSION_ERR) {
162             TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
163         }
164         if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
165             return TELEPHONY_ERR_PERMISSION_ERR;
166         } else if (ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API) {
167             return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
168         }
169         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
170     }
171     TELEPHONY_LOGI("register call ability callback success!");
172     callAbilityCallbackPtr_->SetProcessCallback(std::move(callback));
173     registerStatus_ = true;
174     return TELEPHONY_SUCCESS;
175 }
176 
UnRegisterCallBack()177 int32_t CallManagerProxy::UnRegisterCallBack()
178 {
179     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
180     if (!registerStatus_) {
181         TELEPHONY_LOGE("you haven't register callback yet, please RegisterCallBack first!");
182         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
183     }
184     if (callManagerServicePtr_ == nullptr) {
185         TELEPHONY_LOGE("callManagerServicePtr_ is null");
186         return TELEPHONY_ERR_LOCAL_PTR_NULL;
187     }
188     int32_t ret = callManagerServicePtr_->UnRegisterCallBack();
189     if (ret != TELEPHONY_SUCCESS) {
190         TELEPHONY_LOGE("UnRegisterCallBack failed,result: %{public}d", ret);
191         if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
192             return TELEPHONY_ERR_PERMISSION_ERR;
193         } else if (ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API) {
194             return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
195         }
196         return TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL;
197     }
198     if (callAbilityCallbackPtr_ == nullptr) {
199         TELEPHONY_LOGE("callAbilityCallbackPtr_ is nullptr!");
200         return TELEPHONY_ERR_LOCAL_PTR_NULL;
201     }
202     callAbilityCallbackPtr_.clear();
203     callAbilityCallbackPtr_ = nullptr;
204     registerStatus_ = false;
205     TELEPHONY_LOGI("UnRegisterCallBack success!");
206     return TELEPHONY_SUCCESS;
207 }
208 
ConnectService()209 int32_t CallManagerProxy::ConnectService()
210 {
211     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
212     if (callManagerServicePtr_ != nullptr) {
213         return TELEPHONY_SUCCESS;
214     }
215     sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
216     if (managerPtr == nullptr) {
217         TELEPHONY_LOGE("GetSystemAbilityManager failed!");
218         return TELEPHONY_ERR_LOCAL_PTR_NULL;
219     }
220     sptr<ICallManagerService> callManagerServicePtr = nullptr;
221     sptr<IRemoteObject> iRemoteObjectPtr = managerPtr->GetSystemAbility(systemAbilityId_);
222     if (iRemoteObjectPtr == nullptr) {
223         TELEPHONY_LOGE("GetSystemAbility failed!");
224         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
225     }
226 
227     std::unique_ptr<CallManagerServiceDeathRecipient> recipient =
228         std::make_unique<CallManagerServiceDeathRecipient>(*this);
229     if (recipient == nullptr) {
230         TELEPHONY_LOGE("recipient is null");
231         return TELEPHONY_ERROR;
232     }
233     sptr<IRemoteObject::DeathRecipient> dr(recipient.release());
234     if ((iRemoteObjectPtr->IsProxyObject()) && (!iRemoteObjectPtr->AddDeathRecipient(dr))) {
235         TELEPHONY_LOGE("Failed to add death recipient");
236         return TELEPHONY_ERROR;
237     }
238     callManagerServicePtr = iface_cast<ICallManagerService>(iRemoteObjectPtr);
239     if (!callManagerServicePtr) {
240         TELEPHONY_LOGE("iface_cast<ICallManagerService> failed!");
241         return TELEPHONY_ERR_LOCAL_PTR_NULL;
242     }
243     callManagerServicePtr_ = callManagerServicePtr;
244     deathRecipient_ = dr;
245     return TELEPHONY_SUCCESS;
246 }
247 
DisconnectService()248 void CallManagerProxy::DisconnectService()
249 {
250     UnRegisterCallBack();
251     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
252     if (callManagerServicePtr_ != nullptr) {
253         callManagerServicePtr_.clear();
254         callManagerServicePtr_ = nullptr;
255     }
256 }
257 
ReConnectService()258 int32_t CallManagerProxy::ReConnectService()
259 {
260     sptr<ICallManagerService> callManagerServicePtr = nullptr;
261     bool registerStatus = false;
262     {
263         Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
264         callManagerServicePtr = callManagerServicePtr_;
265         registerStatus = registerStatus_;
266     }
267     if (callManagerServicePtr == nullptr) {
268         TELEPHONY_LOGI("try to reconnect call manager service now...");
269         int32_t result = ConnectService();
270         if (result != TELEPHONY_SUCCESS) {
271             TELEPHONY_LOGE("Connect service: %{public}d", result);
272             return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
273         }
274         if (registerStatus) {
275             ReRegisterCallBack();
276         }
277     }
278     return TELEPHONY_SUCCESS;
279 }
280 
ReRegisterCallBack()281 int32_t CallManagerProxy::ReRegisterCallBack()
282 {
283     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
284     if (callManagerServicePtr_ == nullptr) {
285         TELEPHONY_LOGE("callManagerServicePtr_ is null");
286         return TELEPHONY_ERR_LOCAL_PTR_NULL;
287     }
288     if (callAbilityCallbackPtr_ == nullptr) {
289         TELEPHONY_LOGE("create CallAbilityCallback object failed!");
290         return TELEPHONY_ERR_LOCAL_PTR_NULL;
291     }
292     int32_t ret = callManagerServicePtr_->RegisterCallBack(callAbilityCallbackPtr_);
293     if (ret != TELEPHONY_SUCCESS) {
294         callAbilityCallbackPtr_.clear();
295         callAbilityCallbackPtr_ = nullptr;
296         TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
297         if (ret == TELEPHONY_ERR_PERMISSION_ERR) {
298             return TELEPHONY_ERR_PERMISSION_ERR;
299         }
300         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
301     }
302     TELEPHONY_LOGI("register call ability callback again success!");
303     return TELEPHONY_SUCCESS;
304 }
305 
ObserverOnCallDetailsChange()306 int32_t CallManagerProxy::ObserverOnCallDetailsChange()
307 {
308     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
309     if (callManagerServicePtr_ == nullptr) {
310         TELEPHONY_LOGE("callManagerServicePtr_ is null");
311         return TELEPHONY_ERR_LOCAL_PTR_NULL;
312     }
313     int32_t ret = callManagerServicePtr_->ObserverOnCallDetailsChange();
314     if (ret != TELEPHONY_SUCCESS) {
315         TELEPHONY_LOGE("report call state info failed when observe OnCallDetailsChange, result: %{public}d", ret);
316         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
317     }
318     return TELEPHONY_SUCCESS;
319 }
320 
RegisterVoipCallManagerCallback()321 int32_t CallManagerProxy::RegisterVoipCallManagerCallback()
322 {
323     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
324     if (callManagerServicePtr_ == nullptr) {
325         TELEPHONY_LOGE("callManagerServicePtr_ is null");
326         return TELEPHONY_ERR_LOCAL_PTR_NULL;
327     }
328     int32_t ret = callManagerServicePtr_->RegisterVoipCallManagerCallback();
329     if (ret != TELEPHONY_SUCCESS) {
330         TELEPHONY_LOGE("register callback to call manager service failed,result: %{public}d", ret);
331         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
332     }
333     return TELEPHONY_SUCCESS;
334 }
335 
UnRegisterVoipCallManagerCallback()336 int32_t CallManagerProxy::UnRegisterVoipCallManagerCallback()
337 {
338     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
339     if (callManagerServicePtr_ == nullptr) {
340         TELEPHONY_LOGE("callManagerServicePtr_ is null");
341         return TELEPHONY_ERR_LOCAL_PTR_NULL;
342     }
343     int32_t ret = callManagerServicePtr_->UnRegisterVoipCallManagerCallback();
344     if (ret != TELEPHONY_SUCCESS) {
345         TELEPHONY_LOGE("unregister callback to call manager service failed,result: %{public}d", ret);
346         return TELEPHONY_ERR_REGISTER_CALLBACK_FAIL;
347     }
348     return TELEPHONY_SUCCESS;
349 }
350 
DialCall(std::u16string number,AppExecFwk::PacMap & extras)351 int32_t CallManagerProxy::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
352 {
353     if (ReConnectService() != TELEPHONY_SUCCESS) {
354         TELEPHONY_LOGE("ipc reconnect failed!");
355         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
356     }
357     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
358     if (callManagerServicePtr_ == nullptr) {
359         TELEPHONY_LOGE("callManagerServicePtr_ is null");
360         return TELEPHONY_ERR_LOCAL_PTR_NULL;
361     }
362     int32_t errCode = callManagerServicePtr_->DialCall(number, extras);
363     if (errCode != TELEPHONY_SUCCESS) {
364         TELEPHONY_LOGE("DialCall failed, errcode:%{public}d", errCode);
365         return errCode;
366     }
367     return TELEPHONY_SUCCESS;
368 }
369 
MakeCall(std::string number)370 int32_t CallManagerProxy::MakeCall(std::string number)
371 {
372     if (ReConnectService() != TELEPHONY_SUCCESS) {
373         TELEPHONY_LOGE("ipc reconnect failed!");
374         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
375     }
376     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
377     if (callManagerServicePtr_ == nullptr) {
378         TELEPHONY_LOGE("callManagerServicePtr_ is null");
379         return TELEPHONY_ERR_LOCAL_PTR_NULL;
380     }
381     int32_t errCode = callManagerServicePtr_->MakeCall(number);
382     if (errCode != TELEPHONY_SUCCESS) {
383         TELEPHONY_LOGE("MakeCall failed, errcode:%{public}d", errCode);
384         return errCode;
385     }
386     return TELEPHONY_SUCCESS;
387 }
388 
AnswerCall(int32_t callId,int32_t videoState)389 int32_t CallManagerProxy::AnswerCall(int32_t callId, int32_t videoState)
390 {
391     if (ReConnectService() != TELEPHONY_SUCCESS) {
392         TELEPHONY_LOGE("ipc reconnect failed!");
393         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
394     }
395     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
396     if (callManagerServicePtr_ == nullptr) {
397         TELEPHONY_LOGE("callManagerServicePtr_ is null");
398         return TELEPHONY_ERR_LOCAL_PTR_NULL;
399     }
400     int32_t errCode = callManagerServicePtr_->AnswerCall(callId, videoState);
401     if (errCode != TELEPHONY_SUCCESS) {
402         TELEPHONY_LOGE("AnswerCall failed, errcode:%{public}d", errCode);
403         return errCode;
404     }
405     return TELEPHONY_SUCCESS;
406 }
407 
RejectCall(int32_t callId,bool isSendSms,std::u16string content)408 int32_t CallManagerProxy::RejectCall(int32_t callId, bool isSendSms, std::u16string content)
409 {
410     if (ReConnectService() != TELEPHONY_SUCCESS) {
411         TELEPHONY_LOGE("ipc reconnect failed!");
412         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
413     }
414     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
415     if (callManagerServicePtr_ == nullptr) {
416         TELEPHONY_LOGE("callManagerServicePtr_ is null");
417         return TELEPHONY_ERR_LOCAL_PTR_NULL;
418     }
419     int32_t errCode = callManagerServicePtr_->RejectCall(callId, isSendSms, content);
420     if (errCode != TELEPHONY_SUCCESS) {
421         TELEPHONY_LOGE("RejectCall failed, errcode:%{public}d", errCode);
422         return errCode;
423     }
424     return TELEPHONY_SUCCESS;
425 }
426 
HangUpCall(int32_t callId)427 int32_t CallManagerProxy::HangUpCall(int32_t callId)
428 {
429     if (ReConnectService() != TELEPHONY_SUCCESS) {
430         TELEPHONY_LOGE("ipc reconnect failed!");
431         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
432     }
433     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
434     if (callManagerServicePtr_ == nullptr) {
435         TELEPHONY_LOGE("callManagerServicePtr_ is null");
436         return TELEPHONY_ERR_LOCAL_PTR_NULL;
437     }
438     int32_t errCode = callManagerServicePtr_->HangUpCall(callId);
439     if (errCode != TELEPHONY_SUCCESS) {
440         TELEPHONY_LOGE("HangUpCall failed, errcode:%{public}d", errCode);
441         return errCode;
442     }
443     return TELEPHONY_SUCCESS;
444 }
445 
GetCallState()446 int32_t CallManagerProxy::GetCallState()
447 {
448     if (ReConnectService() != TELEPHONY_SUCCESS) {
449         TELEPHONY_LOGE("ipc reconnect failed!");
450         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
451     }
452     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
453     if (callManagerServicePtr_ == nullptr) {
454         TELEPHONY_LOGE("callManagerServicePtr_ is null");
455         return TELEPHONY_ERR_LOCAL_PTR_NULL;
456     }
457     int32_t errCode = callManagerServicePtr_->GetCallState();
458     if (errCode != TELEPHONY_SUCCESS) {
459         TELEPHONY_LOGD("GetCallState failed, errcode:%{public}d", errCode);
460         return errCode;
461     }
462     return TELEPHONY_SUCCESS;
463 }
464 
HoldCall(int32_t callId)465 int32_t CallManagerProxy::HoldCall(int32_t callId)
466 {
467     if (ReConnectService() != TELEPHONY_SUCCESS) {
468         TELEPHONY_LOGE("ipc reconnect failed!");
469         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
470     }
471     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
472     if (callManagerServicePtr_ == nullptr) {
473         TELEPHONY_LOGE("callManagerServicePtr_ is null");
474         return TELEPHONY_ERR_LOCAL_PTR_NULL;
475     }
476     int32_t errCode = callManagerServicePtr_->HoldCall(callId);
477     if (errCode != TELEPHONY_SUCCESS) {
478         TELEPHONY_LOGE("HoldCall failed, errcode:%{public}d", errCode);
479         return errCode;
480     }
481     return TELEPHONY_SUCCESS;
482 }
483 
UnHoldCall(int32_t callId)484 int32_t CallManagerProxy::UnHoldCall(int32_t callId)
485 {
486     if (ReConnectService() != TELEPHONY_SUCCESS) {
487         TELEPHONY_LOGE("ipc reconnect failed!");
488         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
489     }
490     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
491     if (callManagerServicePtr_ == nullptr) {
492         TELEPHONY_LOGE("callManagerServicePtr_ is null");
493         return TELEPHONY_ERR_LOCAL_PTR_NULL;
494     }
495     int32_t errCode = callManagerServicePtr_->UnHoldCall(callId);
496     if (errCode != TELEPHONY_SUCCESS) {
497         TELEPHONY_LOGE("UnHoldCall failed, errcode:%{public}d", errCode);
498         return errCode;
499     }
500     return TELEPHONY_SUCCESS;
501 }
502 
SwitchCall(int32_t callId)503 int32_t CallManagerProxy::SwitchCall(int32_t callId)
504 {
505     if (ReConnectService() != TELEPHONY_SUCCESS) {
506         TELEPHONY_LOGE("ipc reconnect failed!");
507         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
508     }
509     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
510     if (callManagerServicePtr_ == nullptr) {
511         TELEPHONY_LOGE("callManagerServicePtr_ is null");
512         return TELEPHONY_ERR_LOCAL_PTR_NULL;
513     }
514     int32_t errCode = callManagerServicePtr_->SwitchCall(callId);
515     if (errCode != TELEPHONY_SUCCESS) {
516         TELEPHONY_LOGE("SwitchCall failed, errcode:%{public}d", errCode);
517         return errCode;
518     }
519     return TELEPHONY_SUCCESS;
520 }
521 
CombineConference(int32_t callId)522 int32_t CallManagerProxy::CombineConference(int32_t callId)
523 {
524     if (ReConnectService() != TELEPHONY_SUCCESS) {
525         TELEPHONY_LOGE("ipc reconnect failed!");
526         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
527     }
528     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
529     if (callManagerServicePtr_ == nullptr) {
530         TELEPHONY_LOGE("callManagerServicePtr_ is null");
531         return TELEPHONY_ERR_LOCAL_PTR_NULL;
532     }
533     int32_t errCode = callManagerServicePtr_->CombineConference(callId);
534     if (errCode != TELEPHONY_SUCCESS) {
535         TELEPHONY_LOGE("CombineConference failed, errcode:%{public}d", errCode);
536         return errCode;
537     }
538     return TELEPHONY_SUCCESS;
539 }
540 
SeparateConference(int32_t callId)541 int32_t CallManagerProxy::SeparateConference(int32_t callId)
542 {
543     if (ReConnectService() != TELEPHONY_SUCCESS) {
544         TELEPHONY_LOGE("ipc reconnect failed!");
545         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
546     }
547     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
548     if (callManagerServicePtr_ == nullptr) {
549         TELEPHONY_LOGE("callManagerServicePtr_ is null");
550         return TELEPHONY_ERR_LOCAL_PTR_NULL;
551     }
552     int32_t errCode = callManagerServicePtr_->SeparateConference(callId);
553     if (errCode != TELEPHONY_SUCCESS) {
554         TELEPHONY_LOGE("SeparateConference failed, errcode:%{public}d", errCode);
555         return errCode;
556     }
557     return TELEPHONY_SUCCESS;
558 }
559 
KickOutFromConference(int32_t callId)560 int32_t CallManagerProxy::KickOutFromConference(int32_t callId)
561 {
562     if (ReConnectService() != TELEPHONY_SUCCESS) {
563         TELEPHONY_LOGE("ipc reconnect failed!");
564         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
565     }
566     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
567     if (callManagerServicePtr_ == nullptr) {
568         TELEPHONY_LOGE("callManagerServicePtr_ is null");
569         return TELEPHONY_ERR_LOCAL_PTR_NULL;
570     }
571     int32_t errCode = callManagerServicePtr_->KickOutFromConference(callId);
572     if (errCode != TELEPHONY_SUCCESS) {
573         TELEPHONY_LOGE("KickOutFromConference failed, errcode:%{public}d", errCode);
574         return errCode;
575     }
576     return TELEPHONY_SUCCESS;
577 }
578 
GetMainCallId(int32_t & callId,int32_t & mainCallId)579 int32_t CallManagerProxy::GetMainCallId(int32_t &callId, int32_t &mainCallId)
580 {
581     if (ReConnectService() != TELEPHONY_SUCCESS) {
582         TELEPHONY_LOGE("ipc reconnect failed!");
583         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
584     }
585     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
586     if (callManagerServicePtr_ == nullptr) {
587         TELEPHONY_LOGE("callManagerServicePtr_ is null");
588         return TELEPHONY_ERR_LOCAL_PTR_NULL;
589     }
590     int32_t errCode = callManagerServicePtr_->GetMainCallId(callId, mainCallId);
591     if (errCode != TELEPHONY_SUCCESS) {
592         TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
593         return errCode;
594     }
595     return TELEPHONY_SUCCESS;
596 }
597 
GetSubCallIdList(int32_t callId,std::vector<std::u16string> & callIdList)598 int32_t CallManagerProxy::GetSubCallIdList(int32_t callId, std::vector<std::u16string> &callIdList)
599 {
600     if (ReConnectService() != TELEPHONY_SUCCESS) {
601         TELEPHONY_LOGE("ipc reconnect failed!");
602         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
603     }
604     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
605     if (callManagerServicePtr_ == nullptr) {
606         TELEPHONY_LOGE("callManagerServicePtr_ is null");
607         return TELEPHONY_ERR_LOCAL_PTR_NULL;
608     }
609     int32_t errCode = callManagerServicePtr_->GetSubCallIdList(callId, callIdList);
610     if (errCode != TELEPHONY_SUCCESS) {
611         TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
612         return errCode;
613     }
614     return TELEPHONY_SUCCESS;
615 }
616 
GetCallIdListForConference(int32_t callId,std::vector<std::u16string> & callIdList)617 int32_t CallManagerProxy::GetCallIdListForConference(int32_t callId, std::vector<std::u16string> &callIdList)
618 {
619     if (ReConnectService() != TELEPHONY_SUCCESS) {
620         TELEPHONY_LOGE("ipc reconnect failed!");
621         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
622     }
623     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
624     if (callManagerServicePtr_ == nullptr) {
625         TELEPHONY_LOGE("callManagerServicePtr_ is null");
626         return TELEPHONY_ERR_LOCAL_PTR_NULL;
627     }
628     int32_t errCode = callManagerServicePtr_->GetCallIdListForConference(callId, callIdList);
629     if (errCode != TELEPHONY_SUCCESS) {
630         TELEPHONY_LOGE("GetMainCallId failed, errcode:%{public}d", errCode);
631         return errCode;
632     }
633     return TELEPHONY_SUCCESS;
634 }
635 
GetCallWaiting(int32_t slotId)636 int32_t CallManagerProxy::GetCallWaiting(int32_t slotId)
637 {
638     if (ReConnectService() != TELEPHONY_SUCCESS) {
639         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
640         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
641     }
642     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
643     if (callManagerServicePtr_ == nullptr) {
644         TELEPHONY_LOGE("callManagerServicePtr_ is null");
645         return TELEPHONY_ERR_LOCAL_PTR_NULL;
646     }
647     int32_t errCode = callManagerServicePtr_->GetCallWaiting(slotId);
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 
SetCallWaiting(int32_t slotId,bool activate)655 int32_t CallManagerProxy::SetCallWaiting(int32_t slotId, bool activate)
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     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
662     if (callManagerServicePtr_ == nullptr) {
663         TELEPHONY_LOGE("callManagerServicePtr_ is null");
664         return TELEPHONY_ERR_LOCAL_PTR_NULL;
665     }
666     int32_t errCode = callManagerServicePtr_->SetCallWaiting(slotId, activate);
667     if (errCode != TELEPHONY_SUCCESS) {
668         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
669         return errCode;
670     }
671     return TELEPHONY_SUCCESS;
672 }
673 
GetCallRestriction(int32_t slotId,CallRestrictionType type)674 int32_t CallManagerProxy::GetCallRestriction(int32_t slotId, CallRestrictionType type)
675 {
676     if (ReConnectService() != TELEPHONY_SUCCESS) {
677         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
678         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
679     }
680     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
681     if (callManagerServicePtr_ == nullptr) {
682         TELEPHONY_LOGE("callManagerServicePtr_ is null");
683         return TELEPHONY_ERR_LOCAL_PTR_NULL;
684     }
685     int32_t errCode = callManagerServicePtr_->GetCallRestriction(slotId, type);
686     if (errCode != TELEPHONY_SUCCESS) {
687         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
688         return errCode;
689     }
690     return TELEPHONY_SUCCESS;
691 }
692 
SetCallRestriction(int32_t slotId,CallRestrictionInfo & info)693 int32_t CallManagerProxy::SetCallRestriction(int32_t slotId, CallRestrictionInfo &info)
694 {
695     if (ReConnectService() != TELEPHONY_SUCCESS) {
696         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
697         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
698     }
699     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
700     if (callManagerServicePtr_ == nullptr) {
701         TELEPHONY_LOGE("callManagerServicePtr_ is null");
702         return TELEPHONY_ERR_LOCAL_PTR_NULL;
703     }
704     int32_t errCode = callManagerServicePtr_->SetCallRestriction(slotId, info);
705     if (errCode != TELEPHONY_SUCCESS) {
706         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
707         return errCode;
708     }
709     return TELEPHONY_SUCCESS;
710 }
711 
SetCallRestrictionPassword(int32_t slotId,CallRestrictionType fac,const char * oldPassword,const char * newPassword)712 int32_t CallManagerProxy::SetCallRestrictionPassword(
713     int32_t slotId, CallRestrictionType fac, const char *oldPassword, const char *newPassword)
714 {
715     if (ReConnectService() != TELEPHONY_SUCCESS) {
716         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
717         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
718     }
719     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
720     if (callManagerServicePtr_ == nullptr) {
721         TELEPHONY_LOGE("callManagerServicePtr_ is null");
722         return TELEPHONY_ERR_LOCAL_PTR_NULL;
723     }
724     int32_t errCode = callManagerServicePtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
725     if (errCode != TELEPHONY_SUCCESS) {
726         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
727         return errCode;
728     }
729     return TELEPHONY_SUCCESS;
730 }
731 
GetCallTransferInfo(int32_t slotId,CallTransferType type)732 int32_t CallManagerProxy::GetCallTransferInfo(int32_t slotId, CallTransferType type)
733 {
734     if (ReConnectService() != TELEPHONY_SUCCESS) {
735         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
736         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
737     }
738     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
739     if (callManagerServicePtr_ == nullptr) {
740         TELEPHONY_LOGE("callManagerServicePtr_ is null");
741         return TELEPHONY_ERR_LOCAL_PTR_NULL;
742     }
743     int32_t errCode = callManagerServicePtr_->GetCallTransferInfo(slotId, type);
744     if (errCode != TELEPHONY_SUCCESS) {
745         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
746         return errCode;
747     }
748     return TELEPHONY_SUCCESS;
749 }
750 
SetCallTransferInfo(int32_t slotId,CallTransferInfo & info)751 int32_t CallManagerProxy::SetCallTransferInfo(int32_t slotId, CallTransferInfo &info)
752 {
753     if (ReConnectService() != TELEPHONY_SUCCESS) {
754         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
755         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
756     }
757     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
758     if (callManagerServicePtr_ == nullptr) {
759         TELEPHONY_LOGE("callManagerServicePtr_ is null");
760         return TELEPHONY_ERR_LOCAL_PTR_NULL;
761     }
762     int32_t errCode = callManagerServicePtr_->SetCallTransferInfo(slotId, info);
763     if (errCode != TELEPHONY_SUCCESS) {
764         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
765         return errCode;
766     }
767     return TELEPHONY_SUCCESS;
768 }
769 
CanSetCallTransferTime(int32_t slotId,bool & result)770 int32_t CallManagerProxy::CanSetCallTransferTime(int32_t slotId, bool &result)
771 {
772     if (ReConnectService() != TELEPHONY_SUCCESS) {
773         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
774         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
775     }
776     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
777     if (callManagerServicePtr_ == nullptr) {
778         TELEPHONY_LOGE("callManagerServicePtr_ is null");
779         return TELEPHONY_ERR_LOCAL_PTR_NULL;
780     }
781     return callManagerServicePtr_->CanSetCallTransferTime(slotId, result);
782 }
783 
SetCallPreferenceMode(int32_t slotId,int32_t mode)784 int32_t CallManagerProxy::SetCallPreferenceMode(int32_t slotId, int32_t mode)
785 {
786     if (ReConnectService() != TELEPHONY_SUCCESS) {
787         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
788         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
789     }
790     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
791     if (callManagerServicePtr_ == nullptr) {
792         TELEPHONY_LOGE("callManagerServicePtr_ is null");
793         return TELEPHONY_ERR_LOCAL_PTR_NULL;
794     }
795     int32_t errCode = callManagerServicePtr_->SetCallPreferenceMode(slotId, mode);
796     if (errCode != TELEPHONY_SUCCESS) {
797         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
798         return errCode;
799     }
800     return TELEPHONY_SUCCESS;
801 }
802 
StartDtmf(int32_t callId,char str)803 int32_t CallManagerProxy::StartDtmf(int32_t callId, char str)
804 {
805     if (ReConnectService() != TELEPHONY_SUCCESS) {
806         TELEPHONY_LOGE("ipc reconnect failed!");
807         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
808     }
809     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
810     if (callManagerServicePtr_ == nullptr) {
811         TELEPHONY_LOGE("callManagerServicePtr_ is null");
812         return TELEPHONY_ERR_LOCAL_PTR_NULL;
813     }
814     int32_t errCode = callManagerServicePtr_->StartDtmf(callId, str);
815     if (errCode != TELEPHONY_SUCCESS) {
816         TELEPHONY_LOGE("StartDtmf failed, errcode:%{public}d", errCode);
817         return errCode;
818     }
819     return TELEPHONY_SUCCESS;
820 }
821 
StopDtmf(int32_t callId)822 int32_t CallManagerProxy::StopDtmf(int32_t callId)
823 {
824     if (ReConnectService() != TELEPHONY_SUCCESS) {
825         TELEPHONY_LOGE("ipc reconnect failed!");
826         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
827     }
828     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
829     if (callManagerServicePtr_ == nullptr) {
830         TELEPHONY_LOGE("callManagerServicePtr_ is null");
831         return TELEPHONY_ERR_LOCAL_PTR_NULL;
832     }
833     int32_t errCode = callManagerServicePtr_->StopDtmf(callId);
834     if (errCode != TELEPHONY_SUCCESS) {
835         TELEPHONY_LOGE("StopDtmf failed, errcode:%{public}d", errCode);
836         return errCode;
837     }
838     return TELEPHONY_SUCCESS;
839 }
840 
PostDialProceed(int32_t callId,bool proceed)841 int32_t CallManagerProxy::PostDialProceed(int32_t callId, bool proceed)
842 {
843     if (ReConnectService() != TELEPHONY_SUCCESS) {
844         TELEPHONY_LOGE("ipc reconnect failed!");
845         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
846     }
847     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
848     if (callManagerServicePtr_ == nullptr) {
849         TELEPHONY_LOGE("callManagerServicePtr_ is null");
850         return TELEPHONY_ERR_LOCAL_PTR_NULL;
851     }
852     int32_t errCode = callManagerServicePtr_->PostDialProceed(callId, proceed);
853     if (errCode != TELEPHONY_SUCCESS) {
854         TELEPHONY_LOGE("PostDialProceed failed, errcode:%{public}d", errCode);
855         return errCode;
856     }
857     return TELEPHONY_SUCCESS;
858 }
859 
IsRinging(bool & enabled)860 int32_t CallManagerProxy::IsRinging(bool &enabled)
861 {
862     if (ReConnectService() != TELEPHONY_SUCCESS) {
863         TELEPHONY_LOGE("ipc reconnect failed!");
864         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
865     }
866     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
867     if (callManagerServicePtr_ == nullptr) {
868         TELEPHONY_LOGE("callManagerServicePtr_ is null");
869         return TELEPHONY_ERR_LOCAL_PTR_NULL;
870     }
871     return callManagerServicePtr_->IsRinging(enabled);
872 }
873 
HasCall()874 bool CallManagerProxy::HasCall()
875 {
876     if (ReConnectService() != TELEPHONY_SUCCESS) {
877         TELEPHONY_LOGE("ipc reconnect failed!");
878         return false;
879     }
880     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
881     if (callManagerServicePtr_ == nullptr) {
882         TELEPHONY_LOGE("callManagerServicePtr_ is null");
883         return TELEPHONY_ERR_LOCAL_PTR_NULL;
884     }
885     return callManagerServicePtr_->HasCall();
886 }
887 
IsNewCallAllowed(bool & enabled)888 int32_t CallManagerProxy::IsNewCallAllowed(bool &enabled)
889 {
890     if (ReConnectService() != TELEPHONY_SUCCESS) {
891         TELEPHONY_LOGE("ipc reconnect failed!");
892         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
893     }
894     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
895     if (callManagerServicePtr_ == nullptr) {
896         TELEPHONY_LOGE("callManagerServicePtr_ is null");
897         return TELEPHONY_ERR_LOCAL_PTR_NULL;
898     }
899     return callManagerServicePtr_->IsNewCallAllowed(enabled);
900 }
901 
IsInEmergencyCall(bool & enabled)902 int32_t CallManagerProxy::IsInEmergencyCall(bool &enabled)
903 {
904     if (ReConnectService() != TELEPHONY_SUCCESS) {
905         TELEPHONY_LOGE("ipc reconnect failed!");
906         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
907     }
908     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
909     if (callManagerServicePtr_ == nullptr) {
910         TELEPHONY_LOGE("callManagerServicePtr_ is null");
911         return TELEPHONY_ERR_LOCAL_PTR_NULL;
912     }
913     return callManagerServicePtr_->IsInEmergencyCall(enabled);
914 }
915 
IsEmergencyPhoneNumber(std::u16string & number,int32_t slotId,bool & enabled)916 int32_t CallManagerProxy::IsEmergencyPhoneNumber(std::u16string &number, int32_t slotId, bool &enabled)
917 {
918     if (ReConnectService() != TELEPHONY_SUCCESS) {
919         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
920         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
921     }
922     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
923     if (callManagerServicePtr_ == nullptr) {
924         TELEPHONY_LOGE("callManagerServicePtr_ is null");
925         return TELEPHONY_ERR_LOCAL_PTR_NULL;
926     }
927     return callManagerServicePtr_->IsEmergencyPhoneNumber(number, slotId, enabled);
928 }
929 
FormatPhoneNumber(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)930 int32_t CallManagerProxy::FormatPhoneNumber(
931     std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
932 {
933     if (ReConnectService() != TELEPHONY_SUCCESS) {
934         TELEPHONY_LOGE("ipc reconnect failed!");
935         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
936     }
937     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
938     if (callManagerServicePtr_ == nullptr) {
939         TELEPHONY_LOGE("callManagerServicePtr_ is null");
940         return TELEPHONY_ERR_LOCAL_PTR_NULL;
941     }
942     int32_t errCode = callManagerServicePtr_->FormatPhoneNumber(number, countryCode, formatNumber);
943     if (errCode != TELEPHONY_SUCCESS) {
944         TELEPHONY_LOGE("FormatPhoneNumber failed, errcode:%{public}d", errCode);
945         return errCode;
946     }
947     return TELEPHONY_SUCCESS;
948 }
949 
FormatPhoneNumberToE164(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)950 int32_t CallManagerProxy::FormatPhoneNumberToE164(
951     std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
952 {
953     if (ReConnectService() != TELEPHONY_SUCCESS) {
954         TELEPHONY_LOGE("ipc reconnect failed!");
955         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
956     }
957     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
958     if (callManagerServicePtr_ == nullptr) {
959         TELEPHONY_LOGE("callManagerServicePtr_ is null");
960         return TELEPHONY_ERR_LOCAL_PTR_NULL;
961     }
962     int32_t errCode = callManagerServicePtr_->FormatPhoneNumberToE164(number, countryCode, formatNumber);
963     if (errCode != TELEPHONY_SUCCESS) {
964         TELEPHONY_LOGE("FormatPhoneNumberToE164 failed, errcode:%{public}d", errCode);
965         return errCode;
966     }
967     return TELEPHONY_SUCCESS;
968 }
969 
SetMuted(bool isMute)970 int32_t CallManagerProxy::SetMuted(bool isMute)
971 {
972     if (ReConnectService() != TELEPHONY_SUCCESS) {
973         TELEPHONY_LOGE("ipc reconnect failed!");
974         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
975     }
976     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
977     if (callManagerServicePtr_ == nullptr) {
978         TELEPHONY_LOGE("callManagerServicePtr_ is null");
979         return TELEPHONY_ERR_LOCAL_PTR_NULL;
980     }
981     int32_t errCode = callManagerServicePtr_->SetMuted(isMute);
982     if (errCode != TELEPHONY_SUCCESS) {
983         TELEPHONY_LOGE("SetMute failed, errcode:%{public}d", errCode);
984         return errCode;
985     }
986     return TELEPHONY_SUCCESS;
987 }
988 
MuteRinger()989 int32_t CallManagerProxy::MuteRinger()
990 {
991     if (ReConnectService() != TELEPHONY_SUCCESS) {
992         TELEPHONY_LOGE("ipc reconnect failed!");
993         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
994     }
995     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
996     if (callManagerServicePtr_ == nullptr) {
997         TELEPHONY_LOGE("callManagerServicePtr_ is null");
998         return TELEPHONY_ERR_LOCAL_PTR_NULL;
999     }
1000     int32_t errCode = callManagerServicePtr_->MuteRinger();
1001     if (errCode != TELEPHONY_SUCCESS) {
1002         TELEPHONY_LOGE("MuteRinger failed, errcode:%{public}d", errCode);
1003         return errCode;
1004     }
1005     return TELEPHONY_SUCCESS;
1006 }
1007 
SetAudioDevice(const AudioDevice & audioDevice)1008 int32_t CallManagerProxy::SetAudioDevice(const AudioDevice &audioDevice)
1009 {
1010     if (ReConnectService() != TELEPHONY_SUCCESS) {
1011         TELEPHONY_LOGE("ipc reconnect failed!");
1012         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1013     }
1014     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1015     if (callManagerServicePtr_ == nullptr) {
1016         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1017         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1018     }
1019     int32_t errCode = callManagerServicePtr_->SetAudioDevice(audioDevice);
1020     if (errCode != TELEPHONY_SUCCESS) {
1021         TELEPHONY_LOGE("SetAudioDevice failed, errcode:%{public}d", errCode);
1022         return errCode;
1023     }
1024     return TELEPHONY_SUCCESS;
1025 }
1026 
ControlCamera(int32_t callId,std::u16string & cameraId)1027 int32_t CallManagerProxy::ControlCamera(int32_t callId, std::u16string &cameraId)
1028 {
1029     if (ReConnectService() != TELEPHONY_SUCCESS) {
1030         TELEPHONY_LOGE("ipc reconnect failed!");
1031         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1032     }
1033     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1034     if (callManagerServicePtr_ == nullptr) {
1035         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1036         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1037     }
1038     int32_t errCode = callManagerServicePtr_->ControlCamera(callId, cameraId);
1039     if (errCode != TELEPHONY_SUCCESS) {
1040         TELEPHONY_LOGE("ControlCamera failed, errcode:%{public}d", errCode);
1041         return errCode;
1042     }
1043     return TELEPHONY_SUCCESS;
1044 }
1045 
SetPreviewWindow(int32_t callId,std::string & surfaceId)1046 int32_t CallManagerProxy::SetPreviewWindow(int32_t callId, std::string &surfaceId)
1047 {
1048     if (ReConnectService() != TELEPHONY_SUCCESS) {
1049         TELEPHONY_LOGE("ipc reconnect failed!");
1050         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1051     }
1052     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1053     TELEPHONY_LOGI("surfaceId is %{public}s", surfaceId.c_str());
1054     if (callManagerServicePtr_ == nullptr) {
1055         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1056         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1057     }
1058     int32_t errCode = TELEPHONY_SUCCESS;
1059     if (surfaceId.empty() || surfaceId[0] < '0' || surfaceId[0] > '9') {
1060         TELEPHONY_LOGI("surfaceId is invalid, set surface nullptr");
1061         surfaceId = "";
1062         errCode = callManagerServicePtr_->SetPreviewWindow(callId, surfaceId, nullptr);
1063     } else {
1064         uint64_t previewSurfaceId = std::stoull(surfaceId);
1065         auto surface = SurfaceUtils::GetInstance()->GetSurface(previewSurfaceId);
1066         if (surface == nullptr) {
1067             TELEPHONY_LOGI("surface is null");
1068             surfaceId = "";
1069         }
1070         errCode = callManagerServicePtr_->SetPreviewWindow(callId, surfaceId, surface);
1071     }
1072     if (errCode != TELEPHONY_SUCCESS) {
1073         TELEPHONY_LOGE("SetPreviewWindow failed, errcode:%{public}d", errCode);
1074         return errCode;
1075     }
1076     return TELEPHONY_SUCCESS;
1077 }
1078 
SetDisplayWindow(int32_t callId,std::string & surfaceId)1079 int32_t CallManagerProxy::SetDisplayWindow(int32_t callId, std::string &surfaceId)
1080 {
1081     if (ReConnectService() != TELEPHONY_SUCCESS) {
1082         TELEPHONY_LOGE("ipc reconnect failed!");
1083         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1084     }
1085     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1086     TELEPHONY_LOGI("surfaceId is %{public}s", surfaceId.c_str());
1087     int32_t errCode = TELEPHONY_SUCCESS;
1088     if (callManagerServicePtr_ == nullptr) {
1089         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1090         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1091     }
1092     if (surfaceId.empty() || surfaceId[0] < '0' || surfaceId[0] > '9') {
1093         TELEPHONY_LOGI("surfaceId is invalid, set surface nullptr");
1094         surfaceId = "";
1095         errCode = callManagerServicePtr_->SetDisplayWindow(callId, surfaceId, nullptr);
1096     } else {
1097         uint64_t displaySurfaceId = std::stoull(surfaceId);
1098         auto surface = SurfaceUtils::GetInstance()->GetSurface(displaySurfaceId);
1099         if (surface == nullptr) {
1100             TELEPHONY_LOGI("surface is null");
1101             surfaceId = "";
1102         }
1103         errCode = callManagerServicePtr_->SetDisplayWindow(callId, surfaceId, surface);
1104     }
1105     if (errCode != TELEPHONY_SUCCESS) {
1106         TELEPHONY_LOGE("SetDisplayWindow failed, errcode:%{public}d", errCode);
1107         return errCode;
1108     }
1109     return TELEPHONY_SUCCESS;
1110 }
1111 
SetCameraZoom(float zoomRatio)1112 int32_t CallManagerProxy::SetCameraZoom(float zoomRatio)
1113 {
1114     if (ReConnectService() != TELEPHONY_SUCCESS) {
1115         TELEPHONY_LOGE("ipc reconnect failed!");
1116         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1117     }
1118     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1119     if (callManagerServicePtr_ == nullptr) {
1120         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1121         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1122     }
1123     int32_t errCode = callManagerServicePtr_->SetCameraZoom(zoomRatio);
1124     if (errCode != TELEPHONY_SUCCESS) {
1125         TELEPHONY_LOGE("SetCameraZoom failed, errcode:%{public}d", errCode);
1126         return errCode;
1127     }
1128     return TELEPHONY_SUCCESS;
1129 }
1130 
SetPausePicture(int32_t callId,std::u16string & path)1131 int32_t CallManagerProxy::SetPausePicture(int32_t callId, std::u16string &path)
1132 {
1133     if (ReConnectService() != TELEPHONY_SUCCESS) {
1134         TELEPHONY_LOGE("ipc reconnect failed!");
1135         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1136     }
1137     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1138     if (callManagerServicePtr_ == nullptr) {
1139         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1140         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1141     }
1142     int32_t errCode = callManagerServicePtr_->SetPausePicture(callId, path);
1143     if (errCode != TELEPHONY_SUCCESS) {
1144         TELEPHONY_LOGE("SetPausePicture failed, errcode:%{public}d", errCode);
1145         return errCode;
1146     }
1147     return TELEPHONY_SUCCESS;
1148 }
1149 
SetDeviceDirection(int32_t callId,int32_t rotation)1150 int32_t CallManagerProxy::SetDeviceDirection(int32_t callId, int32_t rotation)
1151 {
1152     if (ReConnectService() != TELEPHONY_SUCCESS) {
1153         TELEPHONY_LOGE("ipc reconnect failed!");
1154         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1155     }
1156     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1157     if (callManagerServicePtr_ == nullptr) {
1158         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1159         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1160     }
1161     int32_t errCode = callManagerServicePtr_->SetDeviceDirection(callId, rotation);
1162     if (errCode != TELEPHONY_SUCCESS) {
1163         TELEPHONY_LOGE("SetDeviceDirection failed, errcode:%{public}d", errCode);
1164         return errCode;
1165     }
1166     return TELEPHONY_SUCCESS;
1167 }
1168 
GetImsConfig(int32_t slotId,ImsConfigItem item)1169 int32_t CallManagerProxy::GetImsConfig(int32_t slotId, ImsConfigItem item)
1170 {
1171     if (ReConnectService() != TELEPHONY_SUCCESS) {
1172         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1173         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1174     }
1175     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1176     if (callManagerServicePtr_ == nullptr) {
1177         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1178         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1179     }
1180     int32_t errCode = callManagerServicePtr_->GetImsConfig(slotId, item);
1181     if (errCode != TELEPHONY_SUCCESS) {
1182         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1183         return errCode;
1184     }
1185     return TELEPHONY_SUCCESS;
1186 }
1187 
SetImsConfig(int32_t slotId,ImsConfigItem item,std::u16string & value)1188 int32_t CallManagerProxy::SetImsConfig(int32_t slotId, ImsConfigItem item, std::u16string &value)
1189 {
1190     if (ReConnectService() != TELEPHONY_SUCCESS) {
1191         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1192         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1193     }
1194     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1195     if (callManagerServicePtr_ == nullptr) {
1196         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1197         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1198     }
1199     int32_t errCode = callManagerServicePtr_->SetImsConfig(slotId, item, value);
1200     if (errCode != TELEPHONY_SUCCESS) {
1201         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1202         return errCode;
1203     }
1204     return TELEPHONY_SUCCESS;
1205 }
1206 
GetImsFeatureValue(int32_t slotId,FeatureType type)1207 int32_t CallManagerProxy::GetImsFeatureValue(int32_t slotId, FeatureType type)
1208 {
1209     if (ReConnectService() != TELEPHONY_SUCCESS) {
1210         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1211         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1212     }
1213     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1214     if (callManagerServicePtr_ == nullptr) {
1215         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1216         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1217     }
1218     int32_t errCode = callManagerServicePtr_->GetImsFeatureValue(slotId, type);
1219     if (errCode != TELEPHONY_SUCCESS) {
1220         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1221         return errCode;
1222     }
1223     return TELEPHONY_SUCCESS;
1224 }
1225 
SetImsFeatureValue(int32_t slotId,FeatureType type,int32_t value)1226 int32_t CallManagerProxy::SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value)
1227 {
1228     if (ReConnectService() != TELEPHONY_SUCCESS) {
1229         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1230         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1231     }
1232     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1233     if (callManagerServicePtr_ == nullptr) {
1234         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1235         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1236     }
1237     int32_t errCode = callManagerServicePtr_->SetImsFeatureValue(slotId, type, value);
1238     if (errCode != TELEPHONY_SUCCESS) {
1239         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1240         return errCode;
1241     }
1242     return TELEPHONY_SUCCESS;
1243 }
1244 
UpdateImsCallMode(int32_t callId,ImsCallMode mode)1245 int32_t CallManagerProxy::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1246 {
1247     if (ReConnectService() != TELEPHONY_SUCCESS) {
1248         TELEPHONY_LOGE("ipc reconnect failed!");
1249         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1250     }
1251     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1252     if (callManagerServicePtr_ == nullptr) {
1253         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1254         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1255     }
1256     int32_t errCode = callManagerServicePtr_->UpdateImsCallMode(callId, mode);
1257     if (errCode != TELEPHONY_SUCCESS) {
1258         TELEPHONY_LOGE("UpdateImsCallMode failed, errcode:%{public}d", errCode);
1259         return errCode;
1260     }
1261     return TELEPHONY_SUCCESS;
1262 }
1263 
EnableImsSwitch(int32_t slotId)1264 int32_t CallManagerProxy::EnableImsSwitch(int32_t slotId)
1265 {
1266     if (ReConnectService() != TELEPHONY_SUCCESS) {
1267         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1268         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1269     }
1270     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1271     if (callManagerServicePtr_ == nullptr) {
1272         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1273         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1274     }
1275     int32_t errCode = callManagerServicePtr_->EnableImsSwitch(slotId);
1276     if (errCode != TELEPHONY_SUCCESS) {
1277         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1278         return errCode;
1279     }
1280     return TELEPHONY_SUCCESS;
1281 }
1282 
DisableImsSwitch(int32_t slotId)1283 int32_t CallManagerProxy::DisableImsSwitch(int32_t slotId)
1284 {
1285     if (ReConnectService() != TELEPHONY_SUCCESS) {
1286         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1287         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1288     }
1289     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1290     if (callManagerServicePtr_ == nullptr) {
1291         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1292         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1293     }
1294     int32_t errCode = callManagerServicePtr_->DisableImsSwitch(slotId);
1295     if (errCode != TELEPHONY_SUCCESS) {
1296         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1297         return errCode;
1298     }
1299     return TELEPHONY_SUCCESS;
1300 }
1301 
IsImsSwitchEnabled(int32_t slotId,bool & enabled)1302 int32_t CallManagerProxy::IsImsSwitchEnabled(int32_t slotId, bool &enabled)
1303 {
1304     if (ReConnectService() != TELEPHONY_SUCCESS) {
1305         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1306         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1307     }
1308     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1309     if (callManagerServicePtr_ == nullptr) {
1310         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1311         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1312     }
1313     int32_t errCode = callManagerServicePtr_->IsImsSwitchEnabled(slotId, enabled);
1314     if (errCode != TELEPHONY_SUCCESS) {
1315         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1316         return errCode;
1317     }
1318     return TELEPHONY_SUCCESS;
1319 }
1320 
SetVoNRState(int32_t slotId,int32_t state)1321 int32_t CallManagerProxy::SetVoNRState(int32_t slotId, int32_t state)
1322 {
1323     if (ReConnectService() != TELEPHONY_SUCCESS) {
1324         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1325         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1326     }
1327     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1328     if (callManagerServicePtr_ == nullptr) {
1329         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1330         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1331     }
1332     int32_t errCode = callManagerServicePtr_->SetVoNRState(slotId, state);
1333     if (errCode != TELEPHONY_SUCCESS) {
1334         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1335         return errCode;
1336     }
1337     return TELEPHONY_SUCCESS;
1338 }
1339 
GetVoNRState(int32_t slotId,int32_t & state)1340 int32_t CallManagerProxy::GetVoNRState(int32_t slotId, int32_t &state)
1341 {
1342     if (ReConnectService() != TELEPHONY_SUCCESS) {
1343         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1344         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1345     }
1346     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1347     if (callManagerServicePtr_ == nullptr) {
1348         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1349         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1350     }
1351     int32_t errCode = callManagerServicePtr_->GetVoNRState(slotId, state);
1352     if (errCode != TELEPHONY_SUCCESS) {
1353         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1354         return errCode;
1355     }
1356     return TELEPHONY_SUCCESS;
1357 }
1358 
StartRtt(int32_t callId,std::u16string & msg)1359 int32_t CallManagerProxy::StartRtt(int32_t callId, std::u16string &msg)
1360 {
1361     if (ReConnectService() != TELEPHONY_SUCCESS) {
1362         TELEPHONY_LOGE("ipc reconnect failed!");
1363         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1364     }
1365     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1366     if (callManagerServicePtr_ == nullptr) {
1367         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1368         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1369     }
1370     int32_t errCode = callManagerServicePtr_->StartRtt(callId, msg);
1371     if (errCode != TELEPHONY_SUCCESS) {
1372         TELEPHONY_LOGE("StartRtt failed, errcode:%{public}d", errCode);
1373         return errCode;
1374     }
1375     return TELEPHONY_SUCCESS;
1376 }
1377 
StopRtt(int32_t callId)1378 int32_t CallManagerProxy::StopRtt(int32_t callId)
1379 {
1380     if (ReConnectService() != TELEPHONY_SUCCESS) {
1381         TELEPHONY_LOGE("ipc reconnect failed!");
1382         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1383     }
1384     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1385     if (callManagerServicePtr_ == nullptr) {
1386         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1387         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1388     }
1389     int32_t errCode = callManagerServicePtr_->StopRtt(callId);
1390     if (errCode != TELEPHONY_SUCCESS) {
1391         TELEPHONY_LOGE("StopRtt failed, errcode:%{public}d", errCode);
1392         return errCode;
1393     }
1394     return TELEPHONY_SUCCESS;
1395 }
1396 
JoinConference(int32_t callId,std::vector<std::u16string> & numberList)1397 int32_t CallManagerProxy::JoinConference(int32_t callId, std::vector<std::u16string> &numberList)
1398 {
1399     if (ReConnectService() != TELEPHONY_SUCCESS) {
1400         TELEPHONY_LOGE("ipc reconnect failed!");
1401         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1402     }
1403     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1404     if (callManagerServicePtr_ == nullptr) {
1405         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1406         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1407     }
1408     int32_t errCode = callManagerServicePtr_->JoinConference(callId, numberList);
1409     if (errCode != TELEPHONY_SUCCESS) {
1410         TELEPHONY_LOGE("JoinConference failed, errcode:%{public}d", errCode);
1411         return errCode;
1412     }
1413     return TELEPHONY_SUCCESS;
1414 }
1415 
ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> & ottVec)1416 int32_t CallManagerProxy::ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> &ottVec)
1417 {
1418     if (ReConnectService() != TELEPHONY_SUCCESS) {
1419         TELEPHONY_LOGE("ipc reconnect failed!");
1420         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1421     }
1422     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1423     if (callManagerServicePtr_ == nullptr) {
1424         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1425         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1426     }
1427     int32_t errCode = callManagerServicePtr_->ReportOttCallDetailsInfo(ottVec);
1428     if (errCode != TELEPHONY_SUCCESS) {
1429         TELEPHONY_LOGE("ReportOttCallInfo failed, errcode:%{public}d", errCode);
1430         return errCode;
1431     }
1432     return TELEPHONY_SUCCESS;
1433 }
1434 
ReportOttCallEventInfo(OttCallEventInfo & eventInfo)1435 int32_t CallManagerProxy::ReportOttCallEventInfo(OttCallEventInfo &eventInfo)
1436 {
1437     if (ReConnectService() != TELEPHONY_SUCCESS) {
1438         TELEPHONY_LOGE("ipc reconnect failed!");
1439         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1440     }
1441     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1442     if (callManagerServicePtr_ == nullptr) {
1443         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1444         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1445     }
1446     int32_t errCode = callManagerServicePtr_->ReportOttCallEventInfo(eventInfo);
1447     if (errCode != TELEPHONY_SUCCESS) {
1448         TELEPHONY_LOGE("ReportOttCallEventInfo failed, errcode:%{public}d", errCode);
1449         return errCode;
1450     }
1451     return TELEPHONY_SUCCESS;
1452 }
1453 
CloseUnFinishedUssd(int32_t slotId)1454 int32_t CallManagerProxy::CloseUnFinishedUssd(int32_t slotId)
1455 {
1456     if (ReConnectService() != TELEPHONY_SUCCESS) {
1457         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
1458         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1459     }
1460     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1461     if (callManagerServicePtr_ == nullptr) {
1462         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1463         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1464     }
1465     int32_t errCode = callManagerServicePtr_->CloseUnFinishedUssd(slotId);
1466     if (errCode != TELEPHONY_SUCCESS) {
1467         TELEPHONY_LOGE("[slot%{public}d] failed, errcode:%{public}d", slotId, errCode);
1468         return errCode;
1469     }
1470     return TELEPHONY_SUCCESS;
1471 }
1472 
InputDialerSpecialCode(const std::string & specialCode)1473 int32_t CallManagerProxy::InputDialerSpecialCode(const std::string &specialCode)
1474 {
1475     if (ReConnectService() != TELEPHONY_SUCCESS) {
1476         TELEPHONY_LOGE("ipc reconnect failed!");
1477         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1478     }
1479 
1480     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1481     if (callManagerServicePtr_ == nullptr) {
1482         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1483         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1484     }
1485     int32_t errCode = callManagerServicePtr_->InputDialerSpecialCode(specialCode);
1486     if (errCode != TELEPHONY_SUCCESS) {
1487         TELEPHONY_LOGE("InputDialerSpecialCode failed, errcode:%{public}d", errCode);
1488         return errCode;
1489     }
1490     return TELEPHONY_SUCCESS;
1491 }
1492 
RemoveMissedIncomingCallNotification()1493 int32_t CallManagerProxy::RemoveMissedIncomingCallNotification()
1494 {
1495     if (ReConnectService() != TELEPHONY_SUCCESS) {
1496         TELEPHONY_LOGE("ipc reconnect failed!");
1497         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1498     }
1499     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1500     if (callManagerServicePtr_ == nullptr) {
1501         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1502         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1503     }
1504     int32_t errCode = callManagerServicePtr_->RemoveMissedIncomingCallNotification();
1505     if (errCode != TELEPHONY_SUCCESS) {
1506         TELEPHONY_LOGE("RemoveMissedIncomingCallNotification failed, errcode:%{public}d", errCode);
1507         return errCode;
1508     }
1509     return TELEPHONY_SUCCESS;
1510 }
1511 
SetVoIPCallState(int32_t state)1512 int32_t CallManagerProxy::SetVoIPCallState(int32_t state)
1513 {
1514     if (ReConnectService() != TELEPHONY_SUCCESS) {
1515         TELEPHONY_LOGE("ipc reconnect failed!");
1516         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1517     }
1518     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1519     if (callManagerServicePtr_ == nullptr) {
1520         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1521         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1522     }
1523     int32_t errCode = callManagerServicePtr_->SetVoIPCallState(state);
1524     if (errCode != TELEPHONY_SUCCESS) {
1525         TELEPHONY_LOGE("failed, errcode:%{public}d", errCode);
1526         return errCode;
1527     }
1528     return TELEPHONY_SUCCESS;
1529 }
1530 
GetVoIPCallState(int32_t & state)1531 int32_t CallManagerProxy::GetVoIPCallState(int32_t &state)
1532 {
1533     if (ReConnectService() != TELEPHONY_SUCCESS) {
1534         TELEPHONY_LOGE("ipc reconnect failed!");
1535         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1536     }
1537     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1538     if (callManagerServicePtr_ == nullptr) {
1539         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1540         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1541     }
1542     int32_t errCode = callManagerServicePtr_->GetVoIPCallState(state);
1543     if (errCode != TELEPHONY_SUCCESS) {
1544         TELEPHONY_LOGE("failed, errcode:%{public}d", errCode);
1545         return errCode;
1546     }
1547     return TELEPHONY_SUCCESS;
1548 }
1549 
GetProxyObjectPtr(CallManagerProxyType proxyType)1550 sptr<IRemoteObject> CallManagerProxy::GetProxyObjectPtr(CallManagerProxyType proxyType)
1551 {
1552     if (ReConnectService() != TELEPHONY_SUCCESS) {
1553         TELEPHONY_LOGE("ipc reconnect failed!");
1554         return nullptr;
1555     }
1556     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1557     if (callManagerServicePtr_ == nullptr) {
1558         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1559         return nullptr;
1560     }
1561     sptr<IRemoteObject> ptr = callManagerServicePtr_->GetProxyObjectPtr(proxyType);
1562     if (ptr == nullptr) {
1563         TELEPHONY_LOGE("GetProxyObjectPtr failed");
1564         return nullptr;
1565     }
1566     return ptr;
1567 }
1568 
OnRemoteDied(const wptr<IRemoteObject> & remote)1569 void CallManagerProxy::OnRemoteDied(const wptr<IRemoteObject> &remote)
1570 {
1571     if (remote == nullptr) {
1572         TELEPHONY_LOGE("OnRemoteDied failed, remote is nullptr");
1573         return;
1574     }
1575     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
1576     if (callManagerServicePtr_ == nullptr) {
1577         TELEPHONY_LOGE("OnRemoteDied failed, callManagerServicePtr_ is nullptr");
1578         return;
1579     }
1580     auto serviceRemote = callManagerServicePtr_->AsObject();
1581     if (serviceRemote != nullptr && serviceRemote == remote.promote()) {
1582         serviceRemote->RemoveDeathRecipient(deathRecipient_);
1583         callManagerServicePtr_ = nullptr;
1584         initStatus_ = false;
1585         TELEPHONY_LOGE("on remote died");
1586     }
1587 }
1588 
ReportAudioDeviceInfo()1589 int32_t CallManagerProxy::ReportAudioDeviceInfo()
1590 {
1591     if (ReConnectService() != TELEPHONY_SUCCESS) {
1592         TELEPHONY_LOGE("ipc reconnect failed!");
1593         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1594     }
1595     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1596     if (callManagerServicePtr_ == nullptr) {
1597         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1598         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1599     }
1600     int32_t errCode = callManagerServicePtr_->ReportAudioDeviceInfo();
1601     if (errCode != TELEPHONY_SUCCESS) {
1602         TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1603         return errCode;
1604     }
1605     return TELEPHONY_SUCCESS;
1606 }
1607 
CancelCallUpgrade(int32_t callId)1608 int32_t CallManagerProxy::CancelCallUpgrade(int32_t callId)
1609 {
1610     if (ReConnectService() != TELEPHONY_SUCCESS) {
1611         TELEPHONY_LOGE("ipc reconnect failed!");
1612         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1613     }
1614     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1615     if (callManagerServicePtr_ == nullptr) {
1616         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1617         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1618     }
1619     int32_t errCode = callManagerServicePtr_->CancelCallUpgrade(callId);
1620     if (errCode != TELEPHONY_SUCCESS) {
1621         TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1622         return errCode;
1623     }
1624     return TELEPHONY_SUCCESS;
1625 }
1626 
RequestCameraCapabilities(int32_t callId)1627 int32_t CallManagerProxy::RequestCameraCapabilities(int32_t callId)
1628 {
1629     if (ReConnectService() != TELEPHONY_SUCCESS) {
1630         TELEPHONY_LOGE("ipc reconnect failed!");
1631         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1632     }
1633     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1634     if (callManagerServicePtr_ == nullptr) {
1635         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1636         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1637     }
1638     int32_t errCode = callManagerServicePtr_->RequestCameraCapabilities(callId);
1639     if (errCode != TELEPHONY_SUCCESS) {
1640         TELEPHONY_LOGE("ReportAudioDeviceInfo failed, errcode:%{public}d", errCode);
1641         return errCode;
1642     }
1643     return TELEPHONY_SUCCESS;
1644 }
1645 
SendCallUiEvent(int32_t callId,std::string & eventName)1646 int32_t CallManagerProxy::SendCallUiEvent(int32_t callId, std::string &eventName)
1647 {
1648     if (ReConnectService() != TELEPHONY_SUCCESS) {
1649         TELEPHONY_LOGE("ipc reconnect failed!");
1650         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
1651     }
1652     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
1653     if (callManagerServicePtr_ == nullptr) {
1654         TELEPHONY_LOGE("callManagerServicePtr_ is null");
1655         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1656     }
1657     int32_t errCode = callManagerServicePtr_->SendCallUiEvent(callId, eventName);
1658     if (errCode != TELEPHONY_SUCCESS) {
1659         TELEPHONY_LOGE("SendCallUiEvent failed, errcode:%{public}d", errCode);
1660         return errCode;
1661     }
1662     return TELEPHONY_SUCCESS;
1663 }
1664 } // namespace Telephony
1665 } // namespace OHOS
1666