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