1 /*
2 * Copyright (c) 2025 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 #include "telephony_manager_addon.h"
16
17 #include "edm_constants.h"
18 #include "edm_ipc_interface_code.h"
19 #include "edm_log.h"
20 #include "iptables_utils.h"
21
22 using namespace OHOS::EDM;
23 constexpr int32_t STRING_MAX_LEN = 100;
24
Init(napi_env env,napi_value exports)25 napi_value TelephonyManagerAddon::Init(napi_env env, napi_value exports)
26 {
27 napi_property_descriptor property[] = {
28 DECLARE_NAPI_FUNCTION("setSimDisabled", SetSimDisabled),
29 DECLARE_NAPI_FUNCTION("setSimEnabled", SetSimEnabled),
30 DECLARE_NAPI_FUNCTION("isSimDisabled", IsSimDisabled),
31 DECLARE_NAPI_FUNCTION("addOutgoingCallPolicyNumbers", AddOutgoingCallPolicyNumbers),
32 DECLARE_NAPI_FUNCTION("removeOutgoingCallPolicyNumbers", RemoveOutgoingCallPolicyNumbers),
33 DECLARE_NAPI_FUNCTION("getOutgoingCallPolicyNumbers", GetOutgoingCallPolicyNumbers),
34 DECLARE_NAPI_FUNCTION("addIncomingCallPolicyNumbers", AddIncomingCallPolicyNumbers),
35 DECLARE_NAPI_FUNCTION("removeIncomingCallPolicyNumbers", RemoveIncomingCallPolicyNumbers),
36 DECLARE_NAPI_FUNCTION("getIncomingCallPolicyNumbers", GetIncomingCallPolicyNumbers),
37 };
38 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
39 return exports;
40 }
41
42
SetSimDisabled(napi_env env,napi_callback_info info)43 napi_value TelephonyManagerAddon::SetSimDisabled(napi_env env, napi_callback_info info)
44 {
45 EDMLOGI("NAPI_SetSimDisabled called");
46 #if defined(TELEPHONY_EDM_ENABLE)
47 AddonMethodSign addonMethodSign;
48 addonMethodSign.name = "setSimDisabled";
49 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::INT32};
50 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
51 AdapterAddonData adapterAddonData{};
52 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
53 if (result == nullptr) {
54 return nullptr;
55 }
56 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->SetSimDisabled(adapterAddonData.data);
57 if (FAILED(ret)) {
58 napi_throw(env, CreateError(env, ret));
59 }
60 return nullptr;
61 #else
62 EDMLOGW("TelephonyManagerAddon::SetSimDisabled Unsupported Capabilities.");
63 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
64 return nullptr;
65 #endif
66 }
67
SetSimEnabled(napi_env env,napi_callback_info info)68 napi_value TelephonyManagerAddon::SetSimEnabled(napi_env env, napi_callback_info info)
69 {
70 EDMLOGI("NAPI_SetSimEnabled called");
71 #if defined(TELEPHONY_EDM_ENABLE)
72 AddonMethodSign addonMethodSign;
73 addonMethodSign.name = "setSimEnabled";
74 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::INT32};
75 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
76 AdapterAddonData adapterAddonData{};
77 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
78 if (result == nullptr) {
79 return nullptr;
80 }
81 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->SetSimEnabled(adapterAddonData.data);
82 if (FAILED(ret)) {
83 napi_throw(env, CreateError(env, ret));
84 }
85 return nullptr;
86 #else
87 EDMLOGW("TelephonyManagerAddon::SetSimEnabled Unsupported Capabilities.");
88 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
89 return nullptr;
90 #endif
91 }
92
IsSimDisabled(napi_env env,napi_callback_info info)93 napi_value TelephonyManagerAddon::IsSimDisabled(napi_env env, napi_callback_info info)
94 {
95 EDMLOGI("NAPI_IsSimDisabled called");
96 #if defined(TELEPHONY_EDM_ENABLE)
97 AddonMethodSign addonMethodSign;
98 addonMethodSign.name = "isSimDisabled";
99 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::INT32};
100 addonMethodSign.methodAttribute = MethodAttribute::GET;
101 AdapterAddonData adapterAddonData{};
102 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
103 if (result == nullptr) {
104 return nullptr;
105 }
106 bool isDisable = false;
107 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->IsSimDisabled(adapterAddonData.data, isDisable);
108 if (FAILED(ret)) {
109 napi_throw(env, CreateError(env, ret));
110 return nullptr;
111 }
112 result = nullptr;
113 NAPI_CALL(env, napi_get_boolean(env, isDisable, &result));
114 return result;
115 #else
116 EDMLOGW("TelephonyManagerAddon::IsSimDisabled Unsupported Capabilities.");
117 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
118 return nullptr;
119 #endif
120 }
121
CheckVectorStringLength(const std::vector<std::string> & array)122 bool TelephonyManagerAddon::CheckVectorStringLength(const std::vector<std::string> &array)
123 {
124 for (const auto &item : array) {
125 if (item.empty() || item.length() > STRING_MAX_LEN) {
126 return false;
127 }
128 }
129 return true;
130 }
131
AddOutgoingCallPolicyNumbers(napi_env env,napi_callback_info info)132 napi_value TelephonyManagerAddon::AddOutgoingCallPolicyNumbers(napi_env env, napi_callback_info info)
133 {
134 EDMLOGI("NAPI_AddOutgoingCallPolicyNumbers called");
135 #if defined(TELEPHONY_EDM_ENABLE)
136 size_t argc = ARGS_SIZE_THREE;
137 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
138 napi_value thisArg = nullptr;
139 void *data = nullptr;
140 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
141 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
142 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
143 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
144 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
145 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
146 bool hasNumbers = MatchValueType(env, argv[ARR_INDEX_TWO], napi_object);
147 ASSERT_AND_THROW_PARAM_ERROR(env, hasNumbers, "The third parameter must be numbers.");
148
149 OHOS::AppExecFwk::ElementName elementName;
150 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
151 "element name param error");
152 int32_t policy = -1;
153 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
154 "element name param error");
155 std::vector<std::string> numbers;
156 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, numbers, argv[ARR_INDEX_TWO]),
157 "apnInfo name param error");
158 ASSERT_AND_THROW_PARAM_ERROR(env, CheckVectorStringLength(numbers), "string length is limit");
159
160 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->AddCallPolicyNumbers(
161 elementName, EdmConstants::CallPolicy::OUTGOING, policy, numbers);
162 if (FAILED(ret)) {
163 napi_throw(env, CreateError(env, ret));
164 }
165 return nullptr;
166 #else
167 EDMLOGW("TelephonyManagerAddon::AddOutgoingCallPolicyNumbers Unsupported Capabilities.");
168 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
169 return nullptr;
170 #endif
171 }
172
RemoveOutgoingCallPolicyNumbers(napi_env env,napi_callback_info info)173 napi_value TelephonyManagerAddon::RemoveOutgoingCallPolicyNumbers(napi_env env, napi_callback_info info)
174 {
175 EDMLOGI("NAPI_RemoveOutgoingCallPolicyNumbers called");
176 #if defined(TELEPHONY_EDM_ENABLE)
177 size_t argc = ARGS_SIZE_THREE;
178 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
179 napi_value thisArg = nullptr;
180 void *data = nullptr;
181 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
182 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
183 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
184 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
185 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
186 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
187 bool hasNumbers = MatchValueType(env, argv[ARR_INDEX_TWO], napi_object);
188 ASSERT_AND_THROW_PARAM_ERROR(env, hasNumbers, "The third parameter must be numbers.");
189
190 OHOS::AppExecFwk::ElementName elementName;
191 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
192 "element name param error");
193 int32_t policy = -1;
194 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
195 "element name param error");
196 std::vector<std::string> numbers;
197 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, numbers, argv[ARR_INDEX_TWO]),
198 "apnInfo name param error");
199 ASSERT_AND_THROW_PARAM_ERROR(env, CheckVectorStringLength(numbers), "string length is limit");
200
201 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->RemoveCallPolicyNumbers(
202 elementName, EdmConstants::CallPolicy::OUTGOING, policy, numbers);
203 if (FAILED(ret)) {
204 napi_throw(env, CreateError(env, ret));
205 }
206 return nullptr;
207 #else
208 EDMLOGW("TelephonyManagerAddon::RemoveOutgoingCallPolicyNumbers Unsupported Capabilities.");
209 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
210 return nullptr;
211 #endif
212 }
213
GetOutgoingCallPolicyNumbers(napi_env env,napi_callback_info info)214 napi_value TelephonyManagerAddon::GetOutgoingCallPolicyNumbers(napi_env env, napi_callback_info info)
215 {
216 EDMLOGI("NAPI_GetOutgoingCallPolicyNumbers called");
217 #if defined(TELEPHONY_EDM_ENABLE)
218 size_t argc = ARGS_SIZE_TWO;
219 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
220 napi_value thisArg = nullptr;
221 void *data = nullptr;
222 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
223 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
224 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
225 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
226 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
227 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
228
229 OHOS::AppExecFwk::ElementName elementName;
230 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
231 "element name param error");
232 int32_t policy = -1;
233 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
234 "element name param error");
235
236 std::vector<std::string> numbers;
237 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->GetCallPolicyNumbers(
238 elementName, EdmConstants::CallPolicy::OUTGOING, policy, numbers);
239 if (FAILED(ret)) {
240 napi_throw(env, CreateError(env, ret));
241 return nullptr;
242 }
243
244 napi_value jsList = nullptr;
245 NAPI_CALL(env, napi_create_array_with_length(env, numbers.size(), &jsList));
246 ConvertStringVectorToJS(env, numbers, jsList);
247
248 return jsList;
249 #else
250 EDMLOGW("TelephonyManagerAddon::GetOutgoingCallPolicyNumbers Unsupported Capabilities.");
251 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
252 return nullptr;
253 #endif
254 }
255
AddIncomingCallPolicyNumbers(napi_env env,napi_callback_info info)256 napi_value TelephonyManagerAddon::AddIncomingCallPolicyNumbers(napi_env env, napi_callback_info info)
257 {
258 EDMLOGI("NAPI_AddIncomingCallPolicyNumbers called");
259 #if defined(TELEPHONY_EDM_ENABLE)
260 size_t argc = ARGS_SIZE_THREE;
261 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
262 napi_value thisArg = nullptr;
263 void *data = nullptr;
264 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
265 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
266 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
267 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
268 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
269 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
270 bool hasNumbers = MatchValueType(env, argv[ARR_INDEX_TWO], napi_object);
271 ASSERT_AND_THROW_PARAM_ERROR(env, hasNumbers, "The third parameter must be numbers.");
272
273 OHOS::AppExecFwk::ElementName elementName;
274 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
275 "element name param error");
276 int32_t policy = -1;
277 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
278 "element name param error");
279 std::vector<std::string> numbers;
280 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, numbers, argv[ARR_INDEX_TWO]),
281 "apnInfo name param error");
282 ASSERT_AND_THROW_PARAM_ERROR(env, CheckVectorStringLength(numbers), "string length is limit");
283
284 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->AddCallPolicyNumbers(
285 elementName, EdmConstants::CallPolicy::INCOMING, policy, numbers);
286 if (FAILED(ret)) {
287 napi_throw(env, CreateError(env, ret));
288 }
289 return nullptr;
290 #else
291 EDMLOGW("TelephonyManagerAddon::AddIncomingCallPolicyNumbers Unsupported Capabilities.");
292 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
293 return nullptr;
294 #endif
295 }
296
RemoveIncomingCallPolicyNumbers(napi_env env,napi_callback_info info)297 napi_value TelephonyManagerAddon::RemoveIncomingCallPolicyNumbers(napi_env env, napi_callback_info info)
298 {
299 EDMLOGI("NAPI_RemoveIncomingCallPolicyNumbers called");
300 #if defined(TELEPHONY_EDM_ENABLE)
301 size_t argc = ARGS_SIZE_THREE;
302 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
303 napi_value thisArg = nullptr;
304 void *data = nullptr;
305 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
306 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
307 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
308 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
309 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
310 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
311 bool hasNumbers = MatchValueType(env, argv[ARR_INDEX_TWO], napi_object);
312 ASSERT_AND_THROW_PARAM_ERROR(env, hasNumbers, "The third parameter must be numbers.");
313
314 OHOS::AppExecFwk::ElementName elementName;
315 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
316 "element name param error");
317 int32_t policy = -1;
318 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
319 "element name param error");
320 std::vector<std::string> numbers;
321 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, numbers, argv[ARR_INDEX_TWO]),
322 "apnInfo name param error");
323 ASSERT_AND_THROW_PARAM_ERROR(env, CheckVectorStringLength(numbers), "string length is limit");
324
325 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->RemoveCallPolicyNumbers(
326 elementName, EdmConstants::CallPolicy::INCOMING, policy, numbers);
327 if (FAILED(ret)) {
328 napi_throw(env, CreateError(env, ret));
329 }
330 return nullptr;
331 #else
332 EDMLOGW("TelephonyManagerAddon::RemoveIncomingCallPolicyNumbers Unsupported Capabilities.");
333 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
334 return nullptr;
335 #endif
336 }
337
GetIncomingCallPolicyNumbers(napi_env env,napi_callback_info info)338 napi_value TelephonyManagerAddon::GetIncomingCallPolicyNumbers(napi_env env, napi_callback_info info)
339 {
340 EDMLOGI("NAPI_GetIncomingCallPolicyNumbers called");
341 #if defined(TELEPHONY_EDM_ENABLE)
342 size_t argc = ARGS_SIZE_TWO;
343 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
344 napi_value thisArg = nullptr;
345 void *data = nullptr;
346 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
347 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
348 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
349 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
350 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
351 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be Policy.");
352
353 OHOS::AppExecFwk::ElementName elementName;
354 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
355 "element name param error");
356 int32_t policy = -1;
357 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_ONE]),
358 "element name param error");
359
360 std::vector<std::string> numbers;
361 int32_t ret = TelephonyManagerProxy::GetTelephonyManagerProxy()->GetCallPolicyNumbers(
362 elementName, EdmConstants::CallPolicy::INCOMING, policy, numbers);
363 if (FAILED(ret)) {
364 napi_throw(env, CreateError(env, ret));
365 return nullptr;
366 }
367
368 napi_value jsList = nullptr;
369 NAPI_CALL(env, napi_create_array_with_length(env, numbers.size(), &jsList));
370 ConvertStringVectorToJS(env, numbers, jsList);
371
372 return jsList;
373 #else
374 EDMLOGW("TelephonyManagerAddon::GetIncomingCallPolicyNumbers Unsupported Capabilities.");
375 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
376 return nullptr;
377 #endif
378 }
379
380 static napi_module g_telephonyManagerModule = {
381 .nm_version = 1,
382 .nm_flags = 0,
383 .nm_filename = nullptr,
384 .nm_register_func = TelephonyManagerAddon::Init,
385 .nm_modname = "enterprise.telephonyManager",
386 .nm_priv = ((void *)0),
387 .reserved = {0},
388 };
389
TelephonyManagerRegister()390 extern "C" __attribute__((constructor)) void TelephonyManagerRegister()
391 {
392 napi_module_register(&g_telephonyManagerModule);
393 }