1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "call_ability_callback_stub.h"
17
18 #include <securec.h>
19
20 #include "call_manager_errors.h"
21 #include "telephony_log_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
25 const int32_t MAX_LEN = 100000;
CallAbilityCallbackStub()26 CallAbilityCallbackStub::CallAbilityCallbackStub()
27 {
28 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO)] =
29 &CallAbilityCallbackStub::OnUpdateCallStateInfo;
30 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_EVENT)] =
31 &CallAbilityCallbackStub::OnUpdateCallEvent;
32 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_DISCONNECTED_CAUSE)] =
33 &CallAbilityCallbackStub::OnUpdateCallDisconnectedCause;
34 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_ASYNC_RESULT_REQUEST)] =
35 &CallAbilityCallbackStub::OnUpdateAysncResults;
36 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::REPORT_OTT_CALL_REQUEST)] =
37 &CallAbilityCallbackStub::OnUpdateOttCallRequest;
38 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_MMI_CODE_RESULT_REQUEST)] =
39 &CallAbilityCallbackStub::OnUpdateMmiCodeResults;
40 memberFuncMap_[static_cast<uint32_t>(
41 CallManagerCallAbilityInterfaceCode::UPDATE_AUDIO_DEVICE_CHANGE_RESULT_REQUEST)] =
42 &CallAbilityCallbackStub::OnUpdateAudioDeviceChange;
43 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::REPORT_POST_DIAL_DELAY)] =
44 &CallAbilityCallbackStub::OnUpdatePostDialDelay;
45 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_IMS_CALL_MODE_RECEIVE)] =
46 &CallAbilityCallbackStub::OnUpdateImsCallModeChange;
47 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::CALL_SESSION_EVENT_CHANGE)] =
48 &CallAbilityCallbackStub::OnUpdateCallSessionEventChange;
49 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::PEERD_DIMENSIONS_CHANGE)] =
50 &CallAbilityCallbackStub::OnUpdatePeerDimensionsChange;
51 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::CALL_DATA_USAGE_CHANGE)] =
52 &CallAbilityCallbackStub::OnUpdateCallDataUsageChange;
53 memberFuncMap_[static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::CAMERA_CAPABILITIES_CHANGE)] =
54 &CallAbilityCallbackStub::OnUpdateCameraCapabilities;
55 }
56
~CallAbilityCallbackStub()57 CallAbilityCallbackStub::~CallAbilityCallbackStub()
58 {
59 memberFuncMap_.clear();
60 }
61
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)62 int32_t CallAbilityCallbackStub::OnRemoteRequest(
63 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
64 {
65 std::u16string myDescriptor = CallAbilityCallbackStub::GetDescriptor();
66 std::u16string remoteDescriptor = data.ReadInterfaceToken();
67 if (myDescriptor != remoteDescriptor) {
68 TELEPHONY_LOGE("descriptor checked failed");
69 return TELEPHONY_ERR_DESCRIPTOR_MISMATCH;
70 }
71 TELEPHONY_LOGI("OnReceived, cmd = %{public}u", code);
72 auto itFunc = memberFuncMap_.find(code);
73 if (itFunc != memberFuncMap_.end()) {
74 auto memberFunc = itFunc->second;
75 if (memberFunc != nullptr) {
76 return (this->*memberFunc)(data, reply);
77 }
78 }
79 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
80 }
81
OnUpdateCallStateInfo(MessageParcel & data,MessageParcel & reply)82 int32_t CallAbilityCallbackStub::OnUpdateCallStateInfo(MessageParcel &data, MessageParcel &reply)
83 {
84 int32_t result = TELEPHONY_SUCCESS;
85 CallAttributeInfo parcelPtr;
86 if (!data.ContainFileDescriptors()) {
87 TELEPHONY_LOGW("sent raw data is less than 32k");
88 }
89 strncpy_s(parcelPtr.accountNumber, kMaxNumberLen + 1, data.ReadCString(), kMaxNumberLen + 1);
90 strncpy_s(parcelPtr.bundleName, kMaxNumberLen + 1, data.ReadCString(), kMaxNumberLen + 1);
91 parcelPtr.speakerphoneOn = data.ReadBool();
92 parcelPtr.accountId = data.ReadInt32();
93 parcelPtr.videoState = static_cast<VideoStateType>(data.ReadInt32());
94 parcelPtr.startTime = data.ReadInt64();
95 parcelPtr.isEcc = data.ReadBool();
96 parcelPtr.callType = static_cast<CallType>(data.ReadInt32());
97 parcelPtr.callId = data.ReadInt32();
98 parcelPtr.callState = static_cast<TelCallState>(data.ReadInt32());
99 parcelPtr.conferenceState = static_cast<TelConferenceState>(data.ReadInt32());
100 parcelPtr.callBeginTime = data.ReadInt64();
101 parcelPtr.callEndTime = data.ReadInt64();
102 parcelPtr.ringBeginTime = data.ReadInt64();
103 parcelPtr.ringEndTime = data.ReadInt64();
104 parcelPtr.callDirection = static_cast<CallDirection>(data.ReadInt32());
105 parcelPtr.answerType = static_cast<CallAnswerType>(data.ReadInt32());
106 parcelPtr.index = data.ReadInt32();
107 parcelPtr.crsType = data.ReadInt32();
108 parcelPtr.originalCallType = data.ReadInt32();
109 if (parcelPtr.callType == CallType::TYPE_VOIP) {
110 parcelPtr.voipCallInfo.voipCallId = data.ReadString();
111 parcelPtr.voipCallInfo.userName = data.ReadString();
112 parcelPtr.voipCallInfo.abilityName = data.ReadString();
113 parcelPtr.voipCallInfo.extensionId = data.ReadString();
114 parcelPtr.voipCallInfo.voipBundleName = data.ReadString();
115 std::vector<uint8_t> userProfile = {};
116 data.ReadUInt8Vector(&userProfile);
117 (parcelPtr.voipCallInfo.userProfile).assign(userProfile.begin(), userProfile.end());
118 }
119 result = OnCallDetailsChange(parcelPtr);
120 if (!reply.WriteInt32(result)) {
121 TELEPHONY_LOGE("writing parcel failed");
122 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
123 }
124 return TELEPHONY_SUCCESS;
125 }
126
OnUpdateCallEvent(MessageParcel & data,MessageParcel & reply)127 int32_t CallAbilityCallbackStub::OnUpdateCallEvent(MessageParcel &data, MessageParcel &reply)
128 {
129 int32_t result = TELEPHONY_SUCCESS;
130 const CallEventInfo *parcelPtr = nullptr;
131 int32_t len = data.ReadInt32();
132 if (len <= 0 || len >= MAX_LEN) {
133 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
134 return TELEPHONY_ERR_ARGUMENT_INVALID;
135 }
136 if (!data.ContainFileDescriptors()) {
137 TELEPHONY_LOGW("sent raw data is less than 32k");
138 }
139 if ((parcelPtr = reinterpret_cast<const CallEventInfo *>(data.ReadRawData(sizeof(CallEventInfo)))) == nullptr) {
140 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
141 return TELEPHONY_ERR_LOCAL_PTR_NULL;
142 }
143
144 CallEventInfo info = *parcelPtr;
145 result = OnCallEventChange(info);
146 if (!reply.WriteInt32(result)) {
147 TELEPHONY_LOGE("writing parcel failed");
148 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
149 }
150 return TELEPHONY_SUCCESS;
151 }
152
OnUpdateCallDisconnectedCause(MessageParcel & data,MessageParcel & reply)153 int32_t CallAbilityCallbackStub::OnUpdateCallDisconnectedCause(MessageParcel &data, MessageParcel &reply)
154 {
155 DisconnectedDetails dcDetails;
156 dcDetails.reason = static_cast<DisconnectedReason>(data.ReadInt32());
157 dcDetails.message = data.ReadString();
158 int32_t result = OnCallDisconnectedCause(dcDetails);
159 if (!reply.WriteInt32(result)) {
160 TELEPHONY_LOGE("writing parcel failed");
161 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
162 }
163 return TELEPHONY_SUCCESS;
164 }
165
OnUpdateAysncResults(MessageParcel & data,MessageParcel & reply)166 int32_t CallAbilityCallbackStub::OnUpdateAysncResults(MessageParcel &data, MessageParcel &reply)
167 {
168 int32_t result = TELEPHONY_SUCCESS;
169 AppExecFwk::PacMap resultInfo;
170 CallResultReportId reportId = static_cast<CallResultReportId>(data.ReadInt32());
171 resultInfo.PutIntValue("result", data.ReadInt32());
172 switch (reportId) {
173 case CallResultReportId::GET_CALL_WAITING_REPORT_ID:
174 case CallResultReportId::GET_CALL_RESTRICTION_REPORT_ID:
175 resultInfo.PutIntValue("status", data.ReadInt32());
176 resultInfo.PutIntValue("classCw", data.ReadInt32());
177 break;
178 case CallResultReportId::GET_CALL_TRANSFER_REPORT_ID:
179 resultInfo.PutIntValue("status", data.ReadInt32());
180 resultInfo.PutIntValue("classx", data.ReadInt32());
181 resultInfo.PutStringValue("number", data.ReadString());
182 resultInfo.PutIntValue("type", data.ReadInt32());
183 resultInfo.PutIntValue("reason", data.ReadInt32());
184 resultInfo.PutIntValue("time", data.ReadInt32());
185 break;
186 case CallResultReportId::GET_CALL_CLIP_ID:
187 resultInfo.PutIntValue("action", data.ReadInt32());
188 resultInfo.PutIntValue("clipStat", data.ReadInt32());
189 break;
190 case CallResultReportId::GET_CALL_CLIR_ID:
191 resultInfo.PutIntValue("action", data.ReadInt32());
192 resultInfo.PutIntValue("clirStat", data.ReadInt32());
193 break;
194 case CallResultReportId::START_RTT_REPORT_ID:
195 resultInfo.PutIntValue("active", data.ReadInt32());
196 break;
197 case CallResultReportId::GET_IMS_CONFIG_REPORT_ID:
198 case CallResultReportId::GET_IMS_FEATURE_VALUE_REPORT_ID:
199 resultInfo.PutIntValue("value", data.ReadInt32());
200 break;
201 case CallResultReportId::STOP_RTT_REPORT_ID:
202 resultInfo.PutIntValue("inactive", data.ReadInt32());
203 break;
204 default:
205 break;
206 }
207 if (!data.ContainFileDescriptors()) {
208 TELEPHONY_LOGW("sent raw data is less than 32k");
209 }
210 result = OnReportAsyncResults(reportId, resultInfo);
211 if (!reply.WriteInt32(result)) {
212 TELEPHONY_LOGE("writing parcel failed");
213 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
214 }
215 return TELEPHONY_SUCCESS;
216 }
217
OnUpdateMmiCodeResults(MessageParcel & data,MessageParcel & reply)218 int32_t CallAbilityCallbackStub::OnUpdateMmiCodeResults(MessageParcel &data, MessageParcel &reply)
219 {
220 int32_t result = TELEPHONY_SUCCESS;
221 const MmiCodeInfo *parcelPtr = nullptr;
222 int32_t len = data.ReadInt32();
223 if (len <= 0 || len >= MAX_LEN) {
224 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
225 return TELEPHONY_ERR_ARGUMENT_INVALID;
226 }
227 if (!data.ContainFileDescriptors()) {
228 TELEPHONY_LOGW("sent raw data is less than 32k");
229 }
230 if ((parcelPtr = reinterpret_cast<const MmiCodeInfo *>(data.ReadRawData(sizeof(MmiCodeInfo)))) == nullptr) {
231 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
232 return TELEPHONY_ERR_LOCAL_PTR_NULL;
233 }
234
235 MmiCodeInfo info = *parcelPtr;
236 result = OnReportMmiCodeResult(info);
237 if (!reply.WriteInt32(result)) {
238 TELEPHONY_LOGE("writing parcel failed");
239 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
240 }
241 return TELEPHONY_SUCCESS;
242 }
243
OnUpdateAudioDeviceChange(MessageParcel & data,MessageParcel & reply)244 int32_t CallAbilityCallbackStub::OnUpdateAudioDeviceChange(MessageParcel &data, MessageParcel &reply)
245 {
246 int32_t result = TELEPHONY_SUCCESS;
247 if (!data.ContainFileDescriptors()) {
248 TELEPHONY_LOGW("sent raw data is less than 32k");
249 }
250 AudioDeviceInfo info;
251 if (memset_s(&info, sizeof(AudioDeviceInfo), 0, sizeof(AudioDeviceInfo)) != EOK) {
252 TELEPHONY_LOGE("memset_s address fail");
253 return TELEPHONY_ERR_MEMSET_FAIL;
254 }
255 int32_t len = data.ReadInt32();
256 if (len <= 0 || len >= MAX_LEN) {
257 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
258 return TELEPHONY_ERR_ARGUMENT_INVALID;
259 }
260 AudioDevice *audioDevicePtr = nullptr;
261 for (int32_t i = 0; i < len + 1; i++) {
262 audioDevicePtr = static_cast<AudioDevice *>(const_cast<void *>(data.ReadRawData(sizeof(AudioDevice))));
263 if (audioDevicePtr == nullptr) {
264 TELEPHONY_LOGE("Invalid parameter audioDevicePtr");
265 return TELEPHONY_ERR_ARGUMENT_INVALID;
266 }
267 if (i < len) {
268 info.audioDeviceList.push_back(*audioDevicePtr);
269 } else {
270 info.currentAudioDevice = *audioDevicePtr;
271 }
272 }
273
274 info.isMuted = data.ReadBool();
275 result = OnReportAudioDeviceChange(info);
276 if (!reply.WriteInt32(result)) {
277 TELEPHONY_LOGE("writing parcel failed");
278 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
279 }
280 return TELEPHONY_SUCCESS;
281 }
282
OnUpdateOttCallRequest(MessageParcel & data,MessageParcel & reply)283 int32_t CallAbilityCallbackStub::OnUpdateOttCallRequest(MessageParcel &data, MessageParcel &reply)
284 {
285 int32_t result = TELEPHONY_SUCCESS;
286 AppExecFwk::PacMap resultInfo;
287 OttCallRequestId requestId = static_cast<OttCallRequestId>(data.ReadInt32());
288 resultInfo.PutStringValue("phoneNumber", data.ReadString());
289 resultInfo.PutStringValue("bundleName", data.ReadString());
290 resultInfo.PutIntValue("videoState", data.ReadInt32());
291 switch (requestId) {
292 case OttCallRequestId::OTT_REQUEST_INVITE_TO_CONFERENCE:
293 resultInfo.PutStringValue("number", data.ReadString());
294 break;
295 case OttCallRequestId::OTT_REQUEST_UPDATE_CALL_MEDIA_MODE:
296 resultInfo.PutIntValue("callMediaMode", data.ReadInt32());
297 break;
298 default:
299 break;
300 }
301 if (!data.ContainFileDescriptors()) {
302 TELEPHONY_LOGW("sent raw data is less than 32k");
303 }
304 result = OnOttCallRequest(requestId, resultInfo);
305 if (!reply.WriteInt32(result)) {
306 TELEPHONY_LOGE("writing parcel failed");
307 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
308 }
309 return TELEPHONY_SUCCESS;
310 }
311
OnUpdatePostDialDelay(MessageParcel & data,MessageParcel & reply)312 int32_t CallAbilityCallbackStub::OnUpdatePostDialDelay(MessageParcel &data, MessageParcel &reply)
313 {
314 std::string remainPostDial = data.ReadString();
315 int32_t result = OnReportPostDialDelay(remainPostDial);
316 if (!reply.WriteInt32(result)) {
317 TELEPHONY_LOGE("writing parcel failed");
318 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
319 }
320 return TELEPHONY_SUCCESS;
321 }
322
OnUpdateImsCallModeChange(MessageParcel & data,MessageParcel & reply)323 int32_t CallAbilityCallbackStub::OnUpdateImsCallModeChange(MessageParcel &data, MessageParcel &reply)
324 {
325 int32_t result = TELEPHONY_SUCCESS;
326 const CallMediaModeInfo *parcelPtr = nullptr;
327 int32_t len = data.ReadInt32();
328 if (len <= 0 || len >= MAX_LEN) {
329 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
330 return TELEPHONY_ERR_ARGUMENT_INVALID;
331 }
332 if (!data.ContainFileDescriptors()) {
333 TELEPHONY_LOGW("sent raw data is less than 32k");
334 }
335 if ((parcelPtr = reinterpret_cast<const CallMediaModeInfo *>(data.ReadRawData(len))) == nullptr) {
336 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
337 return TELEPHONY_ERR_LOCAL_PTR_NULL;
338 }
339
340 result = OnReportImsCallModeChange(*parcelPtr);
341 if (!reply.WriteInt32(result)) {
342 TELEPHONY_LOGE("writing parcel failed");
343 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
344 }
345 return TELEPHONY_SUCCESS;
346 }
347
OnUpdateCallSessionEventChange(MessageParcel & data,MessageParcel & reply)348 int32_t CallAbilityCallbackStub::OnUpdateCallSessionEventChange(MessageParcel &data, MessageParcel &reply)
349 {
350 int32_t result = TELEPHONY_SUCCESS;
351 if (!data.ContainFileDescriptors()) {
352 TELEPHONY_LOGW("sent raw data is less than 32k");
353 }
354
355 const CallSessionEvent *parcelPtr = nullptr;
356 int32_t len = data.ReadInt32();
357 if (len <= 0 || len >= MAX_LEN) {
358 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
359 return TELEPHONY_ERR_ARGUMENT_INVALID;
360 }
361 if ((parcelPtr = reinterpret_cast<const CallSessionEvent *>(data.ReadRawData(len))) == nullptr) {
362 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
363 return TELEPHONY_ERR_LOCAL_PTR_NULL;
364 }
365
366 result = OnReportCallSessionEventChange(*parcelPtr);
367 if (!reply.WriteInt32(result)) {
368 TELEPHONY_LOGE("writing parcel failed");
369 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
370 }
371 return TELEPHONY_SUCCESS;
372 }
373
OnUpdatePeerDimensionsChange(MessageParcel & data,MessageParcel & reply)374 int32_t CallAbilityCallbackStub::OnUpdatePeerDimensionsChange(MessageParcel &data, MessageParcel &reply)
375 {
376 int32_t result = TELEPHONY_SUCCESS;
377 if (!data.ContainFileDescriptors()) {
378 TELEPHONY_LOGW("sent raw data is less than 32k");
379 }
380
381 const PeerDimensionsDetail *parcelPtr = nullptr;
382 int32_t len = data.ReadInt32();
383 if (len <= 0 || len >= MAX_LEN) {
384 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
385 return TELEPHONY_ERR_ARGUMENT_INVALID;
386 }
387 if ((parcelPtr = reinterpret_cast<const PeerDimensionsDetail *>(data.ReadRawData(len))) == nullptr) {
388 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
389 return TELEPHONY_ERR_LOCAL_PTR_NULL;
390 }
391
392 result = OnReportPeerDimensionsChange(*parcelPtr);
393 if (!reply.WriteInt32(result)) {
394 TELEPHONY_LOGE("writing parcel failed");
395 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
396 }
397 return TELEPHONY_SUCCESS;
398 }
399
OnUpdateCallDataUsageChange(MessageParcel & data,MessageParcel & reply)400 int32_t CallAbilityCallbackStub::OnUpdateCallDataUsageChange(MessageParcel &data, MessageParcel &reply)
401 {
402 int32_t result = TELEPHONY_SUCCESS;
403 if (!data.ContainFileDescriptors()) {
404 TELEPHONY_LOGW("sent raw data is less than 32k");
405 }
406
407 int64_t dataUsage = data.ReadInt64();
408 result = OnReportCallDataUsageChange(dataUsage);
409 if (!reply.WriteInt32(result)) {
410 TELEPHONY_LOGE("writing parcel failed");
411 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
412 }
413 return TELEPHONY_SUCCESS;
414 }
415
OnUpdateCameraCapabilities(MessageParcel & data,MessageParcel & reply)416 int32_t CallAbilityCallbackStub::OnUpdateCameraCapabilities(MessageParcel &data, MessageParcel &reply)
417 {
418 int32_t result = TELEPHONY_SUCCESS;
419 if (!data.ContainFileDescriptors()) {
420 TELEPHONY_LOGW("sent raw data is less than 32k");
421 }
422
423 const CameraCapabilities *parcelPtr = nullptr;
424 int32_t len = data.ReadInt32();
425 if (len <= 0 || len >= MAX_LEN) {
426 TELEPHONY_LOGE("Invalid parameter, len = %{public}d", len);
427 return TELEPHONY_ERR_ARGUMENT_INVALID;
428 }
429 if ((parcelPtr = reinterpret_cast<const CameraCapabilities *>(data.ReadRawData(len))) == nullptr) {
430 TELEPHONY_LOGE("reading raw data failed, length = %d", len);
431 return TELEPHONY_ERR_LOCAL_PTR_NULL;
432 }
433
434 result = OnReportCameraCapabilities(*parcelPtr);
435 if (!reply.WriteInt32(result)) {
436 TELEPHONY_LOGE("writing parcel failed");
437 return TELEPHONY_ERR_WRITE_REPLY_FAIL;
438 }
439 return TELEPHONY_SUCCESS;
440 }
441 } // namespace Telephony
442 } // namespace OHOS
443