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