1 /*
2 * Copyright (C) 2021-2023 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_service.h"
17
18 #include "accesstoken_kit.h"
19 #include "audio_device_manager.h"
20 #include "audio_proxy.h"
21 #include "bluetooth_call_service.h"
22 #include "call_ability_report_proxy.h"
23 #include "call_manager_dump_helper.h"
24 #include "call_manager_errors.h"
25 #include "call_manager_hisysevent.h"
26 #include "call_records_manager.h"
27 #include "cellular_call_connection.h"
28 #include "common_type.h"
29 #include "core_manager_inner.h"
30 #include "hitrace_meter.h"
31 #include "ipc_skeleton.h"
32 #include "privacy_kit.h"
33 #include "report_call_info_handler.h"
34 #include "telephony_log_wrapper.h"
35 #include "telephony_permission.h"
36 #include "video_control_manager.h"
37 #include "voip_call_connection.h"
38 #include "distributed_call_manager.h"
39 #include "call_earthquake_alarm_subscriber.h"
40 #include "distributed_communication_manager.h"
41 #include "want_params_wrapper.h"
42 #include "string_wrapper.h"
43 #include "call_wired_headset.h"
44 #include "bluetooth_call_connection.h"
45 #include "interoperable_communication_manager.h"
46
47 #ifdef SUPPORT_MUTE_BY_DATABASE
48 #include "interoperable_settings_handler.h"
49 #endif
50
51 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_CUST
52 #include "telephony_cust_wrapper.h"
53 #endif
54
55 namespace OHOS {
56 namespace Telephony {
57 using namespace Security::AccessToken;
58 static constexpr const char *OHOS_PERMISSION_SET_TELEPHONY_STATE = "ohos.permission.SET_TELEPHONY_STATE";
59 static constexpr const char *OHOS_PERMISSION_GET_TELEPHONY_STATE = "ohos.permission.GET_TELEPHONY_STATE";
60 static constexpr const char *OHOS_PERMISSION_PLACE_CALL = "ohos.permission.PLACE_CALL";
61 static constexpr const char *OHOS_PERMISSION_ANSWER_CALL = "ohos.permission.ANSWER_CALL";
62 static constexpr const char *OHOS_PERMISSION_READ_CALL_LOG = "ohos.permission.READ_CALL_LOG";
63 static constexpr const char *OHOS_PERMISSION_WRITE_CALL_LOG = "ohos.permission.WRITE_CALL_LOG";
64 static constexpr const char *SLOT_ID = "accountId";
65 static constexpr const char *CALL_TYPE = "callType";
66 static constexpr const char *VIDEO_STATE = "videoState";
67 static constexpr int32_t CLEAR_VOICE_MAIL_COUNT = 0;
68 static constexpr int32_t IS_CELIA_CALL = 1;
69
70 const bool g_registerResult =
71 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<CallManagerService>::GetInstance().get());
72
CallManagerService()73 CallManagerService::CallManagerService()
74 : SystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID, true), callControlManagerPtr_(nullptr)
75 {}
76
~CallManagerService()77 CallManagerService::~CallManagerService()
78 {}
79
SetCallStatusManager(std::shared_ptr<CallStatusManager> callStatusManager)80 void CallManagerService::SetCallStatusManager(std::shared_ptr<CallStatusManager> callStatusManager)
81 {
82 callStatusManagerPtr_ = callStatusManager;
83 }
84
Init()85 bool CallManagerService::Init()
86 {
87 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_CUST
88 TELEPHONY_CUST_WRAPPER.InitTelephonyCustWrapper();
89 #endif
90 if (!DelayedSingleton<CallControlManager>::GetInstance()->Init()) {
91 TELEPHONY_LOGE("CallControlManager init failed!");
92 return false;
93 }
94 callControlManagerPtr_ = DelayedSingleton<CallControlManager>::GetInstance();
95 if (callControlManagerPtr_ == nullptr) {
96 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
97 return false;
98 }
99 DelayedSingleton<ReportCallInfoHandler>::GetInstance()->Init();
100 DelayedSingleton<CellularCallConnection>::GetInstance()->Init(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
101 DelayedSingleton<CallRecordsManager>::GetInstance()->Init();
102 DelayedSingleton<BluetoothConnection>::GetInstance()->Init();
103 DelayedSingleton<DistributedCallManager>::GetInstance()->Init();
104 DelayedSingleton<DistributedCommunicationManager>::GetInstance()->Init();
105 AddSystemAbilityListener(AUDIO_POLICY_SERVICE_ID);
106 DelayedSingleton<CallWiredHeadSet>::GetInstance()->Init();
107 AddSystemAbilityListener(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
108 return true;
109 }
110
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)111 void CallManagerService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
112 {
113 TELEPHONY_LOGI("OnAddSystemAbility : %{public}d", systemAbilityId);
114 switch (systemAbilityId) {
115 case AUDIO_POLICY_SERVICE_ID:
116 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioMicStateChangeCallback();
117 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioDeviceChangeCallback();
118 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioPreferDeviceChangeCallback();
119 break;
120 case DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID:
121 DelayedSingleton<InteroperableDeviceObserver>::GetInstance()->Init();
122 break;
123 default:
124 TELEPHONY_LOGE("OnAddSystemAbility unhandle id : %{public}d", systemAbilityId);
125 break;
126 }
127 }
128
UnInit()129 void CallManagerService::UnInit()
130 {
131 DelayedSingleton<CellularCallConnection>::GetInstance()->UnInit();
132 DelayedSingleton<CallControlManager>::GetInstance()->UnInit();
133 callControlManagerPtr_ = nullptr;
134 std::lock_guard<std::mutex> guard(lock_);
135 if (bluetoothCallCallbackPtr_ != nullptr) {
136 bluetoothCallCallbackPtr_ = nullptr;
137 }
138 }
139
OnStart()140 void CallManagerService::OnStart()
141 {
142 using namespace std::chrono;
143 time_point<high_resolution_clock> beginTime = high_resolution_clock::now();
144 std::lock_guard<std::mutex> guard(lock_);
145 if (state_ == ServiceRunningState::STATE_RUNNING) {
146 return;
147 }
148
149 if (!Init()) {
150 TELEPHONY_LOGE("Leave, init failed!");
151 return;
152 }
153
154 bool ret = SystemAbility::Publish(DelayedSingleton<CallManagerService>::GetInstance().get());
155 if (!ret) {
156 TELEPHONY_LOGE("Leave, publishing CallManagerService failed!");
157 return;
158 }
159 TELEPHONY_LOGI("Publish CallManagerService SUCCESS");
160
161 state_ = ServiceRunningState::STATE_RUNNING;
162 struct tm *timeNow = nullptr;
163 struct tm nowTime = { 0 };
164 time_t second = time(0);
165 if (second < 0) {
166 return;
167 }
168 timeNow = localtime_r(&second, &nowTime);
169 if (timeNow != nullptr) {
170 spendTime_ = duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - beginTime).count();
171 TELEPHONY_LOGI(
172 "CallManagerService start time:%{public}d-%{public}d-%{public}d %{public}d:%{public}d:%{public}d",
173 timeNow->tm_year + startTime_, timeNow->tm_mon + extraMonth_, timeNow->tm_mday, timeNow->tm_hour,
174 timeNow->tm_min, timeNow->tm_sec);
175 TELEPHONY_LOGI("CallManagerService start service cost time:%{public}d(milliseconds)", spendTime_);
176 }
177 LocationSubscriber::Subscriber();
178 }
179
OnStop()180 void CallManagerService::OnStop()
181 {
182 std::lock_guard<std::mutex> guard(lock_);
183 struct tm *timeNow = nullptr;
184 struct tm nowTime = { 0 };
185 time_t second = time(0);
186 if (second < 0) {
187 return;
188 }
189 timeNow = localtime_r(&second, &nowTime);
190 if (timeNow != nullptr) {
191 TELEPHONY_LOGI(
192 "CallManagerService dump time:%{public}d-%{public}d-%{public}d %{public}d:%{public}d:%{public}d",
193 timeNow->tm_year + startTime_, timeNow->tm_mon + extraMonth_, timeNow->tm_mday, timeNow->tm_hour,
194 timeNow->tm_min, timeNow->tm_sec);
195 }
196 DelayedSingleton<CellularCallConnection>::GetInstance()->UnInit();
197 state_ = ServiceRunningState::STATE_STOPPED;
198 UnInit();
199 }
200
GetServiceRunningState()201 int32_t CallManagerService::GetServiceRunningState()
202 {
203 return static_cast<int32_t>(state_);
204 }
205
Dump(std::int32_t fd,const std::vector<std::u16string> & args)206 int32_t CallManagerService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
207 {
208 if (fd < 0) {
209 TELEPHONY_LOGE("dump fd invalid");
210 return TELEPHONY_ERR_ARGUMENT_INVALID;
211 }
212 std::vector<std::string> argsInStr;
213 for (const auto &arg : args) {
214 TELEPHONY_LOGI("Dump args: %s", Str16ToStr8(arg).c_str());
215 argsInStr.emplace_back(Str16ToStr8(arg));
216 }
217 std::string result;
218 CallManagerDumpHelper dumpHelper;
219 if (dumpHelper.Dump(argsInStr, result)) {
220 TELEPHONY_LOGI("%s", result.c_str());
221 std::int32_t ret = dprintf(fd, "%s", result.c_str());
222 if (ret < 0) {
223 TELEPHONY_LOGE("dprintf to dump fd failed");
224 return CALL_ERR_SERVICE_DUMP_FAILED;
225 }
226 return TELEPHONY_SUCCESS;
227 }
228 TELEPHONY_LOGW("dumpHelper failed");
229 return CALL_ERR_SERVICE_DUMP_FAILED;
230 }
231
GetBindTime()232 std::string CallManagerService::GetBindTime()
233 {
234 bindTime_ =
235 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
236 .count();
237 std::ostringstream oss;
238 oss << bindTime_;
239 return oss.str();
240 }
241
GetStartServiceSpent()242 std::string CallManagerService::GetStartServiceSpent()
243 {
244 std::ostringstream oss;
245 oss << spendTime_;
246 return oss.str();
247 }
248
RegisterCallBack(const sptr<ICallAbilityCallback> & callback)249 int32_t CallManagerService::RegisterCallBack(const sptr<ICallAbilityCallback> &callback)
250 {
251 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
252 TELEPHONY_LOGE("Non-system applications use system APIs!");
253 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
254 }
255 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE) &&
256 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
257 TELEPHONY_LOGD("Permission denied.");
258 return TELEPHONY_ERR_PERMISSION_ERR;
259 }
260 return DelayedSingleton<CallAbilityReportProxy>::GetInstance()->RegisterCallBack(callback, GetBundleInfo());
261 }
262
UnRegisterCallBack()263 int32_t CallManagerService::UnRegisterCallBack()
264 {
265 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
266 TELEPHONY_LOGE("Non-system applications use system APIs!");
267 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
268 }
269 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
270 TELEPHONY_LOGE("Permission denied!");
271 return TELEPHONY_ERR_PERMISSION_ERR;
272 }
273 return DelayedSingleton<CallAbilityReportProxy>::GetInstance()->UnRegisterCallBack(GetBundleInfo());
274 }
275
ObserverOnCallDetailsChange()276 int32_t CallManagerService::ObserverOnCallDetailsChange()
277 {
278 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
279 TELEPHONY_LOGE("Non-system applications use system APIs!");
280 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
281 }
282 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE) &&
283 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
284 TELEPHONY_LOGE("Permission denied!");
285 return TELEPHONY_ERR_PERMISSION_ERR;
286 }
287
288 std::vector<CallAttributeInfo> callAttributeInfo = CallObjectManager::GetAllCallInfoList();
289 for (auto info : callAttributeInfo) {
290 DelayedSingleton<CallAbilityReportProxy>::GetInstance()->ReportCallStateInfo(info, GetBundleInfo());
291 }
292 return TELEPHONY_SUCCESS;
293 }
294
DialCall(std::u16string number,AppExecFwk::PacMap & extras)295 int32_t CallManagerService::DialCall(std::u16string number, AppExecFwk::PacMap &extras)
296 {
297 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
298 TELEPHONY_LOGE("Non-system applications use system APIs!");
299 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
300 }
301 DelayedSingleton<CallManagerHisysevent>::GetInstance()->SetDialStartTime();
302 StartAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
303 int32_t uid = IPCSkeleton::GetCallingUid();
304 std::string bundleName = "";
305 TelephonyPermission::GetBundleNameByUid(uid, bundleName);
306 extras.PutStringValue("bundleName", bundleName);
307 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
308 TELEPHONY_LOGE("Permission denied!");
309 CallManagerHisysevent::WriteDialCallFaultEvent(extras.GetIntValue(SLOT_ID), extras.GetIntValue(CALL_TYPE),
310 extras.GetIntValue(VIDEO_STATE), TELEPHONY_ERR_PERMISSION_ERR, OHOS_PERMISSION_PLACE_CALL);
311 FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
312 return TELEPHONY_ERR_PERMISSION_ERR;
313 }
314 if (callControlManagerPtr_ != nullptr) {
315 int32_t ret = callControlManagerPtr_->DialCall(number, extras);
316 if (ret == TELEPHONY_SUCCESS) {
317 std::u16string voiceMailNumber;
318 CoreManagerInner::GetInstance().GetVoiceMailNumber(extras.GetIntValue(SLOT_ID), voiceMailNumber);
319 if (voiceMailNumber == number) {
320 CoreManagerInner::GetInstance().SetVoiceMailCount(extras.GetIntValue(SLOT_ID), CLEAR_VOICE_MAIL_COUNT);
321 }
322 } else {
323 std::string errordesc = "";
324 DelayedSingleton<CallManagerHisysevent>::GetInstance()->GetErrorDescription(ret, errordesc);
325 CallManagerHisysevent::WriteDialCallFaultEvent(extras.GetIntValue(SLOT_ID), extras.GetIntValue(CALL_TYPE),
326 extras.GetIntValue(VIDEO_STATE), ret, errordesc);
327 FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
328 }
329 return ret;
330 } else {
331 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
332 FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
333 return TELEPHONY_ERR_LOCAL_PTR_NULL;
334 }
335 }
336
MakeCall(std::string number)337 int32_t CallManagerService::MakeCall(std::string number)
338 {
339 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
340 TELEPHONY_LOGE("Non-system applications use system APIs!");
341 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
342 }
343 std::string identity = IPCSkeleton::ResetCallingIdentity();
344 AAFwk::Want want;
345 AppExecFwk::ElementName element("", "com.ohos.contacts", "com.ohos.contacts.MainAbility");
346 want.SetElement(element);
347 AAFwk::WantParams wantParams;
348 wantParams.SetParam("phoneNumber", AAFwk::String::Box(number));
349 wantParams.SetParam("pageFlag", AAFwk::String::Box("page_flag_edit_before_calling"));
350 want.SetParams(wantParams);
351 ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want);
352 IPCSkeleton::SetCallingIdentity(identity);
353 if (err != ERR_OK) {
354 TELEPHONY_LOGE("Fail to make call, err:%{public}d", err);
355 return TELEPHONY_ERR_UNINIT;
356 }
357 return TELEPHONY_SUCCESS;
358 }
359
AnswerCall(int32_t callId,int32_t videoState)360 int32_t CallManagerService::AnswerCall(int32_t callId, int32_t videoState)
361 {
362 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
363 TELEPHONY_LOGE("Non-system applications use system APIs!");
364 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
365 }
366 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL)) {
367 TELEPHONY_LOGE("Permission denied!");
368 return TELEPHONY_ERR_PERMISSION_ERR;
369 }
370 DelayedSingleton<CallManagerHisysevent>::GetInstance()->SetAnswerStartTime();
371 if (callControlManagerPtr_ != nullptr) {
372 return callControlManagerPtr_->AnswerCall(callId, videoState);
373 } else {
374 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
375 return TELEPHONY_ERR_LOCAL_PTR_NULL;
376 }
377 }
378
RejectCall(int32_t callId,bool rejectWithMessage,std::u16string textMessage)379 int32_t CallManagerService::RejectCall(int32_t callId, bool rejectWithMessage, std::u16string textMessage)
380 {
381 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
382 TELEPHONY_LOGE("Non-system applications use system APIs!");
383 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
384 }
385 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL) &&
386 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
387 TELEPHONY_LOGE("Permission denied!");
388 return TELEPHONY_ERR_PERMISSION_ERR;
389 }
390 if (callControlManagerPtr_ != nullptr) {
391 return callControlManagerPtr_->RejectCall(callId, rejectWithMessage, textMessage);
392 } else {
393 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
394 return TELEPHONY_ERR_LOCAL_PTR_NULL;
395 }
396 }
397
HangUpCall(int32_t callId)398 int32_t CallManagerService::HangUpCall(int32_t callId)
399 {
400 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
401 TELEPHONY_LOGE("Non-system applications use system APIs!");
402 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
403 }
404 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL) &&
405 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
406 TELEPHONY_LOGE("Permission denied!");
407 return TELEPHONY_ERR_PERMISSION_ERR;
408 }
409 if (callControlManagerPtr_ != nullptr) {
410 return callControlManagerPtr_->HangUpCall(callId);
411 } else {
412 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
413 return TELEPHONY_ERR_LOCAL_PTR_NULL;
414 }
415 }
416
GetCallState()417 int32_t CallManagerService::GetCallState()
418 {
419 if (callControlManagerPtr_ != nullptr) {
420 return callControlManagerPtr_->GetCallState();
421 } else {
422 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
423 return TELEPHONY_ERR_LOCAL_PTR_NULL;
424 }
425 }
426
HoldCall(int32_t callId)427 int32_t CallManagerService::HoldCall(int32_t callId)
428 {
429 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
430 TELEPHONY_LOGE("Non-system applications use system APIs!");
431 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
432 }
433 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL)) {
434 TELEPHONY_LOGE("Permission denied!");
435 return TELEPHONY_ERR_PERMISSION_ERR;
436 }
437 if (callControlManagerPtr_ != nullptr) {
438 return callControlManagerPtr_->HoldCall(callId);
439 } else {
440 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
441 return TELEPHONY_ERR_LOCAL_PTR_NULL;
442 }
443 }
444
UnHoldCall(int32_t callId)445 int32_t CallManagerService::UnHoldCall(int32_t callId)
446 {
447 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
448 TELEPHONY_LOGE("Non-system applications use system APIs!");
449 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
450 }
451 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL)) {
452 TELEPHONY_LOGE("Permission denied!");
453 return TELEPHONY_ERR_PERMISSION_ERR;
454 }
455 if (callControlManagerPtr_ != nullptr) {
456 return callControlManagerPtr_->UnHoldCall(callId);
457 } else {
458 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
459 return TELEPHONY_ERR_LOCAL_PTR_NULL;
460 }
461 }
462
SwitchCall(int32_t callId)463 int32_t CallManagerService::SwitchCall(int32_t callId)
464 {
465 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
466 TELEPHONY_LOGE("Non-system applications use system APIs!");
467 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
468 }
469 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_ANSWER_CALL)) {
470 TELEPHONY_LOGE("Permission denied!");
471 return TELEPHONY_ERR_PERMISSION_ERR;
472 }
473 if (callControlManagerPtr_ != nullptr) {
474 return callControlManagerPtr_->SwitchCall(callId);
475 } else {
476 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
477 return TELEPHONY_ERR_LOCAL_PTR_NULL;
478 }
479 }
480
HasCall()481 bool CallManagerService::HasCall()
482 {
483 if (callControlManagerPtr_ != nullptr) {
484 return callControlManagerPtr_->HasCall();
485 } else {
486 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
487 return false;
488 }
489 }
490
IsNewCallAllowed(bool & enabled)491 int32_t CallManagerService::IsNewCallAllowed(bool &enabled)
492 {
493 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
494 TELEPHONY_LOGE("Non-system applications use system APIs!");
495 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
496 }
497 if (callControlManagerPtr_ != nullptr) {
498 return callControlManagerPtr_->IsNewCallAllowed(enabled);
499 } else {
500 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
501 return TELEPHONY_ERR_LOCAL_PTR_NULL;
502 }
503 }
504
RegisterVoipCallManagerCallback()505 int32_t CallManagerService::RegisterVoipCallManagerCallback()
506 {
507 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
508 TELEPHONY_LOGE("Non-system applications use system APIs!");
509 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
510 }
511 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
512 TELEPHONY_LOGE("Permission denied!");
513 return TELEPHONY_ERR_PERMISSION_ERR;
514 }
515 std::lock_guard<std::mutex> guard(lock_);
516 DelayedSingleton<VoipCallConnection>::GetInstance()->Init(TELEPHONY_VOIP_CALL_MANAGER_SYS_ABILITY_ID);
517 sptr<ICallStatusCallback> voipCallCallbackPtr = (std::make_unique<CallStatusCallback>()).release();
518 if (voipCallCallbackPtr == nullptr) {
519 TELEPHONY_LOGE("voipCallCallbackPtr is nullptr!");
520 return TELEPHONY_ERR_LOCAL_PTR_NULL;
521 }
522 DelayedSingleton<VoipCallConnection>::GetInstance()->RegisterCallManagerCallBack(voipCallCallbackPtr);
523 return 0;
524 }
525
UnRegisterVoipCallManagerCallback()526 int32_t CallManagerService::UnRegisterVoipCallManagerCallback()
527 {
528 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
529 TELEPHONY_LOGE("Non-system applications use system APIs!");
530 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
531 }
532 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
533 TELEPHONY_LOGE("Permission denied!");
534 return TELEPHONY_ERR_PERMISSION_ERR;
535 }
536 std::lock_guard<std::mutex> guard(lock_);
537 return DelayedSingleton<VoipCallConnection>::GetInstance()->UnRegisterCallManagerCallBack();
538 }
539
IsRinging(bool & enabled)540 int32_t CallManagerService::IsRinging(bool &enabled)
541 {
542 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
543 TELEPHONY_LOGE("Non-system applications use system APIs!");
544 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
545 }
546 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
547 TELEPHONY_LOGE("Permission denied!");
548 return TELEPHONY_ERR_PERMISSION_ERR;
549 }
550 if (callControlManagerPtr_ != nullptr) {
551 return callControlManagerPtr_->IsRinging(enabled);
552 } else {
553 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
554 return TELEPHONY_ERR_LOCAL_PTR_NULL;
555 }
556 }
557
IsInEmergencyCall(bool & enabled)558 int32_t CallManagerService::IsInEmergencyCall(bool &enabled)
559 {
560 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
561 TELEPHONY_LOGE("Non-system applications use system APIs!");
562 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
563 }
564 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
565 TELEPHONY_LOGE("Permission denied!");
566 return TELEPHONY_ERR_PERMISSION_ERR;
567 }
568 if (callControlManagerPtr_ != nullptr) {
569 return callControlManagerPtr_->HasEmergency(enabled);
570 } else {
571 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
572 return TELEPHONY_ERR_LOCAL_PTR_NULL;
573 }
574 }
575
StartDtmf(int32_t callId,char str)576 int32_t CallManagerService::StartDtmf(int32_t callId, char str)
577 {
578 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
579 TELEPHONY_LOGE("Non-system applications use system APIs!");
580 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
581 }
582 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
583 TELEPHONY_LOGE("Permission denied!");
584 return TELEPHONY_ERR_PERMISSION_ERR;
585 }
586 if (callControlManagerPtr_ != nullptr) {
587 return callControlManagerPtr_->StartDtmf(callId, str);
588 } else {
589 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
590 return TELEPHONY_ERR_LOCAL_PTR_NULL;
591 }
592 }
593
StopDtmf(int32_t callId)594 int32_t CallManagerService::StopDtmf(int32_t callId)
595 {
596 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
597 TELEPHONY_LOGE("Non-system applications use system APIs!");
598 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
599 }
600 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
601 TELEPHONY_LOGE("Permission denied!");
602 return TELEPHONY_ERR_PERMISSION_ERR;
603 }
604 if (callControlManagerPtr_ != nullptr) {
605 return callControlManagerPtr_->StopDtmf(callId);
606 } else {
607 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
608 return TELEPHONY_ERR_LOCAL_PTR_NULL;
609 }
610 }
611
PostDialProceed(int32_t callId,bool proceed)612 int32_t CallManagerService::PostDialProceed(int32_t callId, bool proceed)
613 {
614 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
615 TELEPHONY_LOGE("Non-system applications use system APIs!");
616 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
617 }
618 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
619 TELEPHONY_LOGE("Permission denied!");
620 return TELEPHONY_ERR_PERMISSION_ERR;
621 }
622 if (callControlManagerPtr_ != nullptr) {
623 return callControlManagerPtr_->PostDialProceed(callId, proceed);
624 } else {
625 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
626 return TELEPHONY_ERR_LOCAL_PTR_NULL;
627 }
628 }
629
GetCallWaiting(int32_t slotId)630 int32_t CallManagerService::GetCallWaiting(int32_t slotId)
631 {
632 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
633 TELEPHONY_LOGE("Non-system applications use system APIs!");
634 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
635 }
636 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
637 TELEPHONY_LOGE("Permission denied!");
638 return TELEPHONY_ERR_PERMISSION_ERR;
639 }
640 if (callControlManagerPtr_ != nullptr) {
641 return callControlManagerPtr_->GetCallWaiting(slotId);
642 } else {
643 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
644 return TELEPHONY_ERR_LOCAL_PTR_NULL;
645 }
646 }
647
SetCallWaiting(int32_t slotId,bool activate)648 int32_t CallManagerService::SetCallWaiting(int32_t slotId, bool activate)
649 {
650 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
651 TELEPHONY_LOGE("Non-system applications use system APIs!");
652 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
653 }
654 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
655 TELEPHONY_LOGE("Permission denied!");
656 return TELEPHONY_ERR_PERMISSION_ERR;
657 }
658 if (callControlManagerPtr_ != nullptr) {
659 return callControlManagerPtr_->SetCallWaiting(slotId, activate);
660 } else {
661 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
662 return TELEPHONY_ERR_LOCAL_PTR_NULL;
663 }
664 }
665
GetCallRestriction(int32_t slotId,CallRestrictionType type)666 int32_t CallManagerService::GetCallRestriction(int32_t slotId, CallRestrictionType type)
667 {
668 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
669 TELEPHONY_LOGE("Non-system applications use system APIs!");
670 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
671 }
672 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
673 TELEPHONY_LOGE("Permission denied!");
674 return TELEPHONY_ERR_PERMISSION_ERR;
675 }
676 if (callControlManagerPtr_ != nullptr) {
677 return callControlManagerPtr_->GetCallRestriction(slotId, type);
678 } else {
679 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
680 return TELEPHONY_ERR_LOCAL_PTR_NULL;
681 }
682 }
683
SetCallRestriction(int32_t slotId,CallRestrictionInfo & info)684 int32_t CallManagerService::SetCallRestriction(int32_t slotId, CallRestrictionInfo &info)
685 {
686 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
687 TELEPHONY_LOGE("Non-system applications use system APIs!");
688 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
689 }
690 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
691 TELEPHONY_LOGE("Permission denied!");
692 return TELEPHONY_ERR_PERMISSION_ERR;
693 }
694 if (callControlManagerPtr_ != nullptr) {
695 return callControlManagerPtr_->SetCallRestriction(slotId, info);
696 } else {
697 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
698 return TELEPHONY_ERR_LOCAL_PTR_NULL;
699 }
700 }
701
SetCallRestrictionPassword(int32_t slotId,CallRestrictionType fac,const char * oldPassword,const char * newPassword)702 int32_t CallManagerService::SetCallRestrictionPassword(
703 int32_t slotId, CallRestrictionType fac, const char *oldPassword, const char *newPassword)
704 {
705 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
706 TELEPHONY_LOGE("Non-system applications use system APIs!");
707 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
708 }
709 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
710 TELEPHONY_LOGE("Permission denied!");
711 return TELEPHONY_ERR_PERMISSION_ERR;
712 }
713 if (callControlManagerPtr_ != nullptr) {
714 return callControlManagerPtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
715 } else {
716 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
717 return TELEPHONY_ERR_LOCAL_PTR_NULL;
718 }
719 }
720
GetCallTransferInfo(int32_t slotId,CallTransferType type)721 int32_t CallManagerService::GetCallTransferInfo(int32_t slotId, CallTransferType type)
722 {
723 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
724 TELEPHONY_LOGE("Non-system applications use system APIs!");
725 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
726 }
727 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
728 TELEPHONY_LOGE("Permission denied!");
729 return TELEPHONY_ERR_PERMISSION_ERR;
730 }
731 if (callControlManagerPtr_ != nullptr) {
732 return callControlManagerPtr_->GetCallTransferInfo(slotId, type);
733 } else {
734 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
735 return TELEPHONY_ERR_LOCAL_PTR_NULL;
736 }
737 }
738
SetCallTransferInfo(int32_t slotId,CallTransferInfo & info)739 int32_t CallManagerService::SetCallTransferInfo(int32_t slotId, CallTransferInfo &info)
740 {
741 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
742 TELEPHONY_LOGE("Non-system applications use system APIs!");
743 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
744 }
745 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
746 TELEPHONY_LOGE("Permission denied!");
747 return TELEPHONY_ERR_PERMISSION_ERR;
748 }
749 if (callControlManagerPtr_ != nullptr) {
750 return callControlManagerPtr_->SetCallTransferInfo(slotId, info);
751 } else {
752 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
753 return TELEPHONY_ERR_LOCAL_PTR_NULL;
754 }
755 }
756
CanSetCallTransferTime(int32_t slotId,bool & result)757 int32_t CallManagerService::CanSetCallTransferTime(int32_t slotId, bool &result)
758 {
759 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
760 TELEPHONY_LOGE("Non-system applications use system APIs!");
761 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
762 }
763 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
764 TELEPHONY_LOGE("Permission denied!");
765 return TELEPHONY_ERR_PERMISSION_ERR;
766 }
767 if (callControlManagerPtr_ != nullptr) {
768 return callControlManagerPtr_->CanSetCallTransferTime(slotId, result);
769 } else {
770 TELEPHONY_LOGE("[slot%{public}d] callControlManagerPtr_ is nullptr!", slotId);
771 return TELEPHONY_ERR_LOCAL_PTR_NULL;
772 }
773 }
774
SetCallPreferenceMode(int32_t slotId,int32_t mode)775 int32_t CallManagerService::SetCallPreferenceMode(int32_t slotId, int32_t mode)
776 {
777 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
778 TELEPHONY_LOGE("Permission denied!");
779 return TELEPHONY_ERR_PERMISSION_ERR;
780 }
781 if (callControlManagerPtr_ != nullptr) {
782 return callControlManagerPtr_->SetCallPreferenceMode(slotId, mode);
783 } else {
784 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
785 return TELEPHONY_ERR_LOCAL_PTR_NULL;
786 }
787 }
788
StartRtt(int32_t callId,std::u16string & msg)789 int32_t CallManagerService::StartRtt(int32_t callId, std::u16string &msg)
790 {
791 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
792 TELEPHONY_LOGE("Non-system applications use system APIs!");
793 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
794 }
795 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
796 TELEPHONY_LOGE("Permission denied!");
797 return TELEPHONY_ERR_PERMISSION_ERR;
798 }
799 if (callControlManagerPtr_ != nullptr) {
800 return callControlManagerPtr_->StartRtt(callId, msg);
801 } else {
802 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
803 return TELEPHONY_ERR_LOCAL_PTR_NULL;
804 }
805 }
806
StopRtt(int32_t callId)807 int32_t CallManagerService::StopRtt(int32_t callId)
808 {
809 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
810 TELEPHONY_LOGE("Non-system applications use system APIs!");
811 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
812 }
813 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
814 TELEPHONY_LOGE("Permission denied!");
815 return TELEPHONY_ERR_PERMISSION_ERR;
816 }
817 if (callControlManagerPtr_ != nullptr) {
818 return callControlManagerPtr_->StopRtt(callId);
819 } else {
820 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
821 return TELEPHONY_ERR_LOCAL_PTR_NULL;
822 }
823 }
824
CombineConference(int32_t mainCallId)825 int32_t CallManagerService::CombineConference(int32_t mainCallId)
826 {
827 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
828 TELEPHONY_LOGE("Non-system applications use system APIs!");
829 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
830 }
831 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
832 TELEPHONY_LOGE("Permission denied!");
833 return TELEPHONY_ERR_PERMISSION_ERR;
834 }
835 if (callControlManagerPtr_ != nullptr) {
836 return callControlManagerPtr_->CombineConference(mainCallId);
837 } else {
838 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
839 return TELEPHONY_ERR_LOCAL_PTR_NULL;
840 }
841 }
842
SeparateConference(int32_t callId)843 int32_t CallManagerService::SeparateConference(int32_t callId)
844 {
845 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
846 TELEPHONY_LOGE("Non-system applications use system APIs!");
847 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
848 }
849 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
850 TELEPHONY_LOGE("Permission denied!");
851 return TELEPHONY_ERR_PERMISSION_ERR;
852 }
853 if (callControlManagerPtr_ != nullptr) {
854 return callControlManagerPtr_->SeparateConference(callId);
855 } else {
856 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
857 return TELEPHONY_ERR_LOCAL_PTR_NULL;
858 }
859 }
860
KickOutFromConference(int32_t callId)861 int32_t CallManagerService::KickOutFromConference(int32_t callId)
862 {
863 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
864 TELEPHONY_LOGE("Non-system applications use system APIs!");
865 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
866 }
867 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
868 TELEPHONY_LOGE("Permission denied!");
869 return TELEPHONY_ERR_PERMISSION_ERR;
870 }
871 if (callControlManagerPtr_ != nullptr) {
872 return callControlManagerPtr_->KickOutFromConference(callId);
873 } else {
874 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
875 return TELEPHONY_ERR_LOCAL_PTR_NULL;
876 }
877 }
878
SetMuted(bool isMute)879 int32_t CallManagerService::SetMuted(bool isMute)
880 {
881 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
882 TELEPHONY_LOGE("Non-system applications use system APIs!");
883 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
884 }
885 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
886 TELEPHONY_LOGE("Permission denied!");
887 return TELEPHONY_ERR_PERMISSION_ERR;
888 }
889 if (callControlManagerPtr_ != nullptr) {
890 auto ret = callControlManagerPtr_->SetMuted(isMute);
891 if (ret == TELEPHONY_SUCCESS) {
892 DelayedSingleton<DistributedCommunicationManager>::GetInstance()->SetMuted(isMute);
893 DelayedSingleton<InteroperableCommunicationManager>::GetInstance()->SetMuted(isMute);
894 }
895 return ret;
896 } else {
897 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
898 return TELEPHONY_ERR_LOCAL_PTR_NULL;
899 }
900 }
901
MuteRinger()902 int32_t CallManagerService::MuteRinger()
903 {
904 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
905 TELEPHONY_LOGE("Non-system applications use system APIs!");
906 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
907 }
908 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
909 TELEPHONY_LOGE("Permission denied!");
910 return TELEPHONY_ERR_PERMISSION_ERR;
911 }
912 if (callControlManagerPtr_ != nullptr) {
913 auto ret = callControlManagerPtr_->MuteRinger();
914 if (ret == TELEPHONY_SUCCESS) {
915 DelayedSingleton<DistributedCommunicationManager>::GetInstance()->MuteRinger();
916 DelayedSingleton<InteroperableCommunicationManager>::GetInstance()->MuteRinger();
917 #ifdef SUPPORT_MUTE_BY_DATABASE
918 InteroperableSettingsHandler::SendMuteRinger();
919 #endif
920 }
921 return ret;
922 } else {
923 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
924 return TELEPHONY_ERR_LOCAL_PTR_NULL;
925 }
926 }
927
SetAudioDevice(const AudioDevice & audioDevice)928 int32_t CallManagerService::SetAudioDevice(const AudioDevice &audioDevice)
929 {
930 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
931 TELEPHONY_LOGE("Non-system applications use system APIs!");
932 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
933 }
934 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
935 TELEPHONY_LOGE("Permission denied!");
936 return TELEPHONY_ERR_PERMISSION_ERR;
937 }
938 if (callControlManagerPtr_ != nullptr) {
939 if (callControlManagerPtr_->SetAudioDevice(audioDevice) == TELEPHONY_SUCCESS) {
940 return TELEPHONY_SUCCESS;
941 }
942 TELEPHONY_LOGE("SetAudioDevice failed!");
943 return CALL_ERR_SETTING_AUDIO_DEVICE_FAILED;
944 } else {
945 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
946 return TELEPHONY_ERR_LOCAL_PTR_NULL;
947 }
948 }
949
ControlCamera(int32_t callId,std::u16string & cameraId)950 int32_t CallManagerService::ControlCamera(int32_t callId, std::u16string &cameraId)
951 {
952 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
953 TELEPHONY_LOGE("Non-system applications use system APIs!");
954 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
955 }
956 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
957 TELEPHONY_LOGE("Permission denied!");
958 return TELEPHONY_ERR_PERMISSION_ERR;
959 }
960 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
961 if (videoControlManager != nullptr) {
962 return videoControlManager->ControlCamera(
963 callId, cameraId, IPCSkeleton::GetCallingUid(), IPCSkeleton::GetCallingPid());
964 } else {
965 TELEPHONY_LOGE("videoControlManager is nullptr!");
966 return TELEPHONY_ERR_LOCAL_PTR_NULL;
967 }
968 }
969
SetPreviewWindow(int32_t callId,std::string & surfaceId,sptr<Surface> surface)970 int32_t CallManagerService::SetPreviewWindow(int32_t callId, std::string &surfaceId, sptr<Surface> surface)
971 {
972 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
973 TELEPHONY_LOGE("Non-system applications use system APIs!");
974 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
975 }
976 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
977 TELEPHONY_LOGE("Permission denied!");
978 return TELEPHONY_ERR_PERMISSION_ERR;
979 }
980 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
981 if (videoControlManager != nullptr) {
982 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
983 if (surface == nullptr) {
984 PrivacyKit::StopUsingPermission(callerToken, "ohos.permission.CAMERA");
985 } else {
986 sptr<CallBase> call = CallObjectManager::GetOneCallObjectByIndex(callId);
987 if (call == nullptr || call->GetVideoStateType() != VideoStateType::TYPE_RECEIVE_ONLY) {
988 PrivacyKit::AddPermissionUsedRecord(callerToken, "ohos.permission.CAMERA", 1, 0);
989 PrivacyKit::StartUsingPermission(callerToken, "ohos.permission.CAMERA");
990 }
991 }
992 return videoControlManager->SetPreviewWindow(callId, surfaceId, surface);
993 } else {
994 TELEPHONY_LOGE("videoControlManager is nullptr!");
995 return TELEPHONY_ERR_LOCAL_PTR_NULL;
996 }
997 }
998
SetDisplayWindow(int32_t callId,std::string & surfaceId,sptr<Surface> surface)999 int32_t CallManagerService::SetDisplayWindow(int32_t callId, std::string &surfaceId, sptr<Surface> surface)
1000 {
1001 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1002 TELEPHONY_LOGE("Non-system applications use system APIs!");
1003 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1004 }
1005 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1006 TELEPHONY_LOGE("Permission denied!");
1007 return TELEPHONY_ERR_PERMISSION_ERR;
1008 }
1009 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1010 if (videoControlManager != nullptr) {
1011 return videoControlManager->SetDisplayWindow(callId, surfaceId, surface);
1012 } else {
1013 TELEPHONY_LOGE("videoControlManager is nullptr!");
1014 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1015 }
1016 }
1017
SetCameraZoom(float zoomRatio)1018 int32_t CallManagerService::SetCameraZoom(float zoomRatio)
1019 {
1020 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1021 TELEPHONY_LOGE("Non-system applications use system APIs!");
1022 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1023 }
1024 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1025 TELEPHONY_LOGE("Permission denied!");
1026 return TELEPHONY_ERR_PERMISSION_ERR;
1027 }
1028 if (callControlManagerPtr_ != nullptr) {
1029 return callControlManagerPtr_->SetCameraZoom(zoomRatio);
1030 } else {
1031 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1032 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1033 }
1034 }
1035
SetPausePicture(int32_t callId,std::u16string & path)1036 int32_t CallManagerService::SetPausePicture(int32_t callId, std::u16string &path)
1037 {
1038 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1039 TELEPHONY_LOGE("Non-system applications use system APIs!");
1040 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1041 }
1042 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1043 TELEPHONY_LOGE("Permission denied!");
1044 return TELEPHONY_ERR_PERMISSION_ERR;
1045 }
1046 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1047 if (videoControlManager != nullptr) {
1048 return videoControlManager->SetPausePicture(callId, path);
1049 } else {
1050 TELEPHONY_LOGE("videoControlManager is nullptr!");
1051 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1052 }
1053 }
1054
SetDeviceDirection(int32_t callId,int32_t rotation)1055 int32_t CallManagerService::SetDeviceDirection(int32_t callId, int32_t rotation)
1056 {
1057 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1058 TELEPHONY_LOGE("Non-system applications use system APIs!");
1059 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1060 }
1061 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1062 TELEPHONY_LOGE("Permission denied!");
1063 return TELEPHONY_ERR_PERMISSION_ERR;
1064 }
1065 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1066 if (videoControlManager != nullptr) {
1067 return videoControlManager->SetDeviceDirection(callId, rotation);
1068 } else {
1069 TELEPHONY_LOGE("videoControlManager is nullptr!");
1070 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1071 }
1072 }
1073
IsEmergencyPhoneNumber(std::u16string & number,int32_t slotId,bool & enabled)1074 int32_t CallManagerService::IsEmergencyPhoneNumber(std::u16string &number, int32_t slotId, bool &enabled)
1075 {
1076 if (callControlManagerPtr_ != nullptr) {
1077 return callControlManagerPtr_->IsEmergencyPhoneNumber(number, slotId, enabled);
1078 } else {
1079 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1080 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1081 }
1082 }
1083
FormatPhoneNumber(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1084 int32_t CallManagerService::FormatPhoneNumber(
1085 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1086 {
1087 if (callControlManagerPtr_ != nullptr) {
1088 return callControlManagerPtr_->FormatPhoneNumber(number, countryCode, formatNumber);
1089 } else {
1090 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1091 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1092 }
1093 }
1094
FormatPhoneNumberToE164(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1095 int32_t CallManagerService::FormatPhoneNumberToE164(
1096 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1097 {
1098 if (callControlManagerPtr_ != nullptr) {
1099 return callControlManagerPtr_->FormatPhoneNumberToE164(number, countryCode, formatNumber);
1100 } else {
1101 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1102 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1103 }
1104 }
1105
GetMainCallId(int32_t callId,int32_t & mainCallId)1106 int32_t CallManagerService::GetMainCallId(int32_t callId, int32_t &mainCallId)
1107 {
1108 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1109 TELEPHONY_LOGE("Non-system applications use system APIs!");
1110 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1111 }
1112 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1113 TELEPHONY_LOGE("Permission denied!");
1114 return TELEPHONY_ERR_PERMISSION_ERR;
1115 }
1116 if (callControlManagerPtr_ != nullptr) {
1117 return callControlManagerPtr_->GetMainCallId(callId, mainCallId);
1118 } else {
1119 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1120 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1121 }
1122 }
1123
GetSubCallIdList(int32_t callId,std::vector<std::u16string> & callIdList)1124 int32_t CallManagerService::GetSubCallIdList(int32_t callId, std::vector<std::u16string> &callIdList)
1125 {
1126 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1127 TELEPHONY_LOGE("Non-system applications use system APIs!");
1128 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1129 }
1130 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1131 TELEPHONY_LOGE("Permission denied!");
1132 return TELEPHONY_ERR_PERMISSION_ERR;
1133 }
1134 if (callControlManagerPtr_ != nullptr) {
1135 return callControlManagerPtr_->GetSubCallIdList(callId, callIdList);
1136 }
1137 callIdList.clear();
1138 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1139 }
1140
GetCallIdListForConference(int32_t callId,std::vector<std::u16string> & callIdList)1141 int32_t CallManagerService::GetCallIdListForConference(int32_t callId, std::vector<std::u16string> &callIdList)
1142 {
1143 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1144 TELEPHONY_LOGE("Non-system applications use system APIs!");
1145 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1146 }
1147 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1148 TELEPHONY_LOGE("Permission denied!");
1149 return TELEPHONY_ERR_PERMISSION_ERR;
1150 }
1151 if (callControlManagerPtr_ != nullptr) {
1152 return callControlManagerPtr_->GetCallIdListForConference(callId, callIdList);
1153 }
1154 callIdList.clear();
1155 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1156 }
1157
GetImsConfig(int32_t slotId,ImsConfigItem item)1158 int32_t CallManagerService::GetImsConfig(int32_t slotId, ImsConfigItem item)
1159 {
1160 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1161 TELEPHONY_LOGE("Non-system applications use system APIs!");
1162 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1163 }
1164 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1165 TELEPHONY_LOGE("Permission denied!");
1166 return TELEPHONY_ERR_PERMISSION_ERR;
1167 }
1168 if (callControlManagerPtr_ != nullptr) {
1169 return callControlManagerPtr_->GetImsConfig(slotId, item);
1170 } else {
1171 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1172 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1173 }
1174 }
1175
SetImsConfig(int32_t slotId,ImsConfigItem item,std::u16string & value)1176 int32_t CallManagerService::SetImsConfig(int32_t slotId, ImsConfigItem item, std::u16string &value)
1177 {
1178 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1179 TELEPHONY_LOGE("Non-system applications use system APIs!");
1180 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1181 }
1182 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1183 TELEPHONY_LOGE("Permission denied!");
1184 return TELEPHONY_ERR_PERMISSION_ERR;
1185 }
1186 if (callControlManagerPtr_ != nullptr) {
1187 return callControlManagerPtr_->SetImsConfig(slotId, item, value);
1188 } else {
1189 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1190 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1191 }
1192 }
1193
GetImsFeatureValue(int32_t slotId,FeatureType type)1194 int32_t CallManagerService::GetImsFeatureValue(int32_t slotId, FeatureType type)
1195 {
1196 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1197 TELEPHONY_LOGE("Non-system applications use system APIs!");
1198 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1199 }
1200 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1201 TELEPHONY_LOGE("Permission denied!");
1202 return TELEPHONY_ERR_PERMISSION_ERR;
1203 }
1204 if (callControlManagerPtr_ != nullptr) {
1205 return callControlManagerPtr_->GetImsFeatureValue(slotId, type);
1206 } else {
1207 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1208 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1209 }
1210 }
1211
SetImsFeatureValue(int32_t slotId,FeatureType type,int32_t value)1212 int32_t CallManagerService::SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value)
1213 {
1214 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1215 TELEPHONY_LOGE("Non-system applications use system APIs!");
1216 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1217 }
1218 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1219 TELEPHONY_LOGE("Permission denied!");
1220 return TELEPHONY_ERR_PERMISSION_ERR;
1221 }
1222 if (callControlManagerPtr_ != nullptr) {
1223 return callControlManagerPtr_->SetImsFeatureValue(slotId, type, value);
1224 } else {
1225 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1226 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1227 }
1228 }
1229
UpdateImsCallMode(int32_t callId,ImsCallMode mode)1230 int32_t CallManagerService::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1231 {
1232 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1233 TELEPHONY_LOGE("Non-system applications use system APIs!");
1234 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1235 }
1236 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1237 TELEPHONY_LOGE("Permission denied!");
1238 return TELEPHONY_ERR_PERMISSION_ERR;
1239 }
1240 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1241 if (videoControlManager != nullptr) {
1242 return videoControlManager->UpdateImsCallMode(callId, mode);
1243 } else {
1244 TELEPHONY_LOGE("videoControlManager is nullptr!");
1245 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1246 }
1247 }
1248
EnableImsSwitch(int32_t slotId)1249 int32_t CallManagerService::EnableImsSwitch(int32_t slotId)
1250 {
1251 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1252 TELEPHONY_LOGE("Non-system applications use system APIs!");
1253 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1254 }
1255 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1256 TELEPHONY_LOGE("Permission denied!");
1257 return TELEPHONY_ERR_PERMISSION_ERR;
1258 }
1259 if (callControlManagerPtr_ != nullptr) {
1260 return callControlManagerPtr_->EnableImsSwitch(slotId);
1261 } else {
1262 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1263 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1264 }
1265 }
1266
DisableImsSwitch(int32_t slotId)1267 int32_t CallManagerService::DisableImsSwitch(int32_t slotId)
1268 {
1269 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1270 TELEPHONY_LOGE("Non-system applications use system APIs!");
1271 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1272 }
1273 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1274 TELEPHONY_LOGE("Permission denied!");
1275 return TELEPHONY_ERR_PERMISSION_ERR;
1276 }
1277 if (callControlManagerPtr_ != nullptr) {
1278 return callControlManagerPtr_->DisableImsSwitch(slotId);
1279 } else {
1280 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1281 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1282 }
1283 }
1284
IsImsSwitchEnabled(int32_t slotId,bool & enabled)1285 int32_t CallManagerService::IsImsSwitchEnabled(int32_t slotId, bool &enabled)
1286 {
1287 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1288 TELEPHONY_LOGE("Non-system applications use system APIs!");
1289 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1290 }
1291 if (callControlManagerPtr_ != nullptr) {
1292 return callControlManagerPtr_->IsImsSwitchEnabled(slotId, enabled);
1293 } else {
1294 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1295 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1296 }
1297 }
1298
SetVoNRState(int32_t slotId,int32_t state)1299 int32_t CallManagerService::SetVoNRState(int32_t slotId, int32_t state)
1300 {
1301 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1302 TELEPHONY_LOGE("Non-system applications use system APIs!");
1303 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1304 }
1305 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1306 TELEPHONY_LOGE("Permission denied!");
1307 return TELEPHONY_ERR_PERMISSION_ERR;
1308 }
1309 if (callControlManagerPtr_ != nullptr) {
1310 return callControlManagerPtr_->SetVoNRState(slotId, state);
1311 } else {
1312 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1313 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1314 }
1315 }
1316
GetVoNRState(int32_t slotId,int32_t & state)1317 int32_t CallManagerService::GetVoNRState(int32_t slotId, int32_t &state)
1318 {
1319 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1320 TELEPHONY_LOGE("Non-system applications use system APIs!");
1321 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1322 }
1323 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1324 TELEPHONY_LOGE("Permission denied!");
1325 return TELEPHONY_ERR_PERMISSION_ERR;
1326 }
1327 if (callControlManagerPtr_ != nullptr) {
1328 return callControlManagerPtr_->GetVoNRState(slotId, state);
1329 } else {
1330 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1331 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1332 }
1333 }
1334
JoinConference(int32_t callId,std::vector<std::u16string> & numberList)1335 int32_t CallManagerService::JoinConference(int32_t callId, std::vector<std::u16string> &numberList)
1336 {
1337 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1338 TELEPHONY_LOGE("Non-system applications use system APIs!");
1339 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1340 }
1341 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
1342 TELEPHONY_LOGE("Permission denied!");
1343 return TELEPHONY_ERR_PERMISSION_ERR;
1344 }
1345 if (callControlManagerPtr_ != nullptr) {
1346 return callControlManagerPtr_->JoinConference(callId, numberList);
1347 }
1348 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1349 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1350 }
1351
ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> & ottVec)1352 int32_t CallManagerService::ReportOttCallDetailsInfo(std::vector<OttCallDetailsInfo> &ottVec)
1353 {
1354 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1355 TELEPHONY_LOGE("Non-system applications use system APIs!");
1356 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1357 }
1358 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1359 TELEPHONY_LOGE("Permission denied!");
1360 return TELEPHONY_ERR_PERMISSION_ERR;
1361 }
1362 if (ottVec.empty()) {
1363 TELEPHONY_LOGE("ottVec is empty!");
1364 return TELEPHONY_ERR_ARGUMENT_INVALID;
1365 }
1366 CallDetailsInfo detailsInfo;
1367 CallDetailInfo detailInfo;
1368 detailsInfo.slotId = ERR_ID;
1369 (void)memcpy_s(detailsInfo.bundleName, kMaxBundleNameLen, ottVec[0].bundleName, kMaxBundleNameLen);
1370 detailInfo.callType = CallType::TYPE_OTT;
1371 detailInfo.accountId = ERR_ID;
1372 detailInfo.index = ERR_ID;
1373 detailInfo.voiceDomain = ERR_ID;
1374 std::vector<OttCallDetailsInfo>::iterator it = ottVec.begin();
1375 for (; it != ottVec.end(); ++it) {
1376 detailInfo.callMode = (*it).videoState;
1377 detailInfo.state = (*it).callState;
1378 (void)memcpy_s(detailInfo.phoneNum, kMaxNumberLen, (*it).phoneNum, kMaxNumberLen);
1379 (void)memcpy_s(detailInfo.bundleName, kMaxBundleNameLen, (*it).bundleName, kMaxBundleNameLen);
1380 detailsInfo.callVec.push_back(detailInfo);
1381 }
1382 int32_t ret = DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallsReportInfo(detailsInfo);
1383 if (ret != TELEPHONY_SUCCESS) {
1384 TELEPHONY_LOGE("UpdateCallsReportInfo failed! errCode:%{public}d", ret);
1385 } else {
1386 TELEPHONY_LOGI("UpdateCallsReportInfo success!");
1387 }
1388 return ret;
1389 }
1390
ReportOttCallEventInfo(OttCallEventInfo & eventInfo)1391 int32_t CallManagerService::ReportOttCallEventInfo(OttCallEventInfo &eventInfo)
1392 {
1393 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1394 TELEPHONY_LOGE("Non-system applications use system APIs!");
1395 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1396 }
1397 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1398 TELEPHONY_LOGE("Permission denied!");
1399 return TELEPHONY_ERR_PERMISSION_ERR;
1400 }
1401 int32_t ret = DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateOttEventInfo(eventInfo);
1402 if (ret != TELEPHONY_SUCCESS) {
1403 TELEPHONY_LOGE("UpdateOttEventInfo failed! errCode:%{public}d", ret);
1404 } else {
1405 TELEPHONY_LOGI("UpdateOttEventInfo success!");
1406 }
1407 return ret;
1408 }
1409
CloseUnFinishedUssd(int32_t slotId)1410 int32_t CallManagerService::CloseUnFinishedUssd(int32_t slotId)
1411 {
1412 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1413 TELEPHONY_LOGE("Non system applications use system APIs!");
1414 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1415 }
1416 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1417 TELEPHONY_LOGE("Permission denied!");
1418 return TELEPHONY_ERR_PERMISSION_ERR;
1419 }
1420 if (callControlManagerPtr_ != nullptr) {
1421 return callControlManagerPtr_->CloseUnFinishedUssd(slotId);
1422 } else {
1423 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1424 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1425 }
1426 }
1427
InputDialerSpecialCode(const std::string & specialCode)1428 int32_t CallManagerService::InputDialerSpecialCode(const std::string &specialCode)
1429 {
1430 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1431 TELEPHONY_LOGE("Non system applications use system APIs!");
1432 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1433 }
1434 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
1435 TELEPHONY_LOGE("Permission denied!");
1436 return TELEPHONY_ERR_PERMISSION_ERR;
1437 }
1438
1439 auto it = find(supportSpecialCode_.begin(), supportSpecialCode_.end(), specialCode);
1440 if (it == supportSpecialCode_.end()) {
1441 TELEPHONY_LOGE("specialCode is not support");
1442 return TELEPHONY_ERR_ARGUMENT_INVALID;
1443 }
1444 AAFwk::Want want;
1445 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SPECIAL_CODE);
1446 EventFwk::CommonEventData commonEventData;
1447 commonEventData.SetWant(want);
1448 commonEventData.SetData(specialCode);
1449 EventFwk::CommonEventPublishInfo publishInfo;
1450 if (!EventFwk::CommonEventManager::PublishCommonEvent(commonEventData, publishInfo, nullptr)) {
1451 TELEPHONY_LOGE("PublishCommonEvent fail");
1452 return TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL;
1453 }
1454 return TELEPHONY_SUCCESS;
1455 }
1456
RemoveMissedIncomingCallNotification()1457 int32_t CallManagerService::RemoveMissedIncomingCallNotification()
1458 {
1459 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1460 TELEPHONY_LOGE("Non-system applications use system APIs!");
1461 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1462 }
1463 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE) ||
1464 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_READ_CALL_LOG) ||
1465 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_WRITE_CALL_LOG)) {
1466 TELEPHONY_LOGE("Permission denied!");
1467 return TELEPHONY_ERR_PERMISSION_ERR;
1468 }
1469 if (callControlManagerPtr_ == nullptr) {
1470 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1471 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1472 }
1473 return callControlManagerPtr_->RemoveMissedIncomingCallNotification();
1474 }
1475
SetVoIPCallState(int32_t state)1476 int32_t CallManagerService::SetVoIPCallState(int32_t state)
1477 {
1478 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1479 TELEPHONY_LOGE("Non-system applications use system APIs!");
1480 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1481 }
1482 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE) &&
1483 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1484 TELEPHONY_LOGE("Permission denied!");
1485 return TELEPHONY_ERR_PERMISSION_ERR;
1486 }
1487 if (callControlManagerPtr_ != nullptr) {
1488 return callControlManagerPtr_->SetVoIPCallState(state);
1489 } else {
1490 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1491 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1492 }
1493 }
1494
GetVoIPCallState(int32_t & state)1495 int32_t CallManagerService::GetVoIPCallState(int32_t &state)
1496 {
1497 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1498 TELEPHONY_LOGE("Non-system applications use system APIs!");
1499 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1500 }
1501 if (callControlManagerPtr_ != nullptr) {
1502 return callControlManagerPtr_->GetVoIPCallState(state);
1503 } else {
1504 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1505 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1506 }
1507 }
1508
SetVoIPCallInfo(int32_t callId,int32_t state,std::string phoneNumber)1509 int32_t CallManagerService::SetVoIPCallInfo(int32_t callId, int32_t state, std::string phoneNumber)
1510 {
1511 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1512 TELEPHONY_LOGE("Non-system applications use system APIs!");
1513 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1514 }
1515 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE) &&
1516 !TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1517 TELEPHONY_LOGE("Permission denied!");
1518 return TELEPHONY_ERR_PERMISSION_ERR;
1519 }
1520 if (callControlManagerPtr_ == nullptr) {
1521 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1522 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1523 }
1524 return callControlManagerPtr_->SetVoIPCallInfo(callId, state, phoneNumber);
1525 }
1526
GetVoIPCallInfo(int32_t & callId,int32_t & state,std::string & phoneNumber)1527 int32_t CallManagerService::GetVoIPCallInfo(int32_t &callId, int32_t &state, std::string &phoneNumber)
1528 {
1529 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1530 TELEPHONY_LOGE("Non-system applications use system APIs!");
1531 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1532 }
1533 if (callControlManagerPtr_ != nullptr) {
1534 return callControlManagerPtr_->GetVoIPCallInfo(callId, state, phoneNumber);
1535 } else {
1536 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
1537 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1538 }
1539 }
1540
GetProxyObjectPtr(CallManagerProxyType proxyType)1541 sptr<IRemoteObject> CallManagerService::GetProxyObjectPtr(CallManagerProxyType proxyType)
1542 {
1543 std::lock_guard<std::mutex> guard(lock_);
1544 auto it = proxyObjectPtrMap_.find(static_cast<uint32_t>(proxyType));
1545 if (it != proxyObjectPtrMap_.end()) {
1546 TELEPHONY_LOGI("GetProxyObjectPtr success! proxyType:%{public}d", proxyType);
1547 return it->second;
1548 } else {
1549 switch (proxyType) {
1550 case PROXY_BLUETOOTH_CALL: {
1551 sptr<BluetoothCallService> ptr = new (std::nothrow) BluetoothCallService();
1552 if (ptr == nullptr) {
1553 TELEPHONY_LOGE("create BluetoothCallService object failed!");
1554 return nullptr;
1555 }
1556 proxyObjectPtrMap_[proxyType] = ptr->AsObject().GetRefPtr();
1557 TELEPHONY_LOGI("create BluetoothCallService object success! proxyType:%{public}d", proxyType);
1558 return ptr->AsObject().GetRefPtr();
1559 }
1560 default:
1561 TELEPHONY_LOGE("invalid proxyType!");
1562 break;
1563 }
1564 }
1565 TELEPHONY_LOGE("GetProxyObjectPtr failed! proxyType:%{public}d", proxyType);
1566 return nullptr;
1567 }
1568
GetBundleInfo()1569 std::string CallManagerService::GetBundleInfo()
1570 {
1571 int32_t uid = IPCSkeleton::GetCallingUid();
1572 std::string bundleName = "";
1573 TelephonyPermission::GetBundleNameByUid(uid, bundleName);
1574 if (bundleName.empty()) {
1575 bundleName.append(std::to_string(uid));
1576 bundleName.append(std::to_string(IPCSkeleton::GetCallingPid()));
1577 }
1578 std::string bundleInfo = "";
1579 bundleInfo.append(bundleName);
1580 bundleInfo.append(":");
1581 bundleInfo.append(std::to_string(IPCSkeleton::GetCallingPid()));
1582 return bundleInfo;
1583 }
1584
ReportAudioDeviceInfo()1585 int32_t CallManagerService::ReportAudioDeviceInfo()
1586 {
1587 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1588 TELEPHONY_LOGE("Permission denied!");
1589 return TELEPHONY_ERR_PERMISSION_ERR;
1590 }
1591 AudioDevice device = {
1592 .deviceType = AudioDeviceType::DEVICE_UNKNOWN,
1593 .address = { 0 },
1594 };
1595 return DelayedSingleton<AudioDeviceManager>::GetInstance()->ReportAudioDeviceChange(device);
1596 }
1597
CancelCallUpgrade(int32_t callId)1598 int32_t CallManagerService::CancelCallUpgrade(int32_t callId)
1599 {
1600 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1601 TELEPHONY_LOGE("Non-system applications use system APIs!");
1602 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1603 }
1604 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL)) {
1605 TELEPHONY_LOGE("Permission denied!");
1606 return TELEPHONY_ERR_PERMISSION_ERR;
1607 }
1608 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1609 if (videoControlManager != nullptr) {
1610 return DelayedSingleton<VideoControlManager>::GetInstance()->CancelCallUpgrade(callId);
1611 } else {
1612 TELEPHONY_LOGE("videoControlManager is nullptr!");
1613 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1614 }
1615 }
1616
RequestCameraCapabilities(int32_t callId)1617 int32_t CallManagerService::RequestCameraCapabilities(int32_t callId)
1618 {
1619 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1620 TELEPHONY_LOGE("Non-system applications use system APIs!");
1621 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1622 }
1623 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_GET_TELEPHONY_STATE)) {
1624 TELEPHONY_LOGE("Permission denied!");
1625 return TELEPHONY_ERR_PERMISSION_ERR;
1626 }
1627 auto videoControlManager = DelayedSingleton<VideoControlManager>::GetInstance();
1628 if (videoControlManager != nullptr) {
1629 return DelayedSingleton<VideoControlManager>::GetInstance()->RequestCameraCapabilities(callId);
1630 } else {
1631 TELEPHONY_LOGE("videoControlManager is nullptr!");
1632 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1633 }
1634 }
1635
dealCeliaCallEvent(int32_t callId)1636 int32_t CallManagerService::dealCeliaCallEvent(int32_t callId)
1637 {
1638 sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
1639 if (callPtr == nullptr) {
1640 TELEPHONY_LOGI("the call object is nullptr!");
1641 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1642 }
1643 if (callStatusManagerPtr_ != nullptr) {
1644 callStatusManagerPtr_->HandleCeliaCall(callPtr);
1645 }
1646 callPtr->SetCeliaCallType(IS_CELIA_CALL);
1647 TELEPHONY_LOGI("set selia call type!");
1648 if (DelayedSingleton<DistributedCallManager>::GetInstance()->IsDCallDeviceSwitchedOn()) {
1649 TELEPHONY_LOGI("switch device to local.");
1650 DelayedSingleton<DistributedCallManager>::GetInstance()->SwitchOffDCallDeviceSync();
1651 DelayedSingleton<DistributedCallManager>::GetInstance()->ReportDistributedDeviceInfoForSwitchOff();
1652 }
1653 return TELEPHONY_SUCCESS;
1654 }
1655
SendCallUiEvent(int32_t callId,std::string & eventName)1656 int32_t CallManagerService::SendCallUiEvent(int32_t callId, std::string &eventName)
1657 {
1658 TELEPHONY_LOGI("SendCallUiEvent eventName=%{public}s", eventName.c_str());
1659 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1660 TELEPHONY_LOGE("Permission denied!");
1661 return TELEPHONY_ERR_PERMISSION_ERR;
1662 }
1663 if (eventName == "EVENT_IS_CELIA_CALL") {
1664 return dealCeliaCallEvent(callId);
1665 } else if (eventName == "EVENT_SPEAKER_OFF") {
1666 if (!DelayedSingleton<AudioProxy>::GetInstance()->SetSpeakerDevActive(false)) {
1667 return TELEPHONY_ERR_FAIL;
1668 }
1669 } else if (eventName == "DISPLAY_SPECIFIED_CALL_PAGE_BY_CALL_ID") {
1670 TELEPHONY_LOGI("enter emergency start callui event");
1671 sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
1672 if (callPtr == nullptr) {
1673 TELEPHONY_LOGI("the call object is nullptr!");
1674 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1675 }
1676 CallAttributeInfo info;
1677 callPtr->GetCallAttributeInfo(info);
1678 AAFwk::WantParams object = AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(info.extraParamsString);
1679 object.SetParam("sosWithOutCallUiAbility", AAFwk::String::Box(SOS_PULL_CALL_PAGE));
1680 info.extraParamsString = AAFwk::WantParamWrapper(object).ToString();
1681 object.Remove("sosWithOutCallUiAbility");
1682 callPtr->SetExtraParams(object);
1683 DelayedSingleton<CallAbilityReportProxy>::GetInstance()->ReportCallStateInfo(info);
1684 } else if (eventName == "EVENT_BLUETOOTH_SCO_STATE_OFF") {
1685 return DelayedSingleton<BluetoothCallConnection>::GetInstance()->DisConnectBtSco();
1686 } else if (eventName == "EVENT_BLUETOOTH_SCO_STATE_ON") {
1687 return DelayedSingleton<BluetoothCallConnection>::GetInstance()->ConnectBtSco();
1688 } else if (eventName == "EVENT_SUPPORT_BLUETOOTH_CALL") {
1689 if (DelayedSingleton<BluetoothCallConnection>::GetInstance()->GetSupportBtCall()) {
1690 return TELEPHONY_SUCCESS;
1691 }
1692 return TELEPHONY_ERR_FAIL;
1693 } else if (eventName == "EVENT_NOT_SUPPORT_BLUETOOTH_CALL") {
1694 if (!DelayedSingleton<BluetoothCallConnection>::GetInstance()->GetSupportBtCall()) {
1695 return TELEPHONY_SUCCESS;
1696 }
1697 return TELEPHONY_ERR_FAIL;
1698 }
1699 return TELEPHONY_SUCCESS;
1700 }
1701
RegisterBluetoothCallManagerCallbackPtr(std::string & macAddress)1702 sptr<ICallStatusCallback> CallManagerService::RegisterBluetoothCallManagerCallbackPtr(std::string &macAddress)
1703 {
1704 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1705 TELEPHONY_LOGE("CallManagerService RegisterBluetoothCallManagerCallbackPtr, Permission denied!");
1706 return nullptr;
1707 }
1708 std::lock_guard<std::mutex> guard(lock_);
1709 if (bluetoothCallCallbackPtr_ == nullptr) {
1710 bluetoothCallCallbackPtr_ = new (std::nothrow) CallStatusCallback();
1711 if (bluetoothCallCallbackPtr_ == nullptr) {
1712 TELEPHONY_LOGE("create CallStatusCallback object failed!");
1713 return nullptr;
1714 }
1715 }
1716 if (macAddress.empty()) {
1717 TELEPHONY_LOGE("macAddress is empty!");
1718 }
1719 Bluetooth::HandsFreeUnit *profile = Bluetooth::HandsFreeUnit::GetProfile();
1720 if (profile != nullptr) {
1721 if (bluetoothCallObserver_ == nullptr) {
1722 bluetoothCallObserver_ = std::make_shared<BluetoothCallState>();
1723 }
1724 profile->RegisterObserver(bluetoothCallObserver_);
1725 } else {
1726 TELEPHONY_LOGE("profile is nullptr");
1727 }
1728 DelayedSingleton<BluetoothCallConnection>::GetInstance()->SetMacAddress(macAddress);
1729 return bluetoothCallCallbackPtr_;
1730 }
1731
SendUssdResponse(int32_t slotId,const std::string & content)1732 int32_t CallManagerService::SendUssdResponse(int32_t slotId, const std::string &content)
1733 {
1734 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1735 TELEPHONY_LOGE("Non-system applications use system APIs!");
1736 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1737 }
1738 if (!TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
1739 TELEPHONY_LOGE("Permission denied!");
1740 return TELEPHONY_ERR_PERMISSION_ERR;
1741 }
1742 DelayedSingleton<CellularCallConnection>::GetInstance()->SendUssdResponse(slotId, content);
1743 return TELEPHONY_SUCCESS;
1744 }
1745 } // namespace Telephony
1746 } // namespace OHOS
1747