1 /*
2 * Copyright (c) 2023 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 "application_manager_addon.h"
17 #include "edm_constants.h"
18 #include "edm_log.h"
19 #include "os_account_manager.h"
20
21 using namespace OHOS::EDM;
22
Init(napi_env env,napi_value exports)23 napi_value ApplicationManagerAddon::Init(napi_env env, napi_value exports)
24 {
25 napi_property_descriptor property[] = {
26 DECLARE_NAPI_FUNCTION("addDisallowedRunningBundles", AddDisallowedRunningBundles),
27 DECLARE_NAPI_FUNCTION("removeDisallowedRunningBundles", RemoveDisallowedRunningBundles),
28 DECLARE_NAPI_FUNCTION("getDisallowedRunningBundles", GetDisallowedRunningBundles),
29 DECLARE_NAPI_FUNCTION("addAutoStartApps", AddAutoStartApps),
30 DECLARE_NAPI_FUNCTION("removeAutoStartApps", RemoveAutoStartApps),
31 DECLARE_NAPI_FUNCTION("getAutoStartApps", GetAutoStartApps),
32 };
33 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
34 return exports;
35 }
36
AddAutoStartApps(napi_env env,napi_callback_info info)37 napi_value ApplicationManagerAddon::AddAutoStartApps(napi_env env, napi_callback_info info)
38 {
39 return AddOrRemoveAutoStartApps(env, info, "AddAutoStartApps");
40 }
41
RemoveAutoStartApps(napi_env env,napi_callback_info info)42 napi_value ApplicationManagerAddon::RemoveAutoStartApps(napi_env env, napi_callback_info info)
43 {
44 return AddOrRemoveAutoStartApps(env, info, "RemoveAutoStartApps");
45 }
46
AddOrRemoveAutoStartApps(napi_env env,napi_callback_info info,std::string function)47 napi_value ApplicationManagerAddon::AddOrRemoveAutoStartApps(napi_env env, napi_callback_info info,
48 std::string function)
49 {
50 EDMLOGI("NAPI_AddOrRemoveAutoStartApps called");
51 size_t argc = ARGS_SIZE_TWO;
52 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
53 napi_value thisArg = nullptr;
54 void *data = nullptr;
55 OHOS::AppExecFwk::ElementName elementName;
56
57 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
58 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
59 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
60 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
61 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
62 "element name param error");
63 std::vector<AppExecFwk::ElementName> autoStartApps;
64 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementArray(env, autoStartApps, argv[ARR_INDEX_ONE]),
65 "Parameter autoStartApps error");
66 EDMLOGD(
67 "EnableAdmin: elementName.bundlename %{public}s, "
68 "elementName.abilityname:%{public}s",
69 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
70 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
71 int32_t ret = 0;
72 if (function == "AddAutoStartApps") {
73 ret = applicationManagerProxy->AddAutoStartApps(elementName, autoStartApps);
74 } else {
75 ret = applicationManagerProxy->RemoveAutoStartApps(elementName, autoStartApps);
76 }
77 if (FAILED(ret)) {
78 napi_throw(env, CreateError(env, ret));
79 }
80 return nullptr;
81 }
82
GetAutoStartApps(napi_env env,napi_callback_info info)83 napi_value ApplicationManagerAddon::GetAutoStartApps(napi_env env, napi_callback_info info)
84 {
85 EDMLOGI("NAPI_GetAutoStartApps called");
86 size_t argc = ARGS_SIZE_ONE;
87 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
88 napi_value thisArg = nullptr;
89 void *data = nullptr;
90 OHOS::AppExecFwk::ElementName elementName;
91
92 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
93 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
94 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
95 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
96 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
97 "element name param error");
98 EDMLOGD(
99 "EnableAdmin: elementName.bundlename %{public}s, "
100 "elementName.abilityname:%{public}s",
101 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
102 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
103 std::vector<OHOS::AppExecFwk::ElementName> autoStartApps;
104 int32_t ret = applicationManagerProxy->GetAutoStartApps(elementName, autoStartApps);
105 if (FAILED(ret)) {
106 napi_throw(env, CreateError(env, ret));
107 return nullptr;
108 }
109 napi_value napiAutoStartApps = nullptr;
110 napi_create_array(env, &napiAutoStartApps);
111 size_t idx = 0;
112 for (const auto &element : autoStartApps) {
113 napi_value objAutoStartApps = nullptr;
114 NAPI_CALL(env, napi_create_object(env, &objAutoStartApps));
115 napi_value napi_bundleName;
116 napi_value napi_abilityName;
117 NAPI_CALL(env, napi_create_string_utf8(env, element.GetBundleName().c_str(),
118 element.GetBundleName().size(), &napi_bundleName));
119 NAPI_CALL(env, napi_create_string_utf8(env, element.GetAbilityName().c_str(),
120 element.GetAbilityName().size(), &napi_abilityName));
121 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "bundleName", napi_bundleName));
122 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "abilityName", napi_abilityName));
123 napi_set_element(env, napiAutoStartApps, idx, objAutoStartApps);
124 idx++;
125 }
126 return napiAutoStartApps;
127 }
128
GetDisallowedRunningBundles(napi_env env,napi_callback_info info)129 napi_value ApplicationManagerAddon::GetDisallowedRunningBundles(napi_env env, napi_callback_info info)
130 {
131 EDMLOGI("NAPI_GetDisallowedRunningBundles called");
132 size_t argc = ARGS_SIZE_THREE;
133 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
134 napi_value thisArg = nullptr;
135 void *data = nullptr;
136 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
137 bool hasCallback = false;
138 bool hasUserId = false;
139 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
140 if (asyncCallbackInfo == nullptr) {
141 return nullptr;
142 }
143 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
144 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
145 ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
146 "Parameter type error");
147 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
148 "Parameter want error");
149
150 EDMLOGD("GetDisallowedRunningBundles::asyncCallbackInfo->elementName.bundlename %{public}s, "
151 "asyncCallbackInfo->abilityname:%{public}s",
152 asyncCallbackInfo->elementName.GetBundleName().c_str(),
153 asyncCallbackInfo->elementName.GetAbilityName().c_str());
154 if (hasUserId) {
155 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
156 "Parameter user id error");
157 } else {
158 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
159 }
160 if (hasCallback) {
161 ASSERT_AND_THROW_PARAM_ERROR(env,
162 ParseCallback(env, asyncCallbackInfo->callback,
163 argc <= ARR_INDEX_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
164 "Parameter callback error");
165 }
166 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetDisallowedRunningBundles",
167 NativeGetDisallowedRunningBundles, NativeArrayStringCallbackComplete);
168 callbackPtr.release();
169 return asyncWorkReturn;
170 }
171
NativeGetDisallowedRunningBundles(napi_env env,void * data)172 void ApplicationManagerAddon::NativeGetDisallowedRunningBundles(napi_env env, void *data)
173 {
174 EDMLOGI("NAPI_NativeGetDisallowedRunningBundles called");
175 if (data == nullptr) {
176 EDMLOGE("data is nullptr");
177 return;
178 }
179 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
180 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
181 auto proxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
182 if (proxy_ == nullptr) {
183 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
184 return;
185 }
186
187 asyncCallbackInfo->ret = proxy_->GetDisallowedRunningBundles(asyncCallbackInfo->elementName,
188 asyncCallbackInfo->userId, asyncCallbackInfo->arrayStringRet);
189 }
190
AddDisallowedRunningBundles(napi_env env,napi_callback_info info)191 napi_value ApplicationManagerAddon::AddDisallowedRunningBundles(napi_env env, napi_callback_info info)
192 {
193 return AddOrRemovellowedRunningBundles(env, info, "AddDisallowedRunningBundles", NativeAddDisallowedRunningBundles);
194 }
195
RemoveDisallowedRunningBundles(napi_env env,napi_callback_info info)196 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundles(napi_env env, napi_callback_info info)
197 {
198 return AddOrRemovellowedRunningBundles(env, info, "RemoveDisallowedRunningBundles",
199 NativeRemoveDisallowedRunningBundles);
200 }
201
NativeAddDisallowedRunningBundles(napi_env env,void * data)202 void ApplicationManagerAddon::NativeAddDisallowedRunningBundles(napi_env env, void *data)
203 {
204 EDMLOGI("NAPI_NativeAddDisallowedRunningBundles called");
205 if (data == nullptr) {
206 EDMLOGE("data is nullptr");
207 return;
208 }
209 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
210 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
211 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
212 if (applicationManagerProxy_ == nullptr) {
213 EDMLOGE("can not get applicationManagerProxy");
214 return;
215 }
216 asyncCallbackInfo->ret = applicationManagerProxy_->AddDisallowedRunningBundles(asyncCallbackInfo->elementName,
217 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
218 }
219
CheckAddDisallowedRunningBundlesParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)220 bool ApplicationManagerAddon::CheckAddDisallowedRunningBundlesParamType(napi_env env, size_t argc,
221 napi_value* argv, bool &hasCallback, bool &hasUserId)
222 {
223 if (!MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) || !MatchValueType(env, argv[ARR_INDEX_ONE],
224 napi_object)) {
225 EDMLOGE("CheckAddDisallowedRunningBundlesParamType admin or array type check failed");
226 return false;
227 }
228 EDMLOGI("CheckAddDisallowedRunningBundlesParamType argc = %{public}zu", argc);
229 if (argc == ARGS_SIZE_TWO) {
230 hasCallback = false;
231 hasUserId = false;
232 EDMLOGI("hasCallback = false; hasUserId = false;");
233 return true;
234 }
235
236 if (argc == ARGS_SIZE_THREE) {
237 if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_function)) {
238 hasCallback = true;
239 hasUserId = false;
240 EDMLOGI("hasCallback = true; hasUserId = false;");
241 return true;
242 } else {
243 hasCallback = false;
244 hasUserId = true;
245 EDMLOGI("hasCallback = false; hasUserId = true;");
246 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
247 }
248 }
249 hasCallback = true;
250 hasUserId = true;
251 EDMLOGI("hasCallback = true; hasUserId = true;");
252 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
253 MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
254 }
255
AddOrRemovellowedRunningBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)256 napi_value ApplicationManagerAddon::AddOrRemovellowedRunningBundles(napi_env env, napi_callback_info info,
257 const std::string &workName, napi_async_execute_callback execute)
258 {
259 size_t argc = ARGS_SIZE_FOUR;
260 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
261 napi_value thisArg = nullptr;
262 void *data = nullptr;
263 bool hasCallback = false;
264 bool hasUserId = false;
265 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
266 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
267 if (asyncCallbackInfo == nullptr) {
268 return nullptr;
269 }
270 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
271 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
272 ASSERT_AND_THROW_PARAM_ERROR(env,
273 CheckAddDisallowedRunningBundlesParamType(env, argc, argv, hasCallback, hasUserId), "Parameter type error");
274 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
275 "Parameter want error");
276 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->appIds, argv[ARR_INDEX_ONE]),
277 "Parameter bundles error");
278 ASSERT_AND_THROW_PARAM_ERROR(env, asyncCallbackInfo->appIds.size() <= EdmConstants::APPID_MAX_SIZE,
279 "Parameter bundles too large");
280 EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
281 "asyncCallbackInfo->abilityname:%{public}s",
282 asyncCallbackInfo->elementName.GetBundleName().c_str(),
283 asyncCallbackInfo->elementName.GetAbilityName().c_str());
284 if (hasUserId) {
285 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
286 "Parameter user id error");
287 } else {
288 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
289 }
290 if (hasCallback) {
291 ASSERT_AND_THROW_PARAM_ERROR(env,
292 ParseCallback(env, asyncCallbackInfo->callback,
293 argc <= ARR_INDEX_FOUR ? argv[argc - 1] : argv[ARR_INDEX_THREE]),
294 "Parameter callback error");
295 }
296 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, workName,
297 execute, NativeVoidCallbackComplete);
298 callbackPtr.release();
299 return asyncWorkReturn;
300 }
301
NativeRemoveDisallowedRunningBundles(napi_env env,void * data)302 void ApplicationManagerAddon::NativeRemoveDisallowedRunningBundles(napi_env env, void *data)
303 {
304 EDMLOGI("NativeRemoveDisallowedRunningBundles called");
305 if (data == nullptr) {
306 EDMLOGE("data is nullptr");
307 return;
308 }
309 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
310 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
311 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
312 if (applicationManagerProxy_ == nullptr) {
313 EDMLOGE("can not get ApplicationManagerProxy");
314 return;
315 }
316 asyncCallbackInfo->ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(asyncCallbackInfo->elementName,
317 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
318 }
319
320 static napi_module g_applicationManagerModule = {
321 .nm_version = 1,
322 .nm_flags = 0,
323 .nm_filename = nullptr,
324 .nm_register_func = ApplicationManagerAddon::Init,
325 .nm_modname = "enterprise.applicationManager",
326 .nm_priv = ((void *)0),
327 .reserved = { 0 },
328 };
329
ApplicationManagerRegister()330 extern "C" __attribute__((constructor)) void ApplicationManagerRegister()
331 {
332 napi_module_register(&g_applicationManagerModule);
333 }