1 /*
2  * Copyright (C) 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 "ims_call_client.h"
17 
18 #include "cellular_call_hisysevent.h"
19 #include "ims_call_callback_stub.h"
20 #include "iservice_registry.h"
21 #include "system_ability_definition.h"
22 #include "telephony_errors.h"
23 #include "telephony_log_wrapper.h"
24 
25 namespace OHOS {
26 namespace Telephony {
27 ImsCallClient::ImsCallClient() = default;
28 
~ImsCallClient()29 ImsCallClient::~ImsCallClient()
30 {
31     UnInit();
32 }
33 
Init()34 void ImsCallClient::Init()
35 {
36     TELEPHONY_LOGI("Init start");
37     if (IsConnect()) {
38         TELEPHONY_LOGE("Init, IsConnect return true");
39         return;
40     }
41 
42     GetImsCallProxy();
43     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
44     if (imsCallProxy_ == nullptr) {
45         TELEPHONY_LOGE("Init, get ims call proxy failed!");
46     }
47 
48     statusChangeListener_ = new (std::nothrow) SystemAbilityListener();
49     if (statusChangeListener_ == nullptr) {
50         TELEPHONY_LOGE("Init, failed to create statusChangeListener.");
51         return;
52     }
53     auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
54     if (managerPtr == nullptr) {
55         TELEPHONY_LOGE("Init, get system ability manager error.");
56         return;
57     }
58     int32_t ret = managerPtr->SubscribeSystemAbility(TELEPHONY_IMS_SYS_ABILITY_ID, statusChangeListener_);
59     if (ret) {
60         TELEPHONY_LOGE("Init, failed to subscribe sa:%{public}d", TELEPHONY_IMS_SYS_ABILITY_ID);
61         return;
62     }
63     TELEPHONY_LOGI("Init successfully");
64 }
65 
UnInit()66 void ImsCallClient::UnInit()
67 {
68     Clean();
69     if (statusChangeListener_ != nullptr) {
70         statusChangeListener_.clear();
71         statusChangeListener_ = nullptr;
72     }
73     std::lock_guard<std::mutex> lock(mutexMap_);
74     handlerMap_.clear();
75 }
76 
GetImsCallProxy()77 sptr<ImsCallInterface> ImsCallClient::GetImsCallProxy()
78 {
79     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
80     if (imsCallProxy_ != nullptr) {
81         return imsCallProxy_;
82     }
83     auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
84     if (managerPtr == nullptr) {
85         TELEPHONY_LOGE("GetImsCallProxy return, get system ability manager error.");
86         return nullptr;
87     }
88     auto remoteObjectPtr = managerPtr->CheckSystemAbility(TELEPHONY_IMS_SYS_ABILITY_ID);
89     if (remoteObjectPtr == nullptr) {
90         TELEPHONY_LOGE("GetImsCallProxy return, remote service not exists.");
91         return nullptr;
92     }
93     imsCoreServiceProxy_ = iface_cast<ImsCoreServiceInterface>(remoteObjectPtr);
94     if (imsCoreServiceProxy_ == nullptr) {
95         TELEPHONY_LOGE("GetImsCallProxy return, imsCoreServiceProxy_ is nullptr.");
96         return nullptr;
97     }
98     sptr<IRemoteObject> imsCallRemoteObjectPtr = imsCoreServiceProxy_->GetProxyObjectPtr(PROXY_IMS_CALL);
99     if (imsCallRemoteObjectPtr == nullptr) {
100         TELEPHONY_LOGE("GetImsCallProxy return, ImsCallRemoteObjectPtr is nullptr.");
101         return nullptr;
102     }
103 
104     imsCallProxy_ = iface_cast<ImsCallInterface>(imsCallRemoteObjectPtr);
105     if (imsCallProxy_ == nullptr) {
106         TELEPHONY_LOGE("GetImsCallProxy return, iface_cast<imsCallProxy_> failed!");
107         return nullptr;
108     }
109     // register callback
110     RegisterImsCallCallback();
111     TELEPHONY_LOGI("GetImsCallProxy success.");
112     return imsCallProxy_;
113 }
114 
IsConnect()115 bool ImsCallClient::IsConnect()
116 {
117     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
118     return (imsCallProxy_ != nullptr);
119 }
120 
RegisterImsCallCallback()121 int32_t ImsCallClient::RegisterImsCallCallback()
122 {
123     if (imsCallProxy_ == nullptr) {
124         TELEPHONY_LOGE("imsCallProxy_ is null!");
125         return TELEPHONY_ERR_LOCAL_PTR_NULL;
126     }
127     imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release();
128     if (imsCallCallback_ == nullptr) {
129         TELEPHONY_LOGE("RegisterImsCallCallback return, make unique error.");
130         return TELEPHONY_ERR_LOCAL_PTR_NULL;
131     }
132     int32_t ret = imsCallProxy_->RegisterImsCallCallback(imsCallCallback_);
133     if (ret) {
134         TELEPHONY_LOGE("RegisterImsCallCallback return, register callback error.");
135         return TELEPHONY_ERR_FAIL;
136     }
137     TELEPHONY_LOGI("RegisterImsCallCallback success.");
138     return TELEPHONY_SUCCESS;
139 }
140 
RegisterImsCallCallbackHandler(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)141 int32_t ImsCallClient::RegisterImsCallCallbackHandler(
142     int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
143 {
144     if (handler == nullptr) {
145         TELEPHONY_LOGE("RegisterImsCallCallbackHandler return, handler is null.");
146         return TELEPHONY_ERR_LOCAL_PTR_NULL;
147     }
148 
149     std::lock_guard<std::mutex> lock(mutexMap_);
150     handlerMap_.insert(std::make_pair(slotId, handler));
151     TELEPHONY_LOGI("RegisterImsCallCallbackHandler success.");
152     return TELEPHONY_SUCCESS;
153 }
154 
GetHandler(int32_t slotId)155 std::shared_ptr<AppExecFwk::EventHandler> ImsCallClient::GetHandler(int32_t slotId)
156 {
157     std::lock_guard<std::mutex> lock(mutexMap_);
158     return handlerMap_[slotId];
159 }
160 
Dial(const ImsCallInfo & callInfo,CLIRMode mode)161 int32_t ImsCallClient::Dial(const ImsCallInfo &callInfo, CLIRMode mode)
162 {
163     if (ReConnectService() != TELEPHONY_SUCCESS) {
164         TELEPHONY_LOGE("ipc reconnect failed!");
165         CellularCallHiSysEvent::WriteDialCallFaultEvent(callInfo.slotId, INVALID_PARAMETER, callInfo.videoState,
166             TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL, "ipc reconnect failed");
167         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
168     }
169     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
170     return imsCallProxy_->Dial(callInfo, mode);
171 }
172 
HangUp(const ImsCallInfo & callInfo)173 int32_t ImsCallClient::HangUp(const ImsCallInfo &callInfo)
174 {
175     if (ReConnectService() != TELEPHONY_SUCCESS) {
176         TELEPHONY_LOGE("ipc reconnect failed!");
177         CellularCallHiSysEvent::WriteHangUpFaultEvent(
178             callInfo.slotId, INVALID_PARAMETER, TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL, "HangUp ims ipc reconnect failed");
179         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
180     }
181     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
182     return imsCallProxy_->HangUp(callInfo);
183 }
184 
Reject(const ImsCallInfo & callInfo)185 int32_t ImsCallClient::Reject(const ImsCallInfo &callInfo)
186 {
187     if (ReConnectService() != TELEPHONY_SUCCESS) {
188         TELEPHONY_LOGE("ipc reconnect failed!");
189         CellularCallHiSysEvent::WriteHangUpFaultEvent(
190             callInfo.slotId, INVALID_PARAMETER, TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL, "Reject ims ipc reconnect failed");
191         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
192     }
193     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
194     return imsCallProxy_->RejectWithReason(callInfo, ImsRejectReason::USER_DECLINE);
195 }
196 
RejectWithReason(const ImsCallInfo & callInfo,const ImsRejectReason & reason)197 int32_t ImsCallClient::RejectWithReason(const ImsCallInfo &callInfo, const ImsRejectReason &reason)
198 {
199     if (ReConnectService() != TELEPHONY_SUCCESS) {
200         TELEPHONY_LOGE("ipc reconnect failed!");
201         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
202     }
203     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
204     return imsCallProxy_->RejectWithReason(callInfo, reason);
205 }
206 
Answer(const ImsCallInfo & callInfo)207 int32_t ImsCallClient::Answer(const ImsCallInfo &callInfo)
208 {
209     if (ReConnectService() != TELEPHONY_SUCCESS) {
210         TELEPHONY_LOGE("ipc reconnect failed!");
211         CellularCallHiSysEvent::WriteAnswerCallFaultEvent(callInfo.slotId, INVALID_PARAMETER, callInfo.videoState,
212             TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL, "answer ims ipc reconnect failed");
213         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
214     }
215     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
216     return imsCallProxy_->Answer(callInfo);
217 }
218 
HoldCall(int32_t slotId,int32_t callType)219 int32_t ImsCallClient::HoldCall(int32_t slotId, int32_t callType)
220 {
221     if (ReConnectService() != TELEPHONY_SUCCESS) {
222         TELEPHONY_LOGE("ipc reconnect failed!");
223         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
224     }
225     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
226     return imsCallProxy_->HoldCall(slotId, callType);
227 }
228 
UnHoldCall(int32_t slotId,int32_t callType)229 int32_t ImsCallClient::UnHoldCall(int32_t slotId, int32_t callType)
230 {
231     if (ReConnectService() != TELEPHONY_SUCCESS) {
232         TELEPHONY_LOGE("ipc reconnect failed!");
233         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
234     }
235     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
236     return imsCallProxy_->UnHoldCall(slotId, callType);
237 }
238 
SwitchCall(int32_t slotId,int32_t callType)239 int32_t ImsCallClient::SwitchCall(int32_t slotId, int32_t callType)
240 {
241     if (ReConnectService() != TELEPHONY_SUCCESS) {
242         TELEPHONY_LOGE("ipc reconnect failed!");
243         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
244     }
245     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
246     return imsCallProxy_->SwitchCall(slotId, callType);
247 }
248 
CombineConference(int32_t slotId)249 int32_t ImsCallClient::CombineConference(int32_t slotId)
250 {
251     if (ReConnectService() != TELEPHONY_SUCCESS) {
252         TELEPHONY_LOGE("ipc reconnect failed!");
253         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
254     }
255     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
256     return imsCallProxy_->CombineConference(slotId);
257 }
258 
InviteToConference(int32_t slotId,const std::vector<std::string> & numberList)259 int32_t ImsCallClient::InviteToConference(int32_t slotId, const std::vector<std::string> &numberList)
260 {
261     if (ReConnectService() != TELEPHONY_SUCCESS) {
262         TELEPHONY_LOGE("ipc reconnect failed!");
263         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
264     }
265     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
266     return imsCallProxy_->InviteToConference(slotId, numberList);
267 }
268 
KickOutFromConference(int32_t slotId,int32_t index)269 int32_t ImsCallClient::KickOutFromConference(int32_t slotId, int32_t index)
270 {
271     if (ReConnectService() != TELEPHONY_SUCCESS) {
272         TELEPHONY_LOGE("ipc reconnect failed!");
273         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
274     }
275     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
276     return imsCallProxy_->KickOutFromConference(slotId, index);
277 }
278 
SendUpdateCallMediaModeRequest(const ImsCallInfo & callInfo,ImsCallType callType)279 int32_t ImsCallClient::SendUpdateCallMediaModeRequest(const ImsCallInfo &callInfo, ImsCallType callType)
280 {
281     if (ReConnectService() != TELEPHONY_SUCCESS) {
282         TELEPHONY_LOGE("ipc reconnect failed!");
283         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
284     }
285     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
286     return imsCallProxy_->SendUpdateCallMediaModeRequest(callInfo, callType);
287 }
288 
SendUpdateCallMediaModeResponse(const ImsCallInfo & callInfo,ImsCallType callType)289 int32_t ImsCallClient::SendUpdateCallMediaModeResponse(const ImsCallInfo &callInfo, ImsCallType callType)
290 {
291     if (ReConnectService() != TELEPHONY_SUCCESS) {
292         TELEPHONY_LOGE("ipc reconnect failed!");
293         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
294     }
295     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
296     return imsCallProxy_->SendUpdateCallMediaModeResponse(callInfo, callType);
297 }
298 
CancelCallUpgrade(int32_t slotId,int32_t callIndex)299 int32_t ImsCallClient::CancelCallUpgrade(int32_t slotId, int32_t callIndex)
300 {
301     if (ReConnectService() != TELEPHONY_SUCCESS) {
302         TELEPHONY_LOGE("ipc reconnect failed!");
303         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
304     }
305     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
306     return imsCallProxy_->CancelCallUpgrade(slotId, callIndex);
307 }
308 
RequestCameraCapabilities(int32_t slotId,int32_t callIndex)309 int32_t ImsCallClient::RequestCameraCapabilities(int32_t slotId, int32_t callIndex)
310 {
311     if (ReConnectService() != TELEPHONY_SUCCESS) {
312         TELEPHONY_LOGE("ipc reconnect failed!");
313         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
314     }
315     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
316     return imsCallProxy_->RequestCameraCapabilities(slotId, callIndex);
317 }
318 
GetImsCallsDataRequest(int32_t slotId,int64_t lastCallsDataFlag)319 int32_t ImsCallClient::GetImsCallsDataRequest(int32_t slotId, int64_t lastCallsDataFlag)
320 {
321     if (ReConnectService() != TELEPHONY_SUCCESS) {
322         TELEPHONY_LOGE("ipc reconnect failed!");
323         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
324     }
325     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
326     return imsCallProxy_->GetImsCallsDataRequest(slotId, lastCallsDataFlag);
327 }
328 
GetLastCallFailReason(int32_t slotId)329 int32_t ImsCallClient::GetLastCallFailReason(int32_t slotId)
330 {
331     if (ReConnectService() != TELEPHONY_SUCCESS) {
332         TELEPHONY_LOGE("ipc reconnect failed!");
333         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
334     }
335     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
336     return imsCallProxy_->GetLastCallFailReason(slotId);
337 }
338 
StartDtmf(int32_t slotId,char cDtmfCode,int32_t index)339 int32_t ImsCallClient::StartDtmf(int32_t slotId, char cDtmfCode, int32_t index)
340 {
341     if (ReConnectService() != TELEPHONY_SUCCESS) {
342         TELEPHONY_LOGE("ipc reconnect failed!");
343         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
344     }
345     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
346     return imsCallProxy_->StartDtmf(slotId, cDtmfCode, index);
347 }
348 
SendDtmf(int32_t slotId,char cDtmfCode,int32_t index)349 int32_t ImsCallClient::SendDtmf(int32_t slotId, char cDtmfCode, int32_t index)
350 {
351     if (ReConnectService() != TELEPHONY_SUCCESS) {
352         TELEPHONY_LOGE("ipc reconnect failed!");
353         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
354     }
355     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
356     return imsCallProxy_->SendDtmf(slotId, cDtmfCode, index);
357 }
358 
StopDtmf(int32_t slotId,int32_t index)359 int32_t ImsCallClient::StopDtmf(int32_t slotId, int32_t index)
360 {
361     if (ReConnectService() != TELEPHONY_SUCCESS) {
362         TELEPHONY_LOGE("ipc reconnect failed!");
363         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
364     }
365     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
366     return imsCallProxy_->StopDtmf(slotId, index);
367 }
368 
StartRtt(int32_t slotId,const std::string & msg)369 int32_t ImsCallClient::StartRtt(int32_t slotId, const std::string &msg)
370 {
371     if (ReConnectService() != TELEPHONY_SUCCESS) {
372         TELEPHONY_LOGE("ipc reconnect failed!");
373         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
374     }
375     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
376     return imsCallProxy_->StartRtt(slotId, msg);
377 }
378 
StopRtt(int32_t slotId)379 int32_t ImsCallClient::StopRtt(int32_t slotId)
380 {
381     if (ReConnectService() != TELEPHONY_SUCCESS) {
382         TELEPHONY_LOGE("ipc reconnect failed!");
383         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
384     }
385     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
386     return imsCallProxy_->StopRtt(slotId);
387 }
388 
SetDomainPreferenceMode(int32_t slotId,int32_t mode)389 int32_t ImsCallClient::SetDomainPreferenceMode(int32_t slotId, int32_t mode)
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     return imsCallProxy_->SetDomainPreferenceMode(slotId, mode);
397 }
398 
GetDomainPreferenceMode(int32_t slotId)399 int32_t ImsCallClient::GetDomainPreferenceMode(int32_t slotId)
400 {
401     if (ReConnectService() != TELEPHONY_SUCCESS) {
402         TELEPHONY_LOGE("ipc reconnect failed!");
403         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
404     }
405     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
406     return imsCallProxy_->GetDomainPreferenceMode(slotId);
407 }
408 
SetImsSwitchStatus(int32_t slotId,int32_t active)409 int32_t ImsCallClient::SetImsSwitchStatus(int32_t slotId, int32_t active)
410 {
411     if (ReConnectService() != TELEPHONY_SUCCESS) {
412         TELEPHONY_LOGE("ipc reconnect failed!");
413         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
414     }
415     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
416     return imsCallProxy_->SetImsSwitchStatus(slotId, active);
417 }
418 
GetImsSwitchStatus(int32_t slotId)419 int32_t ImsCallClient::GetImsSwitchStatus(int32_t slotId)
420 {
421     if (ReConnectService() != TELEPHONY_SUCCESS) {
422         TELEPHONY_LOGE("ipc reconnect failed!");
423         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
424     }
425     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
426     return imsCallProxy_->GetImsSwitchStatus(slotId);
427 }
428 
SetImsConfig(ImsConfigItem item,const std::string & value)429 int32_t ImsCallClient::SetImsConfig(ImsConfigItem item, const std::string &value)
430 {
431     if (ReConnectService() != TELEPHONY_SUCCESS) {
432         TELEPHONY_LOGE("ipc reconnect failed!");
433         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
434     }
435     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
436     return imsCallProxy_->SetImsConfig(item, value);
437 }
438 
SetImsConfig(ImsConfigItem item,int32_t value)439 int32_t ImsCallClient::SetImsConfig(ImsConfigItem item, int32_t value)
440 {
441     if (ReConnectService() != TELEPHONY_SUCCESS) {
442         TELEPHONY_LOGE("ipc reconnect failed!");
443         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
444     }
445     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
446     return imsCallProxy_->SetImsConfig(item, value);
447 }
448 
GetImsConfig(ImsConfigItem item)449 int32_t ImsCallClient::GetImsConfig(ImsConfigItem item)
450 {
451     if (ReConnectService() != TELEPHONY_SUCCESS) {
452         TELEPHONY_LOGE("ipc reconnect failed!");
453         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
454     }
455     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
456     return imsCallProxy_->GetImsConfig(item);
457 }
458 
SetImsFeatureValue(FeatureType type,int32_t value)459 int32_t ImsCallClient::SetImsFeatureValue(FeatureType type, int32_t value)
460 {
461     if (ReConnectService() != TELEPHONY_SUCCESS) {
462         TELEPHONY_LOGE("ipc reconnect failed!");
463         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
464     }
465     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
466     return imsCallProxy_->SetImsFeatureValue(type, value);
467 }
468 
GetImsFeatureValue(FeatureType type,int32_t & value)469 int32_t ImsCallClient::GetImsFeatureValue(FeatureType type, int32_t &value)
470 {
471     if (ReConnectService() != TELEPHONY_SUCCESS) {
472         TELEPHONY_LOGE("ipc reconnect failed!");
473         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
474     }
475     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
476     return imsCallProxy_->GetImsFeatureValue(type, value);
477 }
478 
SetMute(int32_t slotId,int32_t mute)479 int32_t ImsCallClient::SetMute(int32_t slotId, int32_t mute)
480 {
481     if (ReConnectService() != TELEPHONY_SUCCESS) {
482         TELEPHONY_LOGE("ipc reconnect failed!");
483         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
484     }
485     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
486     return imsCallProxy_->SetMute(slotId, mute);
487 }
488 
GetMute(int32_t slotId)489 int32_t ImsCallClient::GetMute(int32_t slotId)
490 {
491     if (ReConnectService() != TELEPHONY_SUCCESS) {
492         TELEPHONY_LOGE("ipc reconnect failed!");
493         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
494     }
495     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
496     return imsCallProxy_->GetMute(slotId);
497 }
498 
ControlCamera(int32_t slotId,int32_t callIndex,const std::string & cameraId)499 int32_t ImsCallClient::ControlCamera(int32_t slotId, int32_t callIndex, const std::string &cameraId)
500 {
501     if (ReConnectService() != TELEPHONY_SUCCESS) {
502         TELEPHONY_LOGE("ipc reconnect failed!");
503         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
504     }
505     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
506     return imsCallProxy_->ControlCamera(slotId, callIndex, cameraId);
507 }
508 
SetPreviewWindow(int32_t slotId,int32_t callIndex,const std::string & surfaceID,sptr<Surface> surface)509 int32_t ImsCallClient::SetPreviewWindow(
510     int32_t slotId, int32_t callIndex, const std::string &surfaceID, sptr<Surface> surface)
511 {
512     if (ReConnectService() != TELEPHONY_SUCCESS) {
513         TELEPHONY_LOGE("ipc reconnect failed!");
514         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
515     }
516     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
517     return imsCallProxy_->SetPreviewWindow(slotId, callIndex, surfaceID, surface);
518 }
519 
SetDisplayWindow(int32_t slotId,int32_t callIndex,const std::string & surfaceID,sptr<Surface> surface)520 int32_t ImsCallClient::SetDisplayWindow(
521     int32_t slotId, int32_t callIndex, const std::string &surfaceID, sptr<Surface> surface)
522 {
523     if (ReConnectService() != TELEPHONY_SUCCESS) {
524         TELEPHONY_LOGE("ipc reconnect failed!");
525         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
526     }
527     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
528     return imsCallProxy_->SetDisplayWindow(slotId, callIndex, surfaceID, surface);
529 }
530 
SetCameraZoom(float zoomRatio)531 int32_t ImsCallClient::SetCameraZoom(float zoomRatio)
532 {
533     if (ReConnectService() != TELEPHONY_SUCCESS) {
534         TELEPHONY_LOGE("ipc reconnect failed!");
535         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
536     }
537     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
538     return imsCallProxy_->SetCameraZoom(zoomRatio);
539 }
540 
SetPausePicture(int32_t slotId,int32_t callIndex,const std::string & path)541 int32_t ImsCallClient::SetPausePicture(int32_t slotId, int32_t callIndex, const std::string &path)
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     return imsCallProxy_->SetPausePicture(slotId, callIndex, path);
549 }
550 
SetDeviceDirection(int32_t slotId,int32_t callIndex,int32_t rotation)551 int32_t ImsCallClient::SetDeviceDirection(int32_t slotId, int32_t callIndex, int32_t rotation)
552 {
553     if (ReConnectService() != TELEPHONY_SUCCESS) {
554         TELEPHONY_LOGE("ipc reconnect failed!");
555         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
556     }
557     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
558     return imsCallProxy_->SetDeviceDirection(slotId, callIndex, rotation);
559 }
560 
SetClip(int32_t slotId,int32_t action,int32_t index)561 int32_t ImsCallClient::SetClip(int32_t slotId, int32_t action, int32_t index)
562 {
563     if (ReConnectService() != TELEPHONY_SUCCESS) {
564         TELEPHONY_LOGE("ipc reconnect failed!");
565         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
566     }
567     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
568     return imsCallProxy_->SetClip(slotId, action, index);
569 }
570 
GetClip(int32_t slotId,int32_t index)571 int32_t ImsCallClient::GetClip(int32_t slotId, int32_t index)
572 {
573     if (ReConnectService() != TELEPHONY_SUCCESS) {
574         TELEPHONY_LOGE("ipc reconnect failed!");
575         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
576     }
577     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
578     return imsCallProxy_->GetClip(slotId, index);
579 }
580 
SetClir(int32_t slotId,int32_t action,int32_t index)581 int32_t ImsCallClient::SetClir(int32_t slotId, int32_t action, int32_t index)
582 {
583     if (ReConnectService() != TELEPHONY_SUCCESS) {
584         TELEPHONY_LOGE("ipc reconnect failed!");
585         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
586     }
587     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
588     return imsCallProxy_->SetClir(slotId, action, index);
589 }
590 
GetClir(int32_t slotId,int32_t index)591 int32_t ImsCallClient::GetClir(int32_t slotId, int32_t index)
592 {
593     if (ReConnectService() != TELEPHONY_SUCCESS) {
594         TELEPHONY_LOGE("ipc reconnect failed!");
595         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
596     }
597     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
598     return imsCallProxy_->GetClir(slotId, index);
599 }
600 
SetCallTransfer(int32_t slotId,const CallTransferInfo & cfInfo,int32_t classType,int32_t index)601 int32_t ImsCallClient::SetCallTransfer(int32_t slotId, const CallTransferInfo &cfInfo, int32_t classType, int32_t index)
602 {
603     if (ReConnectService() != TELEPHONY_SUCCESS) {
604         TELEPHONY_LOGE("ipc reconnect failed!");
605         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
606     }
607     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
608     return imsCallProxy_->SetCallTransfer(slotId, cfInfo, classType, index);
609 }
610 
CanSetCallTransferTime(int32_t slotId,bool & result)611 int32_t ImsCallClient::CanSetCallTransferTime(int32_t slotId, bool &result)
612 {
613     if (ReConnectService() != TELEPHONY_SUCCESS) {
614         TELEPHONY_LOGE("[slot%{public}d] ipc reconnect failed!", slotId);
615         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
616     }
617     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
618     return imsCallProxy_->CanSetCallTransferTime(slotId, result);
619 }
620 
GetCallTransfer(int32_t slotId,int32_t reason,int32_t index)621 int32_t ImsCallClient::GetCallTransfer(int32_t slotId, int32_t reason, int32_t index)
622 {
623     if (ReConnectService() != TELEPHONY_SUCCESS) {
624         TELEPHONY_LOGE("ipc reconnect failed!");
625         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
626     }
627     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
628     return imsCallProxy_->GetCallTransfer(slotId, reason, index);
629 }
630 
SetCallRestriction(int32_t slotId,const std::string & fac,int32_t mode,const std::string & pw,int32_t index)631 int32_t ImsCallClient::SetCallRestriction(
632     int32_t slotId, const std::string &fac, int32_t mode, const std::string &pw, int32_t index)
633 {
634     if (ReConnectService() != TELEPHONY_SUCCESS) {
635         TELEPHONY_LOGE("ipc reconnect failed!");
636         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
637     }
638     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
639     return imsCallProxy_->SetCallRestriction(slotId, fac, mode, pw, index);
640 }
641 
GetCallRestriction(int32_t slotId,const std::string & fac,int32_t index)642 int32_t ImsCallClient::GetCallRestriction(int32_t slotId, const std::string &fac, int32_t index)
643 {
644     if (ReConnectService() != TELEPHONY_SUCCESS) {
645         TELEPHONY_LOGE("ipc reconnect failed!");
646         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
647     }
648     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
649     return imsCallProxy_->GetCallRestriction(slotId, fac, index);
650 }
651 
SetCallWaiting(int32_t slotId,bool activate,int32_t classType,int32_t index)652 int32_t ImsCallClient::SetCallWaiting(int32_t slotId, bool activate, int32_t classType, int32_t index)
653 {
654     if (ReConnectService() != TELEPHONY_SUCCESS) {
655         TELEPHONY_LOGE("ipc reconnect failed!");
656         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
657     }
658     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
659     return imsCallProxy_->SetCallWaiting(slotId, activate, classType, index);
660 }
661 
GetCallWaiting(int32_t slotId,int32_t index)662 int32_t ImsCallClient::GetCallWaiting(int32_t slotId, int32_t index)
663 {
664     if (ReConnectService() != TELEPHONY_SUCCESS) {
665         TELEPHONY_LOGE("ipc reconnect failed!");
666         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
667     }
668     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
669     return imsCallProxy_->GetCallWaiting(slotId, index);
670 }
671 
SetColr(int32_t slotId,int32_t presentation,int32_t index)672 int32_t ImsCallClient::SetColr(int32_t slotId, int32_t presentation, int32_t index)
673 {
674     if (ReConnectService() != TELEPHONY_SUCCESS) {
675         TELEPHONY_LOGE("ipc reconnect failed!");
676         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
677     }
678     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
679     return imsCallProxy_->SetColr(slotId, presentation, index);
680 }
681 
GetColr(int32_t slotId,int32_t index)682 int32_t ImsCallClient::GetColr(int32_t slotId, int32_t index)
683 {
684     if (ReConnectService() != TELEPHONY_SUCCESS) {
685         TELEPHONY_LOGE("ipc reconnect failed!");
686         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
687     }
688     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
689     return imsCallProxy_->GetColr(slotId, index);
690 }
691 
SetColp(int32_t slotId,int32_t action,int32_t index)692 int32_t ImsCallClient::SetColp(int32_t slotId, int32_t action, int32_t index)
693 {
694     if (ReConnectService() != TELEPHONY_SUCCESS) {
695         TELEPHONY_LOGE("ipc reconnect failed!");
696         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
697     }
698     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
699     return imsCallProxy_->SetColp(slotId, action, index);
700 }
701 
GetColp(int32_t slotId,int32_t index)702 int32_t ImsCallClient::GetColp(int32_t slotId, int32_t index)
703 {
704     if (ReConnectService() != TELEPHONY_SUCCESS) {
705         TELEPHONY_LOGE("ipc reconnect failed!");
706         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
707     }
708     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
709     return imsCallProxy_->GetColp(slotId, index);
710 }
711 
ReConnectService()712 int32_t ImsCallClient::ReConnectService()
713 {
714     if (imsCallProxy_ == nullptr) {
715         TELEPHONY_LOGI("try to reconnect ims call service now...");
716         GetImsCallProxy();
717         if (imsCallProxy_ == nullptr) {
718             TELEPHONY_LOGE("Connect service failed");
719             return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
720         }
721     }
722     return TELEPHONY_SUCCESS;
723 }
724 
Clean()725 void ImsCallClient::Clean()
726 {
727     Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
728     if (imsCoreServiceProxy_ != nullptr) {
729         imsCoreServiceProxy_.clear();
730         imsCoreServiceProxy_ = nullptr;
731     }
732     if (imsCallProxy_ != nullptr) {
733         imsCallProxy_.clear();
734         imsCallProxy_ = nullptr;
735     }
736     if (imsCallCallback_ != nullptr) {
737         imsCallCallback_.clear();
738         imsCallCallback_ = nullptr;
739     }
740 }
741 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)742 void ImsCallClient::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId,
743     const std::string& deviceId)
744 {
745     TELEPHONY_LOGI("SA:%{public}d is added!", systemAbilityId);
746     if (!CheckInputSysAbilityId(systemAbilityId)) {
747         TELEPHONY_LOGE("add SA:%{public}d is invalid!", systemAbilityId);
748         return;
749     }
750 
751     auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
752     if (imsCallClient->IsConnect()) {
753         TELEPHONY_LOGE("SA:%{public}d already connected!", systemAbilityId);
754         return;
755     }
756 
757     imsCallClient->Clean();
758     int32_t res = imsCallClient->ReConnectService();
759     if (res != TELEPHONY_SUCCESS) {
760         TELEPHONY_LOGE("SA:%{public}d reconnect service failed!", systemAbilityId);
761         return;
762     }
763     TELEPHONY_LOGI("SA:%{public}d reconnect service successfully!", systemAbilityId);
764 }
765 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)766 void ImsCallClient::SystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId,
767     const std::string& deviceId)
768 {
769     TELEPHONY_LOGI("SA:%{public}d is removed!", systemAbilityId);
770     auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
771     if (!imsCallClient->IsConnect()) {
772         return;
773     }
774 
775     imsCallClient->Clean();
776 }
777 
UpdateImsCapabilities(int32_t slotId,const ImsCapabilityList & imsCapabilityList)778 int32_t ImsCallClient::UpdateImsCapabilities(int32_t slotId, const ImsCapabilityList &imsCapabilityList)
779 {
780     if (ReConnectService() != TELEPHONY_SUCCESS) {
781         TELEPHONY_LOGE("ipc reconnect failed!");
782         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
783     }
784     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
785     return imsCallProxy_->UpdateImsCapabilities(slotId, imsCapabilityList);
786 }
787 
GetUtImpuFromNetwork(int32_t slotId,std::string & impu)788 int32_t ImsCallClient::GetUtImpuFromNetwork(int32_t slotId, std::string &impu)
789 {
790     if (ReConnectService() != TELEPHONY_SUCCESS) {
791         TELEPHONY_LOGE("[slot%{public}d]ipc reconnect failed!", slotId);
792         return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
793     }
794     Utils::UniqueReadGuard<Utils::RWLock> guard(rwClientLock_);
795     return imsCallProxy_->GetUtImpuFromNetwork(slotId, impu);
796 }
797 } // namespace Telephony
798 } // namespace OHOS
799