1 /*
2 * Copyright (c) 2022 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 "fileshare_n_exporter.h"
16 #include "file_permission.h"
17 #include "grant_permissions.h"
18 #include "grant_uri_permission.h"
19 #include "log.h"
20
21 namespace OHOS {
22 namespace AppFileService {
23 namespace ModuleFileShare {
24 using namespace FileManagement;
25 using namespace FileManagement::LibN;
26
27 /***********************************************
28 * Module export and register
29 ***********************************************/
FileShareExport(napi_env env,napi_value exports)30 napi_value FileShareExport(napi_env env, napi_value exports)
31 {
32 InitOperationMode(env, exports);
33 InitPolicyType(env, exports);
34 InitPolicyInfo(env, exports);
35 InitPathPolicyInfo(env, exports);
36 InitPolicyErrorCode(env, exports);
37 InitPolicyErrorResult(env, exports);
38 static napi_property_descriptor desc[] = {
39 DECLARE_NAPI_FUNCTION("grantUriPermission", GrantUriPermission::Async),
40 DECLARE_NAPI_FUNCTION("persistPermission", PersistPermission),
41 DECLARE_NAPI_FUNCTION("revokePermission", RevokePermission),
42 DECLARE_NAPI_FUNCTION("activatePermission", ActivatePermission),
43 DECLARE_NAPI_FUNCTION("deactivatePermission", DeactivatePermission),
44 DECLARE_NAPI_FUNCTION("checkPersistentPermission", CheckPersistentPermission),
45 DECLARE_NAPI_FUNCTION("checkPathPermission", CheckPathPermission),
46 };
47 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
48 return exports;
49 }
50
InitPolicyConstructor(napi_env env,napi_callback_info info)51 static napi_value InitPolicyConstructor(napi_env env, napi_callback_info info)
52 {
53 size_t argc = 0;
54 napi_value args[1] = {0};
55 napi_value res = nullptr;
56 void *data = nullptr;
57 napi_status status = napi_get_cb_info(env, info, &argc, args, &res, &data);
58 if (status != napi_ok) {
59 HILOGE("InitPolicyConstructor, status is not napi_ok");
60 return nullptr;
61 }
62 return res;
63 }
64
InitOperationMode(napi_env env,napi_value exports)65 void InitOperationMode(napi_env env, napi_value exports)
66 {
67 char propertyName[] = "OperationMode";
68 napi_property_descriptor desc[] = {
69 DECLARE_NAPI_STATIC_PROPERTY("READ_MODE",
70 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::READ_MODE)).val_),
71 DECLARE_NAPI_STATIC_PROPERTY("WRITE_MODE",
72 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::WRITE_MODE)).val_),
73 DECLARE_NAPI_STATIC_PROPERTY("CREATE_MODE",
74 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::CREATE_MODE)).val_),
75 DECLARE_NAPI_STATIC_PROPERTY("DELETE_MODE",
76 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::DELETE_MODE)).val_),
77 DECLARE_NAPI_STATIC_PROPERTY("RENAME_MODE",
78 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::RENAME_MODE)).val_),
79 };
80 napi_value obj = nullptr;
81 napi_status status = napi_create_object(env, &obj);
82 if (status != napi_ok) {
83 HILOGE("Failed to create object at initializing OperationMode");
84 return;
85 }
86 status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
87 if (status != napi_ok) {
88 HILOGE("Failed to set properties of character at initializing OperationMode");
89 return;
90 }
91 status = napi_set_named_property(env, exports, propertyName, obj);
92 if (status != napi_ok) {
93 HILOGE("Failed to set direction property at initializing OperationMode");
94 return;
95 }
96 }
97
InitPolicyType(napi_env env,napi_value exports)98 void InitPolicyType(napi_env env, napi_value exports)
99 {
100 char propertyName[] = "PolicyType";
101 napi_property_descriptor desc[] = {
102 DECLARE_NAPI_STATIC_PROPERTY("TEMPORARY_TYPE",
103 NVal::CreateUint32(env, static_cast<uint32_t>(TEMPORARY_TYPE)).val_),
104 DECLARE_NAPI_STATIC_PROPERTY("PERSISTENT_TYPE",
105 NVal::CreateUint32(env, static_cast<uint32_t>(PERSISTENT_TYPE)).val_),
106 };
107 napi_value obj = nullptr;
108 napi_status status = napi_create_object(env, &obj);
109 if (status != napi_ok) {
110 HILOGE("Failed to create object at initializing PolicyType");
111 return;
112 }
113 status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
114 if (status != napi_ok) {
115 HILOGE("Failed to set properties of character at initializing PolicyType");
116 return;
117 }
118 status = napi_set_named_property(env, exports, propertyName, obj);
119 if (status != napi_ok) {
120 HILOGE("Failed to set direction property at initializing PolicyType");
121 return;
122 }
123 }
124
125
InitPolicyErrorCode(napi_env env,napi_value exports)126 void InitPolicyErrorCode(napi_env env, napi_value exports)
127 {
128 char propertyName[] = "PolicyErrorCode";
129 napi_property_descriptor desc[] = {
130 DECLARE_NAPI_STATIC_PROPERTY(
131 "PERSISTENCE_FORBIDDEN",
132 NVal::CreateInt32(env, static_cast<int32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN)).val_),
133 DECLARE_NAPI_STATIC_PROPERTY("INVALID_MODE",
134 NVal::CreateInt32(env, static_cast<int32_t>(PolicyErrorCode::INVALID_MODE)).val_),
135 DECLARE_NAPI_STATIC_PROPERTY("INVALID_PATH",
136 NVal::CreateInt32(env, static_cast<int32_t>(PolicyErrorCode::INVALID_PATH)).val_),
137 };
138 napi_value obj = nullptr;
139 napi_status status = napi_create_object(env, &obj);
140 if (status != napi_ok) {
141 HILOGE("Failed to create object at initializing InitPolicyErrorCode");
142 return;
143 }
144 status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
145 if (status != napi_ok) {
146 HILOGE("Failed to set properties of character at initializing InitPolicyErrorCode");
147 return;
148 }
149 status = napi_set_named_property(env, exports, propertyName, obj);
150 if (status != napi_ok) {
151 HILOGE("Failed to set direction property at initializing InitPolicyErrorCode");
152 return;
153 }
154 }
155
InitPolicyErrorResult(napi_env env,napi_value exports)156 void InitPolicyErrorResult(napi_env env, napi_value exports)
157 {
158 char className[] = "PolicyErrorResult";
159 napi_property_descriptor desc[] = {
160 DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_),
161 DECLARE_NAPI_STATIC_PROPERTY(
162 "code", NVal::CreateInt32(env, static_cast<int32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN)).val_),
163 DECLARE_NAPI_STATIC_PROPERTY("message", NVal::CreateUTF8String(env, "message").val_),
164 };
165 napi_value obj = nullptr;
166 napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr,
167 sizeof(desc) / sizeof(desc[0]), desc, &obj);
168 napi_create_object(env, &obj);
169 if (status != napi_ok) {
170 HILOGE("Failed to define class at initializing PolicyErrorResult");
171 return;
172 }
173 status = napi_set_named_property(env, exports, className, obj);
174 if (status != napi_ok) {
175 HILOGE("Failed to set direction property at initializing PolicyErrorResult");
176 return;
177 }
178 }
179
InitPolicyInfo(napi_env env,napi_value exports)180 void InitPolicyInfo(napi_env env, napi_value exports)
181 {
182 char className[] = "PolicyInfo";
183 napi_property_descriptor desc[] = {
184 DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_),
185 DECLARE_NAPI_STATIC_PROPERTY("operationMode",
186 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::READ_MODE)).val_),
187 };
188 napi_value obj = nullptr;
189 napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr,
190 sizeof(desc) / sizeof(desc[0]), desc, &obj);
191 napi_create_object(env, &obj);
192 if (status != napi_ok) {
193 HILOGE("Failed to define class at initializing PolicyFlag");
194 return;
195 }
196 status = napi_set_named_property(env, exports, className, obj);
197 if (status != napi_ok) {
198 HILOGE("Failed to set direction property at initializing PolicyFlag");
199 return;
200 }
201 }
202
InitPathPolicyInfo(napi_env env,napi_value exports)203 void InitPathPolicyInfo(napi_env env, napi_value exports)
204 {
205 char className[] = "PathPolicyInfo";
206 napi_property_descriptor desc[] = {
207 DECLARE_NAPI_STATIC_PROPERTY("path", NVal::CreateUTF8String(env, "path").val_),
208 DECLARE_NAPI_STATIC_PROPERTY("operationMode",
209 NVal::CreateUint32(env, static_cast<uint32_t>(OperationMode::READ_MODE)).val_),
210 };
211 napi_value obj = nullptr;
212 napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr,
213 sizeof(desc) / sizeof(desc[0]), desc, &obj);
214 napi_create_object(env, &obj);
215 if (status != napi_ok) {
216 HILOGE("Failed to define class at initializing PathPolicyInfo");
217 return;
218 }
219 status = napi_set_named_property(env, exports, className, obj);
220 if (status != napi_ok) {
221 HILOGE("Failed to set direction property at initializing PathPolicyInfo");
222 return;
223 }
224 }
225
226 NAPI_MODULE(fileshare, FileShareExport)
227 } // namespace ModuleFileShare
228 } // namespace AppFileService
229 } // namespace OHOS
230