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