1 /*
2 * Copyright (C) 2021 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 "napi_sms.h"
17 #include "napi_mms.h"
18 #include "delivery_callback.h"
19 #include "send_callback.h"
20 #include "sms_mms_errors.h"
21
22 namespace OHOS {
23 namespace Telephony {
24 namespace {
25 const std::string g_slotIdStr = "slotId";
26 const std::string g_destinationHostStr = "destinationHost";
27 const std::string g_serviceCenterStr = "serviceCenter";
28 const std::string g_contentStr = "content";
29 const std::string g_destinationPortStr = "destinationPort";
30 const std::string g_sendCallbackStr = "sendCallback";
31 const std::string g_deliveryCallbackStr = "deliveryCallback";
32 static const int32_t DEFAULT_REF_COUNT = 1;
33 static bool g_validPort = false;
34 } // namespace
35
SetPropertyArray(napi_env env,napi_value object,const std::string & name,std::vector<unsigned char> pdu)36 static void SetPropertyArray(napi_env env, napi_value object, const std::string &name, std::vector<unsigned char> pdu)
37 {
38 napi_value array = nullptr;
39 napi_create_array(env, &array);
40 size_t size = pdu.size();
41 for (size_t i = 0; i < size; i++) {
42 napi_value element = nullptr;
43 napi_create_int32(env, pdu[i], &element);
44 napi_set_element(env, array, i, element);
45 }
46 napi_set_named_property(env, object, name.c_str(), array);
47 }
48
WrapSimMessageStatus(int32_t status)49 static int32_t WrapSimMessageStatus(int32_t status)
50 {
51 switch (status) {
52 case ShortMessage::SMS_SIM_MESSAGE_STATUS_UNREAD: {
53 return static_cast<int32_t>(ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD);
54 }
55 case ShortMessage::SMS_SIM_MESSAGE_STATUS_READ: {
56 return static_cast<int32_t>(ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_READ);
57 }
58 case ShortMessage::SMS_SIM_MESSAGE_STATUS_UNSENT: {
59 return static_cast<int32_t>(ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNSENT);
60 }
61 case ShortMessage::SMS_SIM_MESSAGE_STATUS_SENT: {
62 return static_cast<int32_t>(ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
63 }
64 default: {
65 return MESSAGE_UNKNOWN_STATUS;
66 }
67 }
68 }
69
GetDefaultSmsSlotId()70 static int32_t GetDefaultSmsSlotId()
71 {
72 return DEFAULT_SIM_SLOT_ID;
73 }
74
IsValidSlotId(int32_t slotId)75 static inline bool IsValidSlotId(int32_t slotId)
76 {
77 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
78 }
79
MatchObjectProperty(napi_env env,napi_value object,std::initializer_list<std::pair<std::string,napi_valuetype>> pairList)80 static bool MatchObjectProperty(
81 napi_env env, napi_value object, std::initializer_list<std::pair<std::string, napi_valuetype>> pairList)
82 {
83 if (object == nullptr) {
84 TELEPHONY_LOGI("MatchObjectProperty object == nullptr");
85 return false;
86 }
87 for (auto beg = pairList.begin(); beg != pairList.end(); ++beg) {
88 if (!NapiUtil::HasNamedTypeProperty(env, object, beg->second, beg->first)) {
89 TELEPHONY_LOGI("MatchObjectProperty match failed!");
90 return false;
91 }
92 }
93 return true;
94 }
95
Get64StringFromValue(napi_env env,napi_value value)96 static std::string Get64StringFromValue(napi_env env, napi_value value)
97 {
98 char msgChars[MAX_TEXT_SHORT_MESSAGE_LENGTH] = {0};
99 size_t strLength = 0;
100 napi_get_value_string_utf8(env, value, msgChars, MAX_TEXT_SHORT_MESSAGE_LENGTH, &strLength);
101 TELEPHONY_LOGI("Get64StringFromValue strLength = %{public}zu", strLength);
102 if (strLength > 0) {
103 return std::string(msgChars, 0, strLength);
104 } else {
105 return "";
106 }
107 }
108
GetU16StrFromNapiValue(napi_env env,napi_value value)109 static std::u16string GetU16StrFromNapiValue(napi_env env, napi_value value)
110 {
111 char strChars[PROPERTY_NAME_SIZE] = {0};
112 size_t strLength = 0;
113 napi_get_value_string_utf8(env, value, strChars, BUFF_LENGTH, &strLength);
114 std::string str8(strChars, strLength);
115 return NapiUtil::ToUtf16(str8);
116 }
117
InValidSlotIdOrInValidPort(int32_t slotId,uint16_t port)118 static bool InValidSlotIdOrInValidPort(int32_t slotId, uint16_t port)
119 {
120 if (!IsValidSlotId(slotId)) {
121 TELEPHONY_LOGE("InValidSlotIdOrInValidPort invalid slotid");
122 return true;
123 }
124
125 if (!g_validPort) {
126 TELEPHONY_LOGE("InValidSlotIdOrInValidPort invalid port");
127 return true;
128 }
129 g_validPort = false;
130 return false;
131 }
132
ActuallySendTextMessage(SendMessageContext & parameter,std::unique_ptr<SendCallback> sendCallback,std::unique_ptr<DeliveryCallback> deliveryCallback)133 static int32_t ActuallySendTextMessage(SendMessageContext ¶meter, std::unique_ptr<SendCallback> sendCallback,
134 std::unique_ptr<DeliveryCallback> deliveryCallback)
135 {
136 if (!IsValidSlotId(parameter.slotId)) {
137 auto result = ISendShortMessageCallback::SmsSendResult::SEND_SMS_FAILURE_UNKNOWN;
138 sendCallback.release()->OnSmsSendResult(result);
139 deliveryCallback.release()->OnSmsDeliveryResult(u"");
140 return TELEPHONY_ERR_SLOTID_INVALID;
141 }
142 return DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(parameter.slotId,
143 parameter.destinationHost, parameter.serviceCenter, parameter.textContent, sendCallback.release(),
144 deliveryCallback.release());
145 }
146
ActuallySendDataMessage(SendMessageContext & parameter,std::unique_ptr<SendCallback> sendCallback,std::unique_ptr<DeliveryCallback> deliveryCallback)147 static int32_t ActuallySendDataMessage(SendMessageContext ¶meter, std::unique_ptr<SendCallback> sendCallback,
148 std::unique_ptr<DeliveryCallback> deliveryCallback)
149 {
150 if (InValidSlotIdOrInValidPort(parameter.slotId, parameter.destinationPort)) {
151 auto result = ISendShortMessageCallback::SmsSendResult::SEND_SMS_FAILURE_UNKNOWN;
152 sendCallback.release()->OnSmsSendResult(result);
153 deliveryCallback.release()->OnSmsDeliveryResult(u"");
154 return TELEPHONY_ERR_SLOTID_INVALID;
155 }
156 if (parameter.rawDataContent.size() > 0) {
157 uint16_t arrayLength = static_cast<uint16_t>(parameter.rawDataContent.size());
158 return DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(parameter.slotId,
159 parameter.destinationHost, parameter.serviceCenter, parameter.destinationPort, ¶meter.rawDataContent[0],
160 arrayLength, sendCallback.release(), deliveryCallback.release());
161 }
162 return TELEPHONY_ERR_ARGUMENT_INVALID;
163 }
164
ActuallySendMessage(napi_env env,SendMessageContext & parameter)165 static int32_t ActuallySendMessage(napi_env env, SendMessageContext ¶meter)
166 {
167 bool hasSendCallback = parameter.sendCallbackRef != nullptr;
168 std::unique_ptr<SendCallback> sendCallback =
169 std::make_unique<SendCallback>(hasSendCallback, env, parameter.thisVarRef, parameter.sendCallbackRef);
170 if (sendCallback == nullptr) {
171 TELEPHONY_LOGE("ActuallySendMessage sendCallback == nullptr");
172 return TELEPHONY_ERR_LOCAL_PTR_NULL;
173 }
174 bool hasDeliveryCallback = parameter.deliveryCallbackRef != nullptr;
175 std::unique_ptr<DeliveryCallback> deliveryCallback = std::make_unique<DeliveryCallback>(
176 hasDeliveryCallback, env, parameter.thisVarRef, parameter.deliveryCallbackRef);
177 if (deliveryCallback == nullptr) {
178 TELEPHONY_LOGE("ActuallySendMessage deliveryCallback == nullptr");
179 return TELEPHONY_ERR_LOCAL_PTR_NULL;
180 }
181 if (parameter.messageType == TEXT_MESSAGE_PARAMETER_MATCH) {
182 return ActuallySendTextMessage(parameter, std::move(sendCallback), std::move(deliveryCallback));
183 } else if (parameter.messageType == RAW_DATA_MESSAGE_PARAMETER_MATCH) {
184 return ActuallySendDataMessage(parameter, std::move(sendCallback), std::move(deliveryCallback));
185 }
186 return TELEPHONY_ERR_ARGUMENT_INVALID;
187 }
188
NativeSendMessage(napi_env env,void * data)189 static void NativeSendMessage(napi_env env, void *data)
190 {
191 auto asyncContext = static_cast<SendMessageContext *>(data);
192 if (asyncContext == nullptr) {
193 TELEPHONY_LOGE("NativeSendMessage SendMessageContext is nullptr.");
194 return;
195 }
196 asyncContext->errorCode = ActuallySendMessage(env, *asyncContext);
197 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
198 asyncContext->resolved = true;
199 }
200 TELEPHONY_LOGI("NativeSendMessage end resolved = %{public}d", asyncContext->resolved);
201 }
202
SendMessageCallback(napi_env env,napi_status status,void * data)203 static void SendMessageCallback(napi_env env, napi_status status, void *data)
204 {
205 auto asyncContext = static_cast<SendMessageContext *>(data);
206 napi_value callbackValue = nullptr;
207 if (asyncContext->resolved) {
208 napi_get_undefined(env, &callbackValue);
209 } else {
210 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
211 asyncContext->errorCode, "sendMessage", "ohos.permission.SEND_MESSAGES");
212 TELEPHONY_LOGI("asyncContext->errorCode:%{public}d.", error.errorCode);
213 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
214 }
215 NapiUtil::Handle1ValueCallback(env, asyncContext, callbackValue);
216 }
217
MatchSendMessageParameters(napi_env env,napi_value parameters[],size_t parameterCount)218 static int32_t MatchSendMessageParameters(napi_env env, napi_value parameters[], size_t parameterCount)
219 {
220 bool match = (parameterCount == 1) && NapiUtil::MatchParameters(env, parameters, {napi_object});
221 if (!match) {
222 return MESSAGE_PARAMETER_NOT_MATCH;
223 }
224 napi_value object = parameters[0];
225 bool hasSlotId = NapiUtil::HasNamedTypeProperty(env, object, napi_number, g_slotIdStr);
226 bool hasDestinationHost = NapiUtil::HasNamedTypeProperty(env, object, napi_string, g_destinationHostStr);
227 bool hasContent = NapiUtil::HasNamedProperty(env, object, g_contentStr);
228 bool hasNecessaryParameter = hasSlotId && hasDestinationHost && hasContent;
229 if (!hasNecessaryParameter) {
230 return MESSAGE_PARAMETER_NOT_MATCH;
231 }
232 napi_value contentValue = NapiUtil::GetNamedProperty(env, object, g_contentStr);
233 bool contentIsStr = NapiUtil::MatchValueType(env, contentValue, napi_string);
234 bool contentIsObj = NapiUtil::MatchValueType(env, contentValue, napi_object);
235 bool contentIsArray = false;
236 if (contentIsObj) {
237 napi_is_array(env, contentValue, &contentIsArray);
238 }
239 bool serviceCenterTypeMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_string, g_serviceCenterStr);
240 bool sendCallbackTypeMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_function, g_sendCallbackStr);
241 bool deliveryCallbackTypeMatch =
242 NapiUtil::MatchOptionPropertyType(env, object, napi_function, g_deliveryCallbackStr);
243 bool destindationPortMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_number, g_destinationPortStr);
244 if (contentIsStr && serviceCenterTypeMatch && sendCallbackTypeMatch && deliveryCallbackTypeMatch) {
245 return TEXT_MESSAGE_PARAMETER_MATCH;
246 } else if (contentIsArray && serviceCenterTypeMatch && sendCallbackTypeMatch && deliveryCallbackTypeMatch &&
247 destindationPortMatch) {
248 return RAW_DATA_MESSAGE_PARAMETER_MATCH;
249 }
250 return MESSAGE_PARAMETER_NOT_MATCH;
251 }
252
ParseMessageParameter(int32_t messageMatchResult,napi_env env,napi_value object,SendMessageContext & context)253 static void ParseMessageParameter(
254 int32_t messageMatchResult, napi_env env, napi_value object, SendMessageContext &context)
255 {
256 context.messageType = messageMatchResult;
257 context.slotId = GetDefaultSmsSlotId();
258 napi_value slotIdValue = nullptr;
259 napi_get_named_property(env, object, g_slotIdStr.data(), &slotIdValue);
260 napi_get_value_int32(env, slotIdValue, &context.slotId);
261 napi_value destinationHostValue = NapiUtil::GetNamedProperty(env, object, g_destinationHostStr);
262 context.destinationHost = GetU16StrFromNapiValue(env, destinationHostValue);
263 if (NapiUtil::HasNamedProperty(env, object, g_serviceCenterStr)) {
264 napi_value serviceCenterValue = NapiUtil::GetNamedProperty(env, object, g_serviceCenterStr);
265 context.serviceCenter = GetU16StrFromNapiValue(env, serviceCenterValue);
266 }
267 if (NapiUtil::HasNamedProperty(env, object, g_sendCallbackStr)) {
268 napi_value sendCallbackValue = NapiUtil::GetNamedProperty(env, object, g_sendCallbackStr);
269 napi_create_reference(env, sendCallbackValue, DEFAULT_REF_COUNT, &context.sendCallbackRef);
270 }
271 if (NapiUtil::HasNamedProperty(env, object, g_deliveryCallbackStr)) {
272 napi_value deliveryCallbackValue = NapiUtil::GetNamedProperty(env, object, g_deliveryCallbackStr);
273 napi_create_reference(env, deliveryCallbackValue, DEFAULT_REF_COUNT, &context.deliveryCallbackRef);
274 }
275 napi_value contentValue = NapiUtil::GetNamedProperty(env, object, g_contentStr);
276 if (messageMatchResult == TEXT_MESSAGE_PARAMETER_MATCH) {
277 char contentChars[MAX_TEXT_SHORT_MESSAGE_LENGTH] = {0};
278 size_t contentLength = 0;
279 napi_get_value_string_utf8(env, contentValue, contentChars, MAX_TEXT_SHORT_MESSAGE_LENGTH, &contentLength);
280 std::string text(contentChars, contentLength);
281 context.textContent = NapiUtil::ToUtf16(text);
282 }
283 if (messageMatchResult == RAW_DATA_MESSAGE_PARAMETER_MATCH) {
284 int32_t destinationPort = INVALID_PORT;
285 napi_value destinationPortValue = nullptr;
286 napi_get_named_property(env, object, g_destinationPortStr.data(), &destinationPortValue);
287 napi_get_value_int32(env, destinationPortValue, &destinationPort);
288 TELEPHONY_LOGI("SendMessage destinationPort: %{private}d", destinationPort);
289 if (destinationPort >= MIN_PORT && destinationPort <= MAX_PORT) {
290 g_validPort = true;
291 }
292 context.destinationPort = static_cast<uint16_t>(destinationPort);
293 napi_value elementValue = nullptr;
294 int32_t element = 0;
295 uint32_t valueArraySize = 0;
296 napi_get_array_length(env, contentValue, &valueArraySize);
297 auto arraySize = static_cast<int32_t>(valueArraySize);
298 for (int32_t i = 0; i < arraySize; i++) {
299 napi_get_element(env, contentValue, i, &elementValue);
300 napi_get_value_int32(env, elementValue, &element);
301 context.rawDataContent.push_back((uint8_t)element);
302 }
303 }
304 }
305
SendMessage(napi_env env,napi_callback_info info)306 static napi_value SendMessage(napi_env env, napi_callback_info info)
307 {
308 size_t parameterCount = 1;
309 napi_value parameters[1] = {0};
310 napi_value thisVar = nullptr;
311 void *data = nullptr;
312
313 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
314 int32_t messageMatchResult = MatchSendMessageParameters(env, parameters, parameterCount);
315 if (messageMatchResult == MESSAGE_PARAMETER_NOT_MATCH) {
316 TELEPHONY_LOGE("SendMessage parameter matching failed.");
317 NapiUtil::ThrowParameterError(env);
318 return nullptr;
319 }
320 auto asyncContext = std::make_unique<SendMessageContext>().release();
321 if (asyncContext == nullptr) {
322 TELEPHONY_LOGE("SendMessage SendMessageContext is nullptr.");
323 NapiUtil::ThrowParameterError(env);
324 return nullptr;
325 }
326 ParseMessageParameter(messageMatchResult, env, parameters[0], *asyncContext);
327 napi_create_reference(env, thisVar, DEFAULT_REF_COUNT, &asyncContext->thisVarRef);
328 napi_value resourceName = nullptr;
329 napi_create_string_utf8(env, "SendMessage", NAPI_AUTO_LENGTH, &resourceName);
330 napi_create_async_work(env, nullptr, resourceName, NativeSendMessage, SendMessageCallback,
331 (void *)asyncContext, &(asyncContext->work));
332 napi_queue_async_work_with_qos(env, asyncContext->work, napi_qos_default);
333 return NapiUtil::CreateUndefined(env);
334 }
335
MatchSendShortMessageParameters(napi_env env,napi_value parameters[],size_t parameterCount)336 static int32_t MatchSendShortMessageParameters(napi_env env, napi_value parameters[], size_t parameterCount)
337 {
338 bool match = false;
339 switch (parameterCount) {
340 case ONE_PARAMETER: {
341 match = NapiUtil::MatchParameters(env, parameters, { napi_object });
342 break;
343 }
344 case TWO_PARAMETERS: {
345 match = NapiUtil::MatchParameters(env, parameters, { napi_object, napi_function });
346 break;
347 }
348 default:
349 break;
350 }
351 if (!match) {
352 return MESSAGE_PARAMETER_NOT_MATCH;
353 }
354
355 napi_value object = parameters[0];
356 bool hasSlotId = NapiUtil::HasNamedTypeProperty(env, object, napi_number, g_slotIdStr);
357 bool hasDestinationHost = NapiUtil::HasNamedTypeProperty(env, object, napi_string, g_destinationHostStr);
358 bool hasContent = NapiUtil::HasNamedProperty(env, object, g_contentStr);
359 bool hasNecessaryParameter = hasSlotId && hasDestinationHost && hasContent;
360 if (!hasNecessaryParameter) {
361 return MESSAGE_PARAMETER_NOT_MATCH;
362 }
363 napi_value contentValue = NapiUtil::GetNamedProperty(env, object, g_contentStr);
364 bool contentIsStr = NapiUtil::MatchValueType(env, contentValue, napi_string);
365 bool contentIsObj = NapiUtil::MatchValueType(env, contentValue, napi_object);
366 bool contentIsArray = false;
367 if (contentIsObj) {
368 napi_is_array(env, contentValue, &contentIsArray);
369 }
370 bool serviceCenterTypeMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_string, g_serviceCenterStr);
371 bool sendCallbackTypeMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_function, g_sendCallbackStr);
372 bool deliveryCallbackTypeMatch =
373 NapiUtil::MatchOptionPropertyType(env, object, napi_function, g_deliveryCallbackStr);
374 bool destindationPortMatch = NapiUtil::MatchOptionPropertyType(env, object, napi_number, g_destinationPortStr);
375 if (contentIsStr && serviceCenterTypeMatch && sendCallbackTypeMatch && deliveryCallbackTypeMatch) {
376 return TEXT_MESSAGE_PARAMETER_MATCH;
377 } else if (contentIsArray && serviceCenterTypeMatch && sendCallbackTypeMatch && deliveryCallbackTypeMatch &&
378 destindationPortMatch) {
379 return RAW_DATA_MESSAGE_PARAMETER_MATCH;
380 }
381 return MESSAGE_PARAMETER_NOT_MATCH;
382 }
383
SendShortMessage(napi_env env,napi_callback_info info)384 static napi_value SendShortMessage(napi_env env, napi_callback_info info)
385 {
386 size_t parameterCount = TWO_PARAMETERS;
387 napi_value parameters[TWO_PARAMETERS] = { 0 };
388 napi_value thisVar = nullptr;
389 void *data = nullptr;
390
391 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
392 int32_t messageMatchResult = MatchSendShortMessageParameters(env, parameters, parameterCount);
393 if (messageMatchResult == MESSAGE_PARAMETER_NOT_MATCH) {
394 TELEPHONY_LOGE("SendShortMessage parameter matching failed.");
395 NapiUtil::ThrowParameterError(env);
396 return nullptr;
397 }
398 auto asyncContext = std::make_unique<SendMessageContext>().release();
399 if (asyncContext == nullptr) {
400 TELEPHONY_LOGE("SendMessage SendMessageContext is nullptr.");
401 NapiUtil::ThrowParameterError(env);
402 return nullptr;
403 }
404 ParseMessageParameter(messageMatchResult, env, parameters[0], *asyncContext);
405 napi_create_reference(env, thisVar, DEFAULT_REF_COUNT, &asyncContext->thisVarRef);
406
407 if (parameterCount == TWO_PARAMETERS) {
408 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef);
409 }
410 napi_value result =
411 NapiUtil::HandleAsyncWork(env, asyncContext, "SendShortMessage", NativeSendMessage, SendMessageCallback);
412 return result;
413 }
414
NativeCreateMessage(napi_env env,void * data)415 static void NativeCreateMessage(napi_env env, void *data)
416 {
417 auto asyncContext = static_cast<CreateMessageContext *>(data);
418 if (asyncContext->specification.empty() || asyncContext->pdu.empty()) {
419 asyncContext->errorCode = TELEPHONY_ERR_ARGUMENT_INVALID;
420 return;
421 }
422 TELEPHONY_LOGI("NativeCreateMessage before CreateMessage");
423 std::u16string specification16 = NapiUtil::ToUtf16(asyncContext->specification);
424 auto shortMessageObj = new ShortMessage();
425 asyncContext->errorCode = ShortMessage::CreateMessage(asyncContext->pdu, specification16, *shortMessageObj);
426 if (asyncContext->errorCode == TELEPHONY_ERR_SUCCESS) {
427 asyncContext->resolved = true;
428 asyncContext->shortMessage = shortMessageObj;
429 } else {
430 TELEPHONY_LOGI("NativeCreateMessage CreateMessage faied");
431 }
432 TELEPHONY_LOGI("NativeCreateMessage end");
433 }
434
CreateShortMessageValue(napi_env env,const ShortMessage & shortMessage)435 static napi_value CreateShortMessageValue(napi_env env, const ShortMessage &shortMessage)
436 {
437 napi_value object = nullptr;
438 napi_create_object(env, &object);
439 NapiUtil::SetPropertyStringUtf8(
440 env, object, "visibleMessageBody", NapiUtil::ToUtf8(shortMessage.GetVisibleMessageBody()));
441 NapiUtil::SetPropertyStringUtf8(
442 env, object, "visibleRawAddress", NapiUtil::ToUtf8(shortMessage.GetVisibleRawAddress()));
443 NapiUtil::SetPropertyInt32(env, object, "messageClass", shortMessage.GetMessageClass());
444 NapiUtil::SetPropertyInt32(env, object, "protocolId", shortMessage.GetProtocolId());
445 std::u16string smscAddress;
446 shortMessage.GetScAddress(smscAddress);
447 NapiUtil::SetPropertyStringUtf8(env, object, "scAddress", NapiUtil::ToUtf8(smscAddress));
448 NapiUtil::SetPropertyInt64(env, object, "scTimestamp", shortMessage.GetScTimestamp());
449 NapiUtil::SetPropertyBoolean(env, object, "isReplaceMessage", shortMessage.IsReplaceMessage());
450 NapiUtil::SetPropertyBoolean(env, object, "hasReplyPath", shortMessage.HasReplyPath());
451 SetPropertyArray(env, object, "pdu", shortMessage.GetPdu());
452 NapiUtil::SetPropertyInt32(env, object, "status", shortMessage.GetStatus());
453 NapiUtil::SetPropertyBoolean(env, object, "isSmsStatusReportMessage", shortMessage.IsSmsStatusReportMessage());
454 return object;
455 }
456
CreateMessageCallback(napi_env env,napi_status status,void * data)457 static void CreateMessageCallback(napi_env env, napi_status status, void *data)
458 {
459 auto asyncContext = static_cast<CreateMessageContext *>(data);
460 napi_value callbackValue = nullptr;
461 if (status == napi_ok) {
462 if (asyncContext->resolved) {
463 callbackValue = CreateShortMessageValue(env, *(asyncContext->shortMessage));
464 if (asyncContext->shortMessage != nullptr) {
465 delete asyncContext->shortMessage;
466 asyncContext->shortMessage = nullptr;
467 }
468 } else {
469 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
470 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
471 }
472 } else {
473 callbackValue = NapiUtil::CreateErrorMessage(
474 env, "create message error,cause napi_status = " + std::to_string(status));
475 }
476 if (asyncContext->pdu.capacity() != 0) {
477 std::vector<unsigned char>().swap(asyncContext->pdu);
478 }
479 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
480 }
481
MatchCreateMessageParameter(napi_env env,const napi_value parameters[],size_t parameterCount)482 static bool MatchCreateMessageParameter(napi_env env, const napi_value parameters[], size_t parameterCount)
483 {
484 bool typeMatch = false;
485 switch (parameterCount) {
486 case TWO_PARAMETERS: {
487 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object, napi_string});
488 break;
489 }
490 case THREE_PARAMETERS:
491 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object, napi_string, napi_function});
492 break;
493 default: {
494 return false;
495 }
496 }
497 if (typeMatch) {
498 bool isArray = false;
499 napi_is_array(env, parameters[0], &isArray);
500 return isArray;
501 }
502 return false;
503 }
504
CreateMessage(napi_env env,napi_callback_info info)505 static napi_value CreateMessage(napi_env env, napi_callback_info info)
506 {
507 size_t parameterCount = THREE_PARAMETERS;
508 napi_value parameters[THREE_PARAMETERS] = {0};
509 napi_value thisVar = nullptr;
510 void *data = nullptr;
511
512 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
513 if (!MatchCreateMessageParameter(env, parameters, parameterCount)) {
514 TELEPHONY_LOGE("CreateMessage parameter matching failed.");
515 NapiUtil::ThrowParameterError(env);
516 return nullptr;
517 }
518 auto asyncContext = std::make_unique<CreateMessageContext>().release();
519 if (asyncContext == nullptr) {
520 TELEPHONY_LOGE("CreateMessage CreateMessageContext is nullptr.");
521 NapiUtil::ThrowParameterError(env);
522 return nullptr;
523 }
524 asyncContext->specification = Get64StringFromValue(env, parameters[1]);
525 TELEPHONY_LOGI("CreateMessage specification = %s", asyncContext->specification.c_str());
526 uint32_t arrayLength = 0;
527 napi_get_array_length(env, parameters[0], &arrayLength);
528 napi_value elementValue = nullptr;
529 int32_t element = 0;
530 for (uint32_t i = 0; i < arrayLength; i++) {
531 napi_get_element(env, parameters[0], i, &elementValue);
532 napi_get_value_int32(env, elementValue, &element);
533 asyncContext->pdu.push_back((unsigned char)element);
534 }
535 TELEPHONY_LOGI("CreateMessage pdu size = %{private}zu", asyncContext->pdu.size());
536 if (parameterCount == THREE_PARAMETERS) {
537 napi_create_reference(env, parameters[2], DEFAULT_REF_COUNT, &(asyncContext->callbackRef));
538 }
539 return NapiUtil ::HandleAsyncWork(
540 env, asyncContext, "CreateMessage", NativeCreateMessage, CreateMessageCallback);
541 }
542
MatchSetDefaultSmsSlotIdParameters(napi_env env,const napi_value parameters[],size_t parameterCount)543 static bool MatchSetDefaultSmsSlotIdParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
544 {
545 switch (parameterCount) {
546 case ONE_PARAMETER: {
547 return NapiUtil::MatchParameters(env, parameters, {napi_number});
548 }
549 case TWO_PARAMETERS:
550 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_function});
551 default: {
552 return false;
553 }
554 }
555 }
556
NativeSetDefaultSmsSlotId(napi_env env,void * data)557 static void NativeSetDefaultSmsSlotId(napi_env env, void *data)
558 {
559 auto context = static_cast<SetDefaultSmsSlotIdContext *>(data);
560 if (!IsValidSlotId(context->slotId) && (context->slotId != DEFAULT_SIM_SLOT_ID_REMOVE)) {
561 TELEPHONY_LOGE("NativeSetDefaultSmsSlotId slotId is invalid");
562 context->errorCode = ERROR_SLOT_ID_INVALID;
563 return;
564 }
565 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetDefaultSmsSlotId(context->slotId);
566 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
567 context->resolved = true;
568 }
569 TELEPHONY_LOGI("NativeSetDefaultSmsSlotId end resolved = %{public}d", context->resolved);
570 }
571
SetDefaultSmsSlotIdCallback(napi_env env,napi_status status,void * data)572 static void SetDefaultSmsSlotIdCallback(napi_env env, napi_status status, void *data)
573 {
574 auto context = static_cast<SetDefaultSmsSlotIdContext *>(data);
575 TELEPHONY_LOGI("SetDefaultSmsSlotIdCallback status = %{public}d", status);
576 napi_value callbackValue = nullptr;
577 if (context->resolved) {
578 napi_get_undefined(env, &callbackValue);
579 } else {
580 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
581 context->errorCode, "setDefaultSmsSlotId", "ohos.permission.SET_TELEPHONY_STATE");
582 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
583 }
584 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
585 }
586
SetDefaultSmsSlotId(napi_env env,napi_callback_info info)587 static napi_value SetDefaultSmsSlotId(napi_env env, napi_callback_info info)
588 {
589 size_t parameterCount = TWO_PARAMETERS;
590 napi_value parameters[TWO_PARAMETERS] = {0};
591 napi_value thisVar = nullptr;
592 void *data = nullptr;
593
594 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
595 if (!MatchSetDefaultSmsSlotIdParameters(env, parameters, parameterCount)) {
596 TELEPHONY_LOGE("SetDefaultSmsSlotId parameter matching failed.");
597 NapiUtil::ThrowParameterError(env);
598 return nullptr;
599 }
600 auto context = std::make_unique<SetDefaultSmsSlotIdContext>().release();
601 if (context == nullptr) {
602 TELEPHONY_LOGE("SetDefaultSmsSlotId SetDefaultSmsSlotIdContext is nullptr.");
603 NapiUtil::ThrowParameterError(env);
604 return nullptr;
605 }
606 napi_get_value_int32(env, parameters[0], &context->slotId);
607 if (parameterCount == TWO_PARAMETERS) {
608 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
609 }
610 napi_value result = NapiUtil::HandleAsyncWork(
611 env, context, "SetDefaultSmsSlotId", NativeSetDefaultSmsSlotId, SetDefaultSmsSlotIdCallback);
612 return result;
613 }
614
MatchGetDefaultSmsSlotIdParameters(napi_env env,const napi_value parameters[],size_t parameterCount)615 static bool MatchGetDefaultSmsSlotIdParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
616 {
617 switch (parameterCount) {
618 case NONE_PARAMETER: {
619 return true;
620 }
621 case ONE_PARAMETER: {
622 return NapiUtil::MatchParameters(env, parameters, {napi_function});
623 }
624 default: {
625 return false;
626 }
627 }
628 }
629
NativeGetDefaultSmsSlotId(napi_env env,void * data)630 static void NativeGetDefaultSmsSlotId(napi_env env, void *data)
631 {
632 auto context = static_cast<GetDefaultSmsSlotIdContext *>(data);
633 context->defaultSmsSlotId = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetDefaultSmsSlotId();
634 TELEPHONY_LOGI("NativeGetDefaultSmsSlotId defaultSmsSlotId = %{public}d", context->defaultSmsSlotId);
635 if (context->defaultSmsSlotId >= SIM_SLOT_0) {
636 context->resolved = true;
637 } else {
638 context->resolved = false;
639 }
640 }
641
GetDefaultSmsSlotIdCallback(napi_env env,napi_status status,void * data)642 static void GetDefaultSmsSlotIdCallback(napi_env env, napi_status status, void *data)
643 {
644 auto context = static_cast<GetDefaultSmsSlotIdContext *>(data);
645 napi_value callbackValue = nullptr;
646 if (status == napi_ok) {
647 if (context->resolved) {
648 napi_create_int32(env, context->defaultSmsSlotId, &callbackValue);
649 } else {
650 callbackValue = NapiUtil::CreateErrorMessage(env, "get default sms slot id error");
651 }
652 } else {
653 callbackValue = NapiUtil::CreateErrorMessage(
654 env, "get default sms slot id error cause napi_status = " + std::to_string(status));
655 }
656 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
657 }
658
GetDefaultSmsSlotId(napi_env env,napi_callback_info info)659 static napi_value GetDefaultSmsSlotId(napi_env env, napi_callback_info info)
660 {
661 size_t parameterCount = 1;
662 napi_value parameters[1] = {0};
663 napi_value thisVar = nullptr;
664 void *data = nullptr;
665
666 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
667 NAPI_ASSERT(env, MatchGetDefaultSmsSlotIdParameters(env, parameters, parameterCount), "type mismatch");
668 auto context = std::make_unique<GetDefaultSmsSlotIdContext>().release();
669 if (context == nullptr) {
670 std::string errorCode = std::to_string(napi_generic_failure);
671 std::string errorMessage = "error at GetDefaultSmsSlotIdContext is nullptr";
672 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
673 return nullptr;
674 }
675 napi_status statusValue = napi_get_value_int32(env, parameters[0], &context->defaultSmsSlotId);
676 TELEPHONY_LOGI("GetDefaultSmsSlotId statusValue = %{private}d", statusValue);
677 if (parameterCount == 1) {
678 napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &context->callbackRef);
679 }
680 return NapiUtil::HandleAsyncWork(
681 env, context, "SetDefaultSmsSlotId", NativeGetDefaultSmsSlotId, GetDefaultSmsSlotIdCallback);
682 }
683
NativeGetDefaultSmsSimId(napi_env env,void * data)684 static void NativeGetDefaultSmsSimId(napi_env env, void *data)
685 {
686 auto context = static_cast<GetDefaultSmsSimIdContext *>(data);
687 int32_t simId = 0;
688 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetDefaultSmsSimId(simId);
689 TELEPHONY_LOGI("result = %{public}d", context->errorCode);
690 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
691 context->defaultSmsSimId = simId;
692 context->resolved = true;
693 } else {
694 context->resolved = false;
695 }
696 }
697
GetDefaultSmsSimIdCallback(napi_env env,napi_status status,void * data)698 static void GetDefaultSmsSimIdCallback(napi_env env, napi_status status, void *data)
699 {
700 auto context = static_cast<GetDefaultSmsSimIdContext *>(data);
701 napi_value callbackValue = nullptr;
702 if (status == napi_ok) {
703 if (context->resolved) {
704 napi_create_int32(env, context->defaultSmsSimId, &callbackValue);
705 } else {
706 JsError error = NapiUtil::ConverErrorMessageForJs(context->errorCode);
707 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
708 }
709 } else {
710 callbackValue = NapiUtil::CreateErrorMessage(
711 env, "get default sms sim id error cause napi_status = " + std::to_string(status));
712 }
713 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
714 }
715
GetDefaultSmsSimId(napi_env env,napi_callback_info info)716 static napi_value GetDefaultSmsSimId(napi_env env, napi_callback_info info)
717 {
718 size_t parameterCount = 1;
719 napi_value parameters[1] = { 0 };
720 napi_value thisVar = nullptr;
721 void *data = nullptr;
722
723 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
724 if (!MatchGetDefaultSmsSlotIdParameters(env, parameters, parameterCount)) {
725 NapiUtil::ThrowParameterError(env);
726 return nullptr;
727 }
728 auto context = std::make_unique<GetDefaultSmsSimIdContext>().release();
729 if (context == nullptr) {
730 NapiUtil::ThrowParameterError(env);
731 return nullptr;
732 }
733 napi_status statusValue = napi_get_value_int32(env, parameters[0], &context->defaultSmsSimId);
734 TELEPHONY_LOGI("statusValue = %{private}d", statusValue);
735 if (parameterCount == 1) {
736 napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &context->callbackRef);
737 }
738 return NapiUtil::HandleAsyncWork(
739 env, context, "GetDefaultSmsSimId", NativeGetDefaultSmsSimId, GetDefaultSmsSimIdCallback);
740 }
741
MatchSetSmscAddrParameters(napi_env env,const napi_value parameters[],size_t parameterCount)742 static bool MatchSetSmscAddrParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
743 {
744 switch (parameterCount) {
745 case TWO_PARAMETERS: {
746 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_string});
747 }
748 case THREE_PARAMETERS: {
749 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_string, napi_function});
750 }
751 default: {
752 return false;
753 }
754 }
755 }
756
NativeSetSmscAddr(napi_env env,void * data)757 static void NativeSetSmscAddr(napi_env env, void *data)
758 {
759 auto context = static_cast<SetSmscAddrContext *>(data);
760 if (!IsValidSlotId(context->slotId)) {
761 TELEPHONY_LOGE("NativeSetSmscAddr slotId is invalid");
762 context->errorCode = ERROR_SLOT_ID_INVALID;
763 return;
764 }
765 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetScAddress(context->slotId,
766 NapiUtil::ToUtf16(context->smscAddr));
767 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
768 context->resolved = true;
769 }
770 TELEPHONY_LOGI("NativeSetSmscAddr resolved = %{public}d", context->resolved);
771 }
772
SetSmscAddrCallback(napi_env env,napi_status status,void * data)773 static void SetSmscAddrCallback(napi_env env, napi_status status, void *data)
774 {
775 auto context = static_cast<SetSmscAddrContext *>(data);
776 napi_value callbackValue = nullptr;
777 if (context->resolved) {
778 napi_get_undefined(env, &callbackValue);
779 } else {
780 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
781 context->errorCode, "setSmscAddr", "ohos.permission.SET_TELEPHONY_STATE");
782 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
783 }
784 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
785 }
786
SetSmscAddr(napi_env env,napi_callback_info info)787 static napi_value SetSmscAddr(napi_env env, napi_callback_info info)
788 {
789 size_t parameterCount = THREE_PARAMETERS;
790 napi_value parameters[THREE_PARAMETERS] = {0};
791 napi_value thisVar = nullptr;
792 void *data = nullptr;
793
794 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
795 if (!MatchSetSmscAddrParameters(env, parameters, parameterCount)) {
796 TELEPHONY_LOGE("SetSmscAddr parameter matching failed.");
797 NapiUtil::ThrowParameterError(env);
798 return nullptr;
799 }
800 TELEPHONY_LOGI("SetSmscAddr start after MatchSetSmscAddrParameters");
801 auto context = std::make_unique<SetSmscAddrContext>().release();
802 if (context == nullptr) {
803 TELEPHONY_LOGE("SetSmscAddr SetSmscAddrContext is nullptr.");
804 NapiUtil::ThrowParameterError(env);
805 return nullptr;
806 }
807 TELEPHONY_LOGI("SetSmscAddr start after SetSmscAddrContext contruct");
808 napi_get_value_int32(env, parameters[0], &context->slotId);
809 context->smscAddr = Get64StringFromValue(env, parameters[1]);
810 TELEPHONY_LOGI("SetSmscAddr smscAddr = %{private}s", context->smscAddr.data());
811 if (parameterCount == THREE_PARAMETERS) {
812 napi_create_reference(env, parameters[2], DEFAULT_REF_COUNT, &context->callbackRef);
813 }
814 TELEPHONY_LOGI("SetSmscAddr before end");
815 return NapiUtil::HandleAsyncWork(env, context, "SetSmscAddr", NativeSetSmscAddr, SetSmscAddrCallback);
816 }
817
MatchGetSmscAddrParameters(napi_env env,const napi_value parameters[],size_t parameterCount)818 static bool MatchGetSmscAddrParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
819 {
820 switch (parameterCount) {
821 case ONE_PARAMETER: {
822 return NapiUtil::MatchParameters(env, parameters, {napi_number});
823 }
824 case TWO_PARAMETERS: {
825 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_function});
826 }
827 default: {
828 return false;
829 }
830 }
831 }
832
NativeGetSmscAddr(napi_env env,void * data)833 static void NativeGetSmscAddr(napi_env env, void *data)
834 {
835 auto context = static_cast<GetSmscAddrContext *>(data);
836 if (!IsValidSlotId(context->slotId)) {
837 TELEPHONY_LOGE("NativeGetSmscAddr slotId is invalid");
838 context->errorCode = ERROR_SLOT_ID_INVALID;
839 return;
840 }
841 std::u16string smscAddress;
842 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->
843 GetScAddress(context->slotId, smscAddress);
844 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
845 context->smscAddr = NapiUtil::ToUtf8(smscAddress);
846 context->resolved = true;
847 TELEPHONY_LOGI("NativeGetSmscAddr smscAddr = %{private}s", context->smscAddr.data());
848 }
849 TELEPHONY_LOGI("NativeGetSmscAddr resolved = %{public}d", context->resolved);
850 }
851
GetSmscAddrCallback(napi_env env,napi_status status,void * data)852 static void GetSmscAddrCallback(napi_env env, napi_status status, void *data)
853 {
854 auto context = static_cast<GetSmscAddrContext *>(data);
855 napi_value callbackValue = nullptr;
856 if (context->resolved) {
857 napi_create_string_utf8(env, context->smscAddr.data(), context->smscAddr.length(), &callbackValue);
858 } else {
859 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
860 context->errorCode, "getSmscAddr", "ohos.permission.GET_TELEPHONY_STATE");
861 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
862 }
863 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
864 }
865
GetSmscAddr(napi_env env,napi_callback_info info)866 static napi_value GetSmscAddr(napi_env env, napi_callback_info info)
867 {
868 size_t parameterCount = TWO_PARAMETERS;
869 napi_value parameters[TWO_PARAMETERS] = {0};
870 napi_value thisVar = nullptr;
871 void *data = nullptr;
872
873 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
874 if (!MatchGetSmscAddrParameters(env, parameters, parameterCount)) {
875 TELEPHONY_LOGE("GetSmscAddr parameter matching failed.");
876 NapiUtil::ThrowParameterError(env);
877 return nullptr;
878 }
879 auto context = std::make_unique<GetSmscAddrContext>().release();
880 if (context == nullptr) {
881 TELEPHONY_LOGE("GetSmscAddr GetSmscAddrContext is nullptr.");
882 NapiUtil::ThrowParameterError(env);
883 return nullptr;
884 }
885 napi_get_value_int32(env, parameters[0], &context->slotId);
886 if (parameterCount == TWO_PARAMETERS) {
887 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
888 }
889 return NapiUtil::HandleAsyncWork(env, context, "GetSmscAddr", NativeGetSmscAddr, GetSmscAddrCallback);
890 }
891
MatchAddSimMessageParameters(napi_env env,const napi_value parameters[],size_t parameterCount)892 static bool MatchAddSimMessageParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
893 {
894 bool typeMatch = false;
895 switch (parameterCount) {
896 case ONE_PARAMETER: {
897 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object});
898 break;
899 }
900 case TWO_PARAMETERS: {
901 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object, napi_function});
902 break;
903 }
904 default: {
905 break;
906 }
907 }
908 if (typeMatch) {
909 return MatchObjectProperty(env, parameters[0],
910 {
911 {"slotId", napi_number},
912 {"smsc", napi_string},
913 {"status", napi_number},
914 {"pdu", napi_string},
915 });
916 }
917 return false;
918 }
919
NativeAddSimMessage(napi_env env,void * data)920 static void NativeAddSimMessage(napi_env env, void *data)
921 {
922 auto context = static_cast<AddSimMessageContext *>(data);
923 int32_t wrapStatus = static_cast<int32_t>(context->status);
924 TELEPHONY_LOGI("NativeAddSimMessage start wrapStatus = %{public}d", wrapStatus);
925 if (wrapStatus != MESSAGE_UNKNOWN_STATUS) {
926 ISmsServiceInterface::SimMessageStatus status =
927 static_cast<ISmsServiceInterface::SimMessageStatus>(wrapStatus);
928 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->AddSimMessage(
929 context->slotId, NapiUtil::ToUtf16(context->smsc), NapiUtil::ToUtf16(context->pdu), status);
930 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
931 context->resolved = true;
932 }
933 TELEPHONY_LOGI("NativeAddSimMessage context->resolved = %{public}d", context->resolved);
934 } else {
935 context->errorCode = SMS_MMS_UNKNOWN_SIM_MESSAGE_STATUS;
936 }
937 }
938
AddSimMessageCallback(napi_env env,napi_status status,void * data)939 static void AddSimMessageCallback(napi_env env, napi_status status, void *data)
940 {
941 auto context = static_cast<AddSimMessageContext *>(data);
942 napi_value callbackValue = nullptr;
943 if (context->resolved) {
944 napi_get_undefined(env, &callbackValue);
945 } else {
946 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
947 context->errorCode, "addSimMessage", "ohos.permission.SEND_MESSAGES");
948 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
949 }
950 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
951 }
952
AddSimMessage(napi_env env,napi_callback_info info)953 static napi_value AddSimMessage(napi_env env, napi_callback_info info)
954 {
955 size_t parameterCount = TWO_PARAMETERS;
956 napi_value parameters[TWO_PARAMETERS] = {0};
957 napi_value thisVar = nullptr;
958 void *data = nullptr;
959
960 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
961 if (!MatchAddSimMessageParameters(env, parameters, parameterCount)) {
962 TELEPHONY_LOGE("AddSimMessage parameter matching failed.");
963 NapiUtil::ThrowParameterError(env);
964 return nullptr;
965 }
966 auto context = std::make_unique<AddSimMessageContext>().release();
967 if (context == nullptr) {
968 TELEPHONY_LOGE("AddSimMessage AddSimMessageContext is nullptr.");
969 NapiUtil::ThrowParameterError(env);
970 return nullptr;
971 }
972 napi_value slotIdValue = NapiUtil::GetNamedProperty(env, parameters[0], "slotId");
973 if (slotIdValue != nullptr) {
974 napi_get_value_int32(env, slotIdValue, &context->slotId);
975 }
976 napi_value smscValue = NapiUtil::GetNamedProperty(env, parameters[0], "smsc");
977 if (smscValue != nullptr) {
978 context->smsc = Get64StringFromValue(env, smscValue);
979 }
980 napi_value pduValue = NapiUtil::GetNamedProperty(env, parameters[0], "pdu");
981 if (pduValue != nullptr) {
982 context->pdu = NapiUtil::GetStringFromValue(env, pduValue);
983 }
984 napi_value statusValue = NapiUtil::GetNamedProperty(env, parameters[0], "status");
985 if (statusValue != nullptr) {
986 int32_t messageStatus = static_cast<int32_t>(MESSAGE_UNKNOWN_STATUS);
987 napi_get_value_int32(env, statusValue, &messageStatus);
988 context->status = WrapSimMessageStatus(messageStatus);
989 }
990 if (parameterCount == TWO_PARAMETERS) {
991 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
992 }
993 return NapiUtil::HandleAsyncWork(env, context, "AddSimMessage", NativeAddSimMessage, AddSimMessageCallback);
994 }
995
MatchDelSimMessageParameters(napi_env env,const napi_value parameters[],size_t parameterCount)996 static bool MatchDelSimMessageParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
997 {
998 switch (parameterCount) {
999 case TWO_PARAMETERS: {
1000 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_number});
1001 }
1002 case THREE_PARAMETERS: {
1003 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_number, napi_function});
1004 }
1005 default: {
1006 return false;
1007 }
1008 }
1009 }
NativeDelSimMessage(napi_env env,void * data)1010 static void NativeDelSimMessage(napi_env env, void *data)
1011 {
1012 auto context = static_cast<DelSimMessageContext *>(data);
1013 if (!IsValidSlotId(context->slotId)) {
1014 TELEPHONY_LOGE("NativeDelSimMessage slotId is invalid");
1015 context->errorCode = ERROR_SLOT_ID_INVALID;
1016 return;
1017 }
1018 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->DelSimMessage(context->slotId,
1019 context->msgIndex);
1020 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1021 context->resolved = true;
1022 }
1023 TELEPHONY_LOGI("NativeDelSimMessage resolved = %{public}d", context->resolved);
1024 }
1025
DelSimMessageCallback(napi_env env,napi_status status,void * data)1026 static void DelSimMessageCallback(napi_env env, napi_status status, void *data)
1027 {
1028 auto context = static_cast<DelSimMessageContext *>(data);
1029 napi_value callbackValue = nullptr;
1030 if (context->resolved) {
1031 napi_get_undefined(env, &callbackValue);
1032 } else {
1033 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1034 context->errorCode, "delSimMessage", "ohos.permission.SEND_MESSAGES");
1035 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1036 }
1037 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
1038 }
1039
DelSimMessage(napi_env env,napi_callback_info info)1040 static napi_value DelSimMessage(napi_env env, napi_callback_info info)
1041 {
1042 size_t parameterCount = 3;
1043 napi_value parameters[3] = {0};
1044 napi_value thisVar = nullptr;
1045 void *data = nullptr;
1046
1047 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1048 if (!MatchDelSimMessageParameters(env, parameters, parameterCount)) {
1049 TELEPHONY_LOGE("DelSimMessage parameter matching failed.");
1050 NapiUtil::ThrowParameterError(env);
1051 return nullptr;
1052 }
1053 auto context = std::make_unique<DelSimMessageContext>().release();
1054 if (context == nullptr) {
1055 TELEPHONY_LOGE("DelSimMessage DelSimMessageContext is nullptr.");
1056 NapiUtil::ThrowParameterError(env);
1057 return nullptr;
1058 }
1059 napi_get_value_int32(env, parameters[0], &context->slotId);
1060 napi_get_value_int32(env, parameters[1], &context->msgIndex);
1061 if (parameterCount == 3) {
1062 napi_create_reference(env, parameters[2], DEFAULT_REF_COUNT, &context->callbackRef);
1063 }
1064 return NapiUtil::HandleAsyncWork(env, context, "DelSimMessage", NativeDelSimMessage, DelSimMessageCallback);
1065 }
1066
MatchUpdateSimMessageParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1067 static bool MatchUpdateSimMessageParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1068 {
1069 bool typeMatch = false;
1070 switch (parameterCount) {
1071 case ONE_PARAMETER: {
1072 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object});
1073 break;
1074 }
1075 case TWO_PARAMETERS: {
1076 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object, napi_function});
1077 break;
1078 }
1079 default: {
1080 break;
1081 }
1082 }
1083 if (typeMatch) {
1084 bool propertyMatchResult = MatchObjectProperty(env, parameters[0],
1085 {
1086 {"slotId", napi_number},
1087 {"msgIndex", napi_number},
1088 {"newStatus", napi_number},
1089 {"pdu", napi_string},
1090 {"smsc", napi_string},
1091 });
1092 TELEPHONY_LOGI(
1093 "MatchUpdateSimMessageParameters start propertyMatchResult = %{public}d", propertyMatchResult);
1094 return propertyMatchResult;
1095 }
1096 TELEPHONY_LOGI("MatchUpdateSimMessageParameters end");
1097 return false;
1098 }
1099
NativeUpdateSimMessage(napi_env env,void * data)1100 static void NativeUpdateSimMessage(napi_env env, void *data)
1101 {
1102 auto context = static_cast<UpdateSimMessageContext *>(data);
1103 int32_t newStatus = static_cast<int32_t>(context->newStatus);
1104 TELEPHONY_LOGI("NativeUpdateSimMessage newStatus = %{public}d", newStatus);
1105 if (!context->pdu.empty() && (newStatus > -1)) {
1106 std::string msgPud(context->pdu.begin(), context->pdu.end());
1107 TELEPHONY_LOGD("NativeUpdateSimMessage msgPud = %{private}s", msgPud.c_str());
1108 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->UpdateSimMessage(context->slotId,
1109 context->msgIndex, static_cast<ISmsServiceInterface::SimMessageStatus>(context->newStatus),
1110 NapiUtil::ToUtf16(context->pdu), NapiUtil::ToUtf16(context->smsc));
1111 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1112 context->resolved = true;
1113 }
1114 } else {
1115 TELEPHONY_LOGI("NativeUpdateSimMessage resolved false cause parameter invalided");
1116 context->errorCode = SMS_MMS_UNKNOWN_SIM_MESSAGE_STATUS;
1117 }
1118 }
1119
UpdateSimMessageCallback(napi_env env,napi_status status,void * data)1120 static void UpdateSimMessageCallback(napi_env env, napi_status status, void *data)
1121 {
1122 auto context = static_cast<UpdateSimMessageContext *>(data);
1123 napi_value callbackValue = nullptr;
1124 if (context->resolved) {
1125 napi_get_undefined(env, &callbackValue);
1126 } else {
1127 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1128 context->errorCode, "updateSimMessage", "ohos.permission.SEND_MESSAGES");
1129 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1130 }
1131 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
1132 }
1133
UpdateSimMessage(napi_env env,napi_callback_info info)1134 static napi_value UpdateSimMessage(napi_env env, napi_callback_info info)
1135 {
1136 size_t parameterCount = TWO_PARAMETERS;
1137 napi_value parameters[TWO_PARAMETERS] = {0};
1138 napi_value thisVar = nullptr;
1139 void *data = nullptr;
1140
1141 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1142 if (!MatchUpdateSimMessageParameters(env, parameters, parameterCount)) {
1143 TELEPHONY_LOGE("UpdateSimMessage parameter matching failed.");
1144 NapiUtil::ThrowParameterError(env);
1145 return nullptr;
1146 }
1147 TELEPHONY_LOGI("UpdateSimMessage start parameter match passed");
1148 auto context = std::make_unique<UpdateSimMessageContext>().release();
1149 if (context == nullptr) {
1150 TELEPHONY_LOGE("UpdateSimMessage UpdateSimMessageContext is nullptr.");
1151 NapiUtil::ThrowParameterError(env);
1152 return nullptr;
1153 }
1154 napi_value slotIdValue = NapiUtil::GetNamedProperty(env, parameters[0], "slotId");
1155 if (slotIdValue != nullptr) {
1156 napi_get_value_int32(env, slotIdValue, &context->slotId);
1157 }
1158 napi_value msgIndexValue = NapiUtil::GetNamedProperty(env, parameters[0], "msgIndex");
1159 if (msgIndexValue != nullptr) {
1160 napi_get_value_int32(env, msgIndexValue, &context->msgIndex);
1161 }
1162 napi_value newStatusValue = NapiUtil::GetNamedProperty(env, parameters[0], "newStatus");
1163 if (newStatusValue != nullptr) {
1164 int32_t newStatus = static_cast<int32_t>(MESSAGE_UNKNOWN_STATUS);
1165 napi_get_value_int32(env, newStatusValue, &newStatus);
1166 context->newStatus = WrapSimMessageStatus(newStatus);
1167 }
1168 napi_value pudValue = NapiUtil::GetNamedProperty(env, parameters[0], "pdu");
1169 if (pudValue != nullptr) {
1170 context->pdu = NapiUtil::GetStringFromValue(env, pudValue);
1171 }
1172 TELEPHONY_LOGD("UpdateSimMessage pdu = %{private}s", context->pdu.c_str());
1173 napi_value smscValue = NapiUtil::GetNamedProperty(env, parameters[0], "smsc");
1174 if (smscValue != nullptr) {
1175 context->smsc = Get64StringFromValue(env, smscValue);
1176 }
1177 if (parameterCount == TWO_PARAMETERS) {
1178 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
1179 }
1180 TELEPHONY_LOGI("UpdateSimMessage start before HandleAsyncWork");
1181 return NapiUtil::HandleAsyncWork(
1182 env, context, "UpdateSimMessage", NativeUpdateSimMessage, UpdateSimMessageCallback);
1183 }
1184
MatchGetAllSimMessagesParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1185 static bool MatchGetAllSimMessagesParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1186 {
1187 switch (parameterCount) {
1188 case ONE_PARAMETER: {
1189 return NapiUtil::MatchParameters(env, parameters, {napi_number});
1190 }
1191 case TWO_PARAMETERS: {
1192 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_function});
1193 }
1194 default: {
1195 return false;
1196 }
1197 }
1198 }
1199
NativeGetAllSimMessages(napi_env env,void * data)1200 static void NativeGetAllSimMessages(napi_env env, void *data)
1201 {
1202 auto context = static_cast<GetAllSimMessagesContext *>(data);
1203 if (!IsValidSlotId(context->slotId)) {
1204 TELEPHONY_LOGE("NativeGetAllSimMessages slotId is invalid");
1205 context->errorCode = ERROR_SLOT_ID_INVALID;
1206 return;
1207 }
1208 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->
1209 GetAllSimMessages(context->slotId, context->messageArray);
1210 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1211 context->resolved = true;
1212 } else {
1213 TELEPHONY_LOGE("NativeGetAllSimMessages context->resolved == false");
1214 }
1215 }
1216
CreateSimShortMessageValue(napi_env env,const ShortMessage & shortMessage)1217 static napi_value CreateSimShortMessageValue(napi_env env, const ShortMessage &shortMessage)
1218 {
1219 napi_value simObject = nullptr;
1220 napi_value object = CreateShortMessageValue(env, shortMessage);
1221 napi_create_object(env, &simObject);
1222 std::string shortMessageKey("shortMessage");
1223 napi_set_named_property(env, simObject, shortMessageKey.c_str(), object);
1224 NapiUtil::SetPropertyInt32(env, simObject, "simMessageStatus", shortMessage.GetIccMessageStatus());
1225 NapiUtil::SetPropertyInt32(env, simObject, "indexOnSim", shortMessage.GetIndexOnSim());
1226 return simObject;
1227 }
1228
GetAllSimMessagesCallback(napi_env env,napi_status status,void * data)1229 static void GetAllSimMessagesCallback(napi_env env, napi_status status, void *data)
1230 {
1231 auto context = static_cast<GetAllSimMessagesContext *>(data);
1232 napi_value callbackValue = nullptr;
1233 if (context->resolved) {
1234 napi_create_array(env, &callbackValue);
1235 int32_t arraySize = static_cast<int32_t>(context->messageArray.size());
1236 for (int32_t i = 0; i < arraySize; i++) {
1237 ShortMessage message = context->messageArray[i];
1238 napi_value itemValue = CreateSimShortMessageValue(env, message);
1239 napi_set_element(env, callbackValue, i, itemValue);
1240 }
1241 } else {
1242 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1243 context->errorCode, "getAllSimMessages", "ohos.permission.RECEIVE_SMS");
1244 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1245 }
1246 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1247 }
1248
GetAllSimMessages(napi_env env,napi_callback_info info)1249 static napi_value GetAllSimMessages(napi_env env, napi_callback_info info)
1250 {
1251 size_t parameterCount = TWO_PARAMETERS;
1252 napi_value parameters[TWO_PARAMETERS] = {0};
1253 napi_value thisVar = nullptr;
1254 void *data = nullptr;
1255
1256 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1257 if (!MatchGetAllSimMessagesParameters(env, parameters, parameterCount)) {
1258 TELEPHONY_LOGE("GetAllSimMessages parameter matching failed.");
1259 NapiUtil::ThrowParameterError(env);
1260 return nullptr;
1261 }
1262 auto context = std::make_unique<GetAllSimMessagesContext>().release();
1263 if (context == nullptr) {
1264 TELEPHONY_LOGE("GetAllSimMessages GetAllSimMessagesContext is nullptr.");
1265 NapiUtil::ThrowParameterError(env);
1266 return nullptr;
1267 }
1268 napi_get_value_int32(env, parameters[0], &context->slotId);
1269 if (parameterCount == TWO_PARAMETERS) {
1270 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
1271 }
1272 napi_value result = NapiUtil::HandleAsyncWork(
1273 env, context, "GetAllSimMessages", NativeGetAllSimMessages, GetAllSimMessagesCallback);
1274 return result;
1275 }
1276
MatchSetCBConfigParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1277 static bool MatchSetCBConfigParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1278 {
1279 bool typeMatch = false;
1280 switch (parameterCount) {
1281 case ONE_PARAMETER: {
1282 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object});
1283 break;
1284 }
1285 case TWO_PARAMETERS: {
1286 typeMatch = NapiUtil::MatchParameters(env, parameters, {napi_object, napi_function});
1287 break;
1288 }
1289 default: {
1290 break;
1291 }
1292 }
1293 if (typeMatch) {
1294 return MatchObjectProperty(env, parameters[0],
1295 {
1296 {"slotId", napi_number},
1297 {"enable", napi_boolean},
1298 {"startMessageId", napi_number},
1299 {"endMessageId", napi_number},
1300 {"ranType", napi_number},
1301 });
1302 }
1303 return false;
1304 }
1305
NativeSetCBConfig(napi_env env,void * data)1306 static void NativeSetCBConfig(napi_env env, void *data)
1307 {
1308 auto context = static_cast<CBConfigContext *>(data);
1309 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetCBConfig(
1310 context->slotId, context->enable, context->startMessageId, context->endMessageId, context->ranType);
1311 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1312 context->resolved = true;
1313 }
1314 TELEPHONY_LOGI("NativeSetCBConfig end resolved = %{public}d", context->resolved);
1315 }
1316
SetCBConfigCallback(napi_env env,napi_status status,void * data)1317 static void SetCBConfigCallback(napi_env env, napi_status status, void *data)
1318 {
1319 auto context = static_cast<CBConfigContext *>(data);
1320 napi_value callbackValue = nullptr;
1321 if (context->resolved) {
1322 napi_get_undefined(env, &callbackValue);
1323 } else {
1324 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1325 context->errorCode, "setCBConfig", "ohos.permission.RECEIVE_SMS");
1326 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1327 }
1328 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
1329 }
1330
SetCBConfig(napi_env env,napi_callback_info info)1331 static napi_value SetCBConfig(napi_env env, napi_callback_info info)
1332 {
1333 size_t parameterCount = TWO_PARAMETERS;
1334 napi_value parameters[TWO_PARAMETERS] = {0};
1335 napi_value thisVar = nullptr;
1336 void *data = nullptr;
1337
1338 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1339 if (!MatchSetCBConfigParameters(env, parameters, parameterCount)) {
1340 TELEPHONY_LOGE("SetCBConfig parameter matching failed.");
1341 NapiUtil::ThrowParameterError(env);
1342 return nullptr;
1343 }
1344 auto context = std::make_unique<CBConfigContext>().release();
1345 if (context == nullptr) {
1346 TELEPHONY_LOGE("SetCBConfig CBConfigContext is nullptr.");
1347 NapiUtil::ThrowParameterError(env);
1348 return nullptr;
1349 }
1350 napi_value slotIdValue = NapiUtil::GetNamedProperty(env, parameters[0], "slotId");
1351 if (slotIdValue != nullptr) {
1352 napi_get_value_int32(env, slotIdValue, &context->slotId);
1353 }
1354 napi_value enableValue = NapiUtil::GetNamedProperty(env, parameters[0], "enable");
1355 if (enableValue != nullptr) {
1356 napi_get_value_bool(env, enableValue, &context->enable);
1357 }
1358 napi_value startMessageIdValue = NapiUtil::GetNamedProperty(env, parameters[0], "startMessageId");
1359 if (startMessageIdValue != nullptr) {
1360 napi_get_value_int32(env, startMessageIdValue, &context->startMessageId);
1361 }
1362 napi_value endMessageIdValue = NapiUtil::GetNamedProperty(env, parameters[0], "endMessageId");
1363 if (endMessageIdValue != nullptr) {
1364 napi_get_value_int32(env, endMessageIdValue, &context->endMessageId);
1365 }
1366 napi_value ranTypeValue = NapiUtil::GetNamedProperty(env, parameters[0], "ranType");
1367 if (ranTypeValue != nullptr) {
1368 napi_get_value_int32(env, ranTypeValue, &context->ranType);
1369 }
1370 if (parameterCount == TWO_PARAMETERS) {
1371 napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &context->callbackRef);
1372 }
1373 napi_value result =
1374 NapiUtil::HandleAsyncWork(env, context, "SetCBConfig", NativeSetCBConfig, SetCBConfigCallback);
1375 return result;
1376 }
1377
MatchSplitMessageParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1378 static bool MatchSplitMessageParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1379 {
1380 switch (parameterCount) {
1381 case ONE_PARAMETER:
1382 return NapiUtil::MatchParameters(env, parameters, {napi_string});
1383 case TWO_PARAMETERS:
1384 return NapiUtil::MatchParameters(env, parameters, {napi_string, napi_function});
1385 default:
1386 return false;
1387 }
1388 }
1389
NativeSplitMessage(napi_env env,void * data)1390 static void NativeSplitMessage(napi_env env, void *data)
1391 {
1392 auto context = static_cast<SplitMessageContext *>(data);
1393 std::u16string content = NapiUtil::ToUtf16(context->content);
1394 context->errorCode =
1395 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SplitMessage(content, context->messageArray);
1396 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1397 context->resolved = true;
1398 }
1399 }
1400
SplitMessageCallback(napi_env env,napi_status status,void * data)1401 static void SplitMessageCallback(napi_env env, napi_status status, void *data)
1402 {
1403 auto context = static_cast<SplitMessageContext *>(data);
1404 napi_value callbackValue = nullptr;
1405 if (context->resolved) {
1406 napi_create_array(env, &callbackValue);
1407 int32_t arraySize = static_cast<int32_t>(context->messageArray.size());
1408 TELEPHONY_LOGI("napi_sms messageArray.size = %{public}d", arraySize);
1409 for (int32_t i = 0; i < arraySize; i++) {
1410 napi_value itemValue = nullptr;
1411 std::string message = NapiUtil::ToUtf8(context->messageArray[i]);
1412 napi_create_string_utf8(env, message.data(), message.size(), &itemValue);
1413 napi_set_element(env, callbackValue, i, itemValue);
1414 }
1415 } else {
1416 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1417 context->errorCode, "splitMessage", "ohos.permission.SEND_MESSAGES");
1418 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1419 }
1420 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1421 }
1422
SplitMessage(napi_env env,napi_callback_info info)1423 static napi_value SplitMessage(napi_env env, napi_callback_info info)
1424 {
1425 size_t parameterCount = TWO_PARAMETERS;
1426 napi_value parameters[TWO_PARAMETERS] = {0};
1427 napi_value thisVar = nullptr;
1428 void *data = nullptr;
1429
1430 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1431 if (!MatchSplitMessageParameters(env, parameters, parameterCount)) {
1432 TELEPHONY_LOGE("SplitMessage parameter matching failed.");
1433 NapiUtil::ThrowParameterError(env);
1434 return nullptr;
1435 }
1436 auto context = std::make_unique<SplitMessageContext>().release();
1437 if (context == nullptr) {
1438 TELEPHONY_LOGE("SplitMessage SplitMessageContext is nullptr.");
1439 NapiUtil::ThrowParameterError(env);
1440 return nullptr;
1441 }
1442 context->content = Get64StringFromValue(env, parameters[0]);
1443 TELEPHONY_LOGD("napi_sms splitMessage context->content = %{private}s", context->content.c_str());
1444 if (parameterCount == TWO_PARAMETERS) {
1445 napi_create_reference(env, parameters[1], MAX_TEXT_SHORT_MESSAGE_LENGTH, &context->callbackRef);
1446 }
1447 napi_value result =
1448 NapiUtil::HandleAsyncWork(env, context, "SplitMessage", NativeSplitMessage, SplitMessageCallback);
1449 return result;
1450 }
1451
HasSmsCapability(napi_env env,napi_callback_info info)1452 static napi_value HasSmsCapability(napi_env env, napi_callback_info info)
1453 {
1454 napi_value result = nullptr;
1455 napi_get_boolean(env, DelayedSingleton<SmsServiceManagerClient>::GetInstance()->HasSmsCapability(), &result);
1456 return result;
1457 }
1458
MatchGetSmsSegmentsInfoParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1459 static bool MatchGetSmsSegmentsInfoParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1460 {
1461 switch (parameterCount) {
1462 case THREE_PARAMETERS:
1463 return NapiUtil::MatchParameters(env, parameters, {napi_number, napi_string, napi_boolean});
1464 case FOUR_PARAMETERS:
1465 return NapiUtil::MatchParameters(
1466 env, parameters, {napi_number, napi_string, napi_boolean, napi_function});
1467 default:
1468 return false;
1469 }
1470 }
1471
NativeGetSmsSegmentsInfo(napi_env env,void * data)1472 static void NativeGetSmsSegmentsInfo(napi_env env, void *data)
1473 {
1474 auto context = static_cast<GetSmsSegmentsInfoContext *>(data);
1475 if (!IsValidSlotId(context->slotId)) {
1476 TELEPHONY_LOGE("NativeGetSmsSegmentsInfo slotId is invalid");
1477 context->errorCode = ERROR_SLOT_ID_INVALID;
1478 return;
1479 }
1480 std::u16string content = NapiUtil::ToUtf16(context->content);
1481 ISmsServiceInterface::SmsSegmentsInfo info;
1482 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetSmsSegmentsInfo(context->slotId,
1483 content, context->force7BitCode, info);
1484 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1485 context->resolved = true;
1486 context->splitCount = info.msgSegCount;
1487 context->encodeCount = info.msgEncodingCount;
1488 context->encodeCountRemaining = info.msgRemainCount;
1489 context->scheme = info.msgCodeScheme;
1490 } else {
1491 TELEPHONY_LOGE("NativeGetSmsSegmentsInfo context->resolved == false");
1492 }
1493 }
1494
GetSmsSegmentsInfoCallback(napi_env env,napi_status status,void * data)1495 static void GetSmsSegmentsInfoCallback(napi_env env, napi_status status, void *data)
1496 {
1497 auto context = static_cast<GetSmsSegmentsInfoContext *>(data);
1498 napi_value callbackValue = nullptr;
1499 if (context->resolved) {
1500 napi_create_object(env, &callbackValue);
1501 NapiUtil::SetPropertyInt32(env, callbackValue, "splitCount", context->splitCount);
1502 NapiUtil::SetPropertyInt32(env, callbackValue, "encodeCount", context->encodeCount);
1503 NapiUtil::SetPropertyInt32(env, callbackValue, "encodeCountRemaining", context->encodeCountRemaining);
1504 NapiUtil::SetPropertyInt32(env, callbackValue, "scheme", static_cast<int32_t>(context->scheme));
1505 } else {
1506 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1507 context->errorCode, "getSmsSegmentsInfo", "ohos.permission.GET_TELEPHONY_STATE");
1508 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1509 }
1510 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1511 }
1512
GetSmsSegmentsInfo(napi_env env,napi_callback_info info)1513 static napi_value GetSmsSegmentsInfo(napi_env env, napi_callback_info info)
1514 {
1515 size_t parameterCount = FOUR_PARAMETERS;
1516 napi_value parameters[FOUR_PARAMETERS] = { 0 };
1517 napi_value thisVar = nullptr;
1518 void *data = nullptr;
1519
1520 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1521 if (!MatchGetSmsSegmentsInfoParameters(env, parameters, parameterCount)) {
1522 TELEPHONY_LOGE("GetSmsSegmentsInfo parameter matching failed.");
1523 NapiUtil::ThrowParameterError(env);
1524 return nullptr;
1525 }
1526 auto context = std::make_unique<GetSmsSegmentsInfoContext>().release();
1527 if (context == nullptr) {
1528 TELEPHONY_LOGE("GetSmsSegmentsInfo context is nullptr.");
1529 NapiUtil::ThrowParameterError(env);
1530 return nullptr;
1531 }
1532 napi_get_value_int32(env, parameters[0], &context->slotId);
1533 context->content = NapiUtil::GetStringFromValue(env, parameters[1]);
1534 napi_get_value_bool(env, parameters[2], &context->force7BitCode);
1535 if (parameterCount == FOUR_PARAMETERS) {
1536 napi_create_reference(env, parameters[3], DEFAULT_REF_COUNT, &context->callbackRef);
1537 }
1538 napi_value result = NapiUtil::HandleAsyncWork(
1539 env, context, "GetSmsSegmentsInfo", NativeGetSmsSegmentsInfo, GetSmsSegmentsInfoCallback);
1540 return result;
1541 }
1542
MatchIsImsSmsSupportedParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1543 static bool MatchIsImsSmsSupportedParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1544 {
1545 switch (parameterCount) {
1546 case ONE_PARAMETER: {
1547 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1548 }
1549 case TWO_PARAMETERS: {
1550 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1551 }
1552 default: {
1553 return false;
1554 }
1555 }
1556 }
1557
NativeIsImsSmsSupported(napi_env env,void * data)1558 static void NativeIsImsSmsSupported(napi_env env, void *data)
1559 {
1560 auto context = static_cast<IsImsSmsSupportedContext *>(data);
1561 context->errorCode = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->IsImsSmsSupported(
1562 context->slotId, context->setResult);
1563 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1564 context->resolved = true;
1565 } else {
1566 TELEPHONY_LOGE("NativeIsImsSmsSupported context->resolved == false");
1567 }
1568 }
1569
IsImsSmsSupportedCallback(napi_env env,napi_status status,void * data)1570 static void IsImsSmsSupportedCallback(napi_env env, napi_status status, void *data)
1571 {
1572 auto context = static_cast<IsImsSmsSupportedContext *>(data);
1573 napi_value callbackValue = nullptr;
1574 if (context->resolved) {
1575 napi_get_boolean(env, context->setResult, &callbackValue);
1576 } else {
1577 JsError error = NapiUtil::ConverErrorMessageForJs(context->errorCode);
1578 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1579 }
1580 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1581 }
1582
IsImsSmsSupported(napi_env env,napi_callback_info info)1583 static napi_value IsImsSmsSupported(napi_env env, napi_callback_info info)
1584 {
1585 size_t paramsCount = TWO_PARAMETERS;
1586 napi_value params[TWO_PARAMETERS] = { 0 };
1587 napi_value arg = nullptr;
1588 void *data = nullptr;
1589
1590 napi_get_cb_info(env, info, ¶msCount, params, &arg, &data);
1591 if (!MatchIsImsSmsSupportedParameters(env, params, paramsCount)) {
1592 TELEPHONY_LOGE("IsImsSmsSupported parameter matching failed.");
1593 NapiUtil::ThrowParameterError(env);
1594 return nullptr;
1595 }
1596 auto context = std::make_unique<IsImsSmsSupportedContext>().release();
1597 if (context == nullptr) {
1598 TELEPHONY_LOGE("IsImsSmsSupported IsImsSmsSupportedContext is nullptr.");
1599 NapiUtil::ThrowParameterError(env);
1600 return nullptr;
1601 }
1602 napi_get_value_int32(env, params[0], &context->slotId);
1603 if (paramsCount == TWO_PARAMETERS) {
1604 napi_create_reference(env, params[1], DEFAULT_REF_COUNT, &context->callbackRef);
1605 }
1606 napi_value result = NapiUtil::HandleAsyncWork(
1607 env, context, "IsImsSmsSupported", NativeIsImsSmsSupported, IsImsSmsSupportedCallback);
1608 return result;
1609 }
1610
NativeGetImsShortMessageFormat(napi_env env,void * data)1611 static void NativeGetImsShortMessageFormat(napi_env env, void *data)
1612 {
1613 auto context = static_cast<SingleValueContext<std::u16string> *>(data);
1614 context->errorCode =
1615 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetImsShortMessageFormat(context->value);
1616 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1617 context->resolved = true;
1618 }
1619 TELEPHONY_LOGE("errorCode:%{public}d", context->errorCode);
1620 }
1621
to_utf8(std::u16string str16)1622 static std::string to_utf8(std::u16string str16)
1623 {
1624 return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.to_bytes(str16);
1625 }
1626
GetImsShortMessageFormatCallback(napi_env env,napi_status status,void * data)1627 static void GetImsShortMessageFormatCallback(napi_env env, napi_status status, void *data)
1628 {
1629 auto context = static_cast<SingleValueContext<std::u16string> *>(data);
1630 napi_value callbackValue = nullptr;
1631 if (context->resolved) {
1632 std::string toUtf8Value = to_utf8(context->value);
1633 napi_create_string_utf8(env, toUtf8Value.c_str(), toUtf8Value.size(), &callbackValue);
1634 } else {
1635 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1636 context->errorCode, "getImsShortMessageFormat", "ohos.permission.GET_TELEPHONY_STATE");
1637 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1638 }
1639 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1640 }
1641
MatchGetImsShortMessageFormatParameters(napi_env env,const napi_value parameters[],size_t parameterCount)1642 static bool MatchGetImsShortMessageFormatParameters(napi_env env, const napi_value parameters[], size_t parameterCount)
1643 {
1644 switch (parameterCount) {
1645 case NONE_PARAMETER: {
1646 return true;
1647 }
1648 case ONE_PARAMETER: {
1649 return NapiUtil::MatchParameters(env, parameters, { napi_function });
1650 }
1651 default: {
1652 return false;
1653 }
1654 }
1655 }
1656
GetImsShortMessageFormat(napi_env env,napi_callback_info info)1657 static napi_value GetImsShortMessageFormat(napi_env env, napi_callback_info info)
1658 {
1659 size_t paramsCount = ONE_PARAMETER;
1660 napi_value params[ONE_PARAMETER] = { 0 };
1661 napi_value arg = nullptr;
1662 void *data = nullptr;
1663
1664 napi_get_cb_info(env, info, ¶msCount, params, &arg, &data);
1665 if (!MatchGetImsShortMessageFormatParameters(env, params, paramsCount)) {
1666 TELEPHONY_LOGE("GetImsShortMessageFormat parameter matching failed.");
1667 NapiUtil::ThrowParameterError(env);
1668 return nullptr;
1669 }
1670 auto context = std::make_unique<SingleValueContext<std::u16string>>().release();
1671 if (context == nullptr) {
1672 TELEPHONY_LOGE("GetImsShortMessageFormat SingleValueContext is nullptr.");
1673 NapiUtil::ThrowParameterError(env);
1674 return nullptr;
1675 }
1676 if (paramsCount == ONE_PARAMETER) {
1677 napi_create_reference(env, params[0], DEFAULT_REF_COUNT, &context->callbackRef);
1678 }
1679 napi_value result = NapiUtil::HandleAsyncWork(env, context, "GetImsShortMessageFormat",
1680 NativeGetImsShortMessageFormat, GetImsShortMessageFormatCallback);
1681 return result;
1682 }
1683
CreateEnumConstructor(napi_env env,napi_callback_info info)1684 static napi_value CreateEnumConstructor(napi_env env, napi_callback_info info)
1685 {
1686 napi_value thisArg = nullptr;
1687 void *data = nullptr;
1688
1689 napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
1690 napi_value global = nullptr;
1691 napi_get_global(env, &global);
1692 return thisArg;
1693 }
1694
CreateEnumSendSmsResult(napi_env env,napi_value exports)1695 static napi_value CreateEnumSendSmsResult(napi_env env, napi_value exports)
1696 {
1697 napi_value success = nullptr;
1698 napi_value unknow = nullptr;
1699 napi_value radioOff = nullptr;
1700 napi_value serviceUnavailable = nullptr;
1701
1702 napi_create_int32(env, (int32_t)SendSmsResult::SEND_SMS_SUCCESS, &success);
1703 napi_create_int32(env, (int32_t)SendSmsResult::SEND_SMS_FAILURE_UNKNOWN, &unknow);
1704 napi_create_int32(env, (int32_t)SendSmsResult::SEND_SMS_FAILURE_RADIO_OFF, &radioOff);
1705 napi_create_int32(env, (int32_t)SendSmsResult::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE, &serviceUnavailable);
1706
1707 napi_property_descriptor desc[] = {
1708 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_SUCCESS", success),
1709 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_UNKNOWN", unknow),
1710 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_RADIO_OFF", radioOff),
1711 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_SERVICE_UNAVAILABLE", serviceUnavailable),
1712 };
1713
1714 napi_value result = nullptr;
1715 napi_define_class(env, "SendSmsResult", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
1716 sizeof(desc) / sizeof(*desc), desc, &result);
1717 napi_set_named_property(env, exports, "SendSmsResult", result);
1718 return exports;
1719 }
1720
CreateEnumShortMessageClass(napi_env env,napi_value exports)1721 static napi_value CreateEnumShortMessageClass(napi_env env, napi_value exports)
1722 {
1723 napi_property_descriptor desc[] = {
1724 DECLARE_NAPI_STATIC_PROPERTY(
1725 "UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::UNKNOWN))),
1726 DECLARE_NAPI_STATIC_PROPERTY("INSTANT_MESSAGE",
1727 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::INSTANT_MESSAGE))),
1728 DECLARE_NAPI_STATIC_PROPERTY("OPTIONAL_MESSAGE",
1729 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::OPTIONAL_MESSAGE))),
1730 DECLARE_NAPI_STATIC_PROPERTY(
1731 "SIM_MESSAGE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::SIM_MESSAGE))),
1732 DECLARE_NAPI_STATIC_PROPERTY("FORWARD_MESSAGE",
1733 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::FORWARD_MESSAGE))),
1734 };
1735 napi_value result = nullptr;
1736 napi_define_class(env, "ShortMessageClass", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
1737 sizeof(desc) / sizeof(*desc), desc, &result);
1738 napi_set_named_property(env, exports, "ShortMessageClass", result);
1739 return exports;
1740 }
1741
CreateEnumMessageStatusClass(napi_env env,napi_value exports)1742 static napi_value CreateEnumMessageStatusClass(napi_env env, napi_value exports)
1743 {
1744 napi_property_descriptor desc[] = {
1745 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_FREE",
1746 NapiUtil::ToInt32Value(
1747 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE))),
1748 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_READ",
1749 NapiUtil::ToInt32Value(
1750 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_READ))),
1751 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_UNREAD",
1752 NapiUtil::ToInt32Value(
1753 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNREAD))),
1754 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_SENT",
1755 NapiUtil::ToInt32Value(
1756 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_SENT))),
1757 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_UNSENT",
1758 NapiUtil::ToInt32Value(
1759 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT))),
1760 };
1761 napi_value result = nullptr;
1762 napi_define_class(env, "SimMessageStatus", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
1763 sizeof(desc) / sizeof(*desc), desc, &result);
1764 napi_set_named_property(env, exports, "SimMessageStatus", result);
1765 return exports;
1766 }
1767
CreateEnumRanType(napi_env env,napi_value exports)1768 static napi_value CreateEnumRanType(napi_env env, napi_value exports)
1769 {
1770 napi_property_descriptor desc[] = {
1771 DECLARE_NAPI_STATIC_PROPERTY(
1772 "TYPE_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RanType::TYPE_GSM))),
1773 DECLARE_NAPI_STATIC_PROPERTY(
1774 "TYPE_CDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RanType::TYPE_CDMA))),
1775 };
1776 napi_value result = nullptr;
1777 napi_define_class(env, "RanType", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
1778 sizeof(desc) / sizeof(*desc), desc, &result);
1779 napi_set_named_property(env, exports, "RanType", result);
1780 return exports;
1781 }
1782
CreateEnumSmsSegmentsInfo(napi_env env,napi_value exports)1783 static napi_value CreateEnumSmsSegmentsInfo(napi_env env, napi_value exports)
1784 {
1785 napi_property_descriptor desc[] = {
1786 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_UNKNOWN",
1787 NapiUtil::ToInt32Value(
1788 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_UNKNOWN))),
1789 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_7BIT",
1790 NapiUtil::ToInt32Value(
1791 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_7BIT))),
1792 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_8BIT",
1793 NapiUtil::ToInt32Value(
1794 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_8BIT))),
1795 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_16BIT",
1796 NapiUtil::ToInt32Value(
1797 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_16BIT))),
1798 };
1799 napi_value result = nullptr;
1800 napi_define_class(env, "SmsEncodingScheme", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
1801 sizeof(desc) / sizeof(*desc), desc, &result);
1802 napi_set_named_property(env, exports, "SmsEncodingScheme", result);
1803 return exports;
1804 }
1805
InitEnumSendSmsResult(napi_env env,napi_value exports)1806 static napi_value InitEnumSendSmsResult(napi_env env, napi_value exports)
1807 {
1808 napi_property_descriptor desc[] = {
1809 DECLARE_NAPI_STATIC_PROPERTY(
1810 "SEND_SMS_SUCCESS", NapiUtil::ToInt32Value(env, static_cast<int32_t>(SEND_SMS_SUCCESS))),
1811 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_UNKNOWN",
1812 NapiUtil::ToInt32Value(env, static_cast<int32_t>(SEND_SMS_FAILURE_UNKNOWN))),
1813 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_RADIO_OFF",
1814 NapiUtil::ToInt32Value(env, static_cast<int32_t>(SEND_SMS_FAILURE_RADIO_OFF))),
1815 DECLARE_NAPI_STATIC_PROPERTY("SEND_SMS_FAILURE_SERVICE_UNAVAILABLE",
1816 NapiUtil::ToInt32Value(env, static_cast<int32_t>(SEND_SMS_FAILURE_SERVICE_UNAVAILABLE))),
1817 };
1818 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1819 return exports;
1820 }
1821
InitEnumShortMessageClass(napi_env env,napi_value exports)1822 static napi_value InitEnumShortMessageClass(napi_env env, napi_value exports)
1823 {
1824 napi_property_descriptor desc[] = {
1825 DECLARE_NAPI_STATIC_PROPERTY(
1826 "UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::UNKNOWN))),
1827 DECLARE_NAPI_STATIC_PROPERTY("INSTANT_MESSAGE",
1828 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::INSTANT_MESSAGE))),
1829 DECLARE_NAPI_STATIC_PROPERTY("OPTIONAL_MESSAGE",
1830 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::OPTIONAL_MESSAGE))),
1831 DECLARE_NAPI_STATIC_PROPERTY(
1832 "SIM_MESSAGE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::SIM_MESSAGE))),
1833 DECLARE_NAPI_STATIC_PROPERTY("FORWARD_MESSAGE",
1834 NapiUtil::ToInt32Value(env, static_cast<int32_t>(ShortMessageClass::FORWARD_MESSAGE))),
1835 };
1836 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1837 return exports;
1838 }
1839
InitEnumMessageStatusClass(napi_env env,napi_value exports)1840 static napi_value InitEnumMessageStatusClass(napi_env env, napi_value exports)
1841 {
1842 napi_property_descriptor desc[] = {
1843 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_FREE",
1844 NapiUtil::ToInt32Value(
1845 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE))),
1846 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_READ",
1847 NapiUtil::ToInt32Value(
1848 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_READ))),
1849 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_UNREAD",
1850 NapiUtil::ToInt32Value(
1851 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNREAD))),
1852 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_SENT",
1853 NapiUtil::ToInt32Value(
1854 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_SENT))),
1855 DECLARE_NAPI_STATIC_PROPERTY("SIM_MESSAGE_STATUS_UNSENT",
1856 NapiUtil::ToInt32Value(
1857 env, static_cast<int32_t>(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT))),
1858 };
1859 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1860 return exports;
1861 }
1862
InitEnumRanType(napi_env env,napi_value exports)1863 static napi_value InitEnumRanType(napi_env env, napi_value exports)
1864 {
1865 napi_property_descriptor desc[] = {
1866 DECLARE_NAPI_STATIC_PROPERTY(
1867 "TYPE_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RanType::TYPE_GSM))),
1868 DECLARE_NAPI_STATIC_PROPERTY(
1869 "TYPE_CDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RanType::TYPE_CDMA))),
1870 };
1871 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1872 return exports;
1873 }
1874
InitEnumSmsSegmentsInfo(napi_env env,napi_value exports)1875 static napi_value InitEnumSmsSegmentsInfo(napi_env env, napi_value exports)
1876 {
1877 napi_property_descriptor desc[] = {
1878 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_UNKNOWN",
1879 NapiUtil::ToInt32Value(
1880 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_UNKNOWN))),
1881 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_7BIT",
1882 NapiUtil::ToInt32Value(
1883 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_7BIT))),
1884 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_8BIT",
1885 NapiUtil::ToInt32Value(
1886 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_8BIT))),
1887 DECLARE_NAPI_STATIC_PROPERTY("SMS_ENCODING_16BIT",
1888 NapiUtil::ToInt32Value(
1889 env, static_cast<int32_t>(ISmsServiceInterface::SmsEncodingScheme::SMS_ENCODING_16BIT))),
1890 };
1891 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1892 return exports;
1893 }
1894
1895 EXTERN_C_START
InitNapiSmsRegistry(napi_env env,napi_value exports)1896 napi_value InitNapiSmsRegistry(napi_env env, napi_value exports)
1897 {
1898 napi_property_descriptor desc[] = {
1899 DECLARE_NAPI_FUNCTION("sendMessage", SendMessage),
1900 DECLARE_NAPI_FUNCTION("sendShortMessage", SendShortMessage),
1901 DECLARE_NAPI_FUNCTION("createMessage", CreateMessage),
1902 DECLARE_NAPI_FUNCTION("setDefaultSmsSlotId", SetDefaultSmsSlotId),
1903 DECLARE_NAPI_FUNCTION("getDefaultSmsSlotId", GetDefaultSmsSlotId),
1904 DECLARE_NAPI_FUNCTION("getDefaultSmsSimId", GetDefaultSmsSimId),
1905 DECLARE_NAPI_FUNCTION("setSmscAddr", SetSmscAddr),
1906 DECLARE_NAPI_FUNCTION("getSmscAddr", GetSmscAddr),
1907 DECLARE_NAPI_FUNCTION("addSimMessage", AddSimMessage),
1908 DECLARE_NAPI_FUNCTION("delSimMessage", DelSimMessage),
1909 DECLARE_NAPI_FUNCTION("updateSimMessage", UpdateSimMessage),
1910 DECLARE_NAPI_FUNCTION("getAllSimMessages", GetAllSimMessages),
1911 DECLARE_NAPI_FUNCTION("setCBConfig", SetCBConfig),
1912 DECLARE_NAPI_FUNCTION("splitMessage", SplitMessage),
1913 DECLARE_NAPI_FUNCTION("hasSmsCapability", HasSmsCapability),
1914 DECLARE_NAPI_FUNCTION("getSmsSegmentsInfo", GetSmsSegmentsInfo),
1915 DECLARE_NAPI_FUNCTION("isImsSmsSupported", IsImsSmsSupported),
1916 DECLARE_NAPI_FUNCTION("getImsShortMessageFormat", GetImsShortMessageFormat),
1917 DECLARE_NAPI_FUNCTION("decodeMms", NapiMms::DecodeMms),
1918 DECLARE_NAPI_FUNCTION("encodeMms", NapiMms::EncodeMms),
1919 DECLARE_NAPI_FUNCTION("sendMms", NapiMms::SendMms),
1920 DECLARE_NAPI_FUNCTION("downloadMms", NapiMms::DownloadMms),
1921 };
1922 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1923 CreateEnumSendSmsResult(env, exports);
1924 CreateEnumShortMessageClass(env, exports);
1925 CreateEnumMessageStatusClass(env, exports);
1926 CreateEnumRanType(env, exports);
1927 CreateEnumSmsSegmentsInfo(env, exports);
1928 InitEnumSendSmsResult(env, exports);
1929 InitEnumShortMessageClass(env, exports);
1930 InitEnumMessageStatusClass(env, exports);
1931 InitEnumRanType(env, exports);
1932 InitEnumSmsSegmentsInfo(env, exports);
1933 NapiMms::InitEnumMmsCharSets(env, exports);
1934 NapiMms::InitEnumMessageType(env, exports);
1935 NapiMms::InitEnumPriorityType(env, exports);
1936 NapiMms::InitEnumVersionType(env, exports);
1937 NapiMms::InitEnumDispositionType(env, exports);
1938 NapiMms::InitEnumReportAllowedType(env, exports);
1939 NapiMms::InitSupportEnumMmsCharSets(env, exports);
1940 NapiMms::InitSupportEnumMessageType(env, exports);
1941 NapiMms::InitSupportEnumPriorityType(env, exports);
1942 NapiMms::InitSupportEnumVersionType(env, exports);
1943 NapiMms::InitSupportEnumDispositionType(env, exports);
1944 NapiMms::InitSupportEnumReportAllowedType(env, exports);
1945 return exports;
1946 }
1947 EXTERN_C_END
1948
1949 static napi_module g_smsModule = {
1950 .nm_version = 1,
1951 .nm_flags = 0,
1952 .nm_filename = nullptr,
1953 .nm_register_func = InitNapiSmsRegistry,
1954 .nm_modname = "telephony.sms",
1955 .nm_priv = ((void *)0),
1956 .reserved = {(void *)0},
1957 };
1958
RegisterTelephonySmsModule(void)1959 extern "C" __attribute__((constructor)) void RegisterTelephonySmsModule(void)
1960 {
1961 napi_module_register(&g_smsModule);
1962 }
1963 } // namespace Telephony
1964 } // namespace OHOS
1965