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