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