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
16 #include <ani.h>
17 #include <array>
18
19 #include "access_ani.h"
20 #include "ani_signature.h"
21 #include "atomicfile_ani.h"
22 #include "bind_function.h"
23 #include "close_ani.h"
24 #include "copy_ani.h"
25 #include "copy_dir_ani.h"
26 #include "copy_file_ani.h"
27 #include "create_randomaccessfile_ani.h"
28 #include "create_stream_ani.h"
29 #include "dup_ani.h"
30 #include "fdatasync_ani.h"
31 #include "fdopen_stream_ani.h"
32 #include "file_ani.h"
33 #include "filemgmt_libhilog.h"
34 #include "fs_watcher_ani.h"
35 #include "fsync_ani.h"
36 #include "listfile_ani.h"
37 #include "lseek_ani.h"
38 #include "lstat_ani.h"
39 #include "mkdir_ani.h"
40 #include "mkdtemp_ani.h"
41 #include "move_ani.h"
42 #include "movedir_ani.h"
43 #include "open_ani.h"
44 #include "randomaccessfile_ani.h"
45 #include "read_ani.h"
46 #include "read_lines_ani.h"
47 #include "read_text_ani.h"
48 #include "reader_iterator_ani.h"
49 #include "rename_ani.h"
50 #include "rmdir_ani.h"
51 #include "stat_ani.h"
52 #include "stream_ani.h"
53 #include "symlink_ani.h"
54 #include "task_signal_ani.h"
55 #include "truncate_ani.h"
56 #include "unlink_ani.h"
57 #include "utimes_ani.h"
58 #include "watcher_ani.h"
59 #include "write_ani.h"
60 #include "xattr_ani.h"
61
62 using namespace OHOS::FileManagement::ModuleFileIO::ANI;
63 using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
64
BindRafFileMethods(ani_env * env)65 static ani_status BindRafFileMethods(ani_env *env)
66 {
67 auto classDesc = FS::RandomAccessFileInner::classDesc.c_str();
68
69 std::array methods = {
70 ani_native_function {
71 "setFilePointer0", nullptr, reinterpret_cast<void *>(RandomAccessFileAni::SetFilePointer) },
72 ani_native_function { "close", nullptr, reinterpret_cast<void *>(RandomAccessFileAni::Close) },
73 ani_native_function { "writeSync0", nullptr, reinterpret_cast<void *>(RandomAccessFileAni::WriteSync) },
74 ani_native_function { "readSync0", nullptr, reinterpret_cast<void *>(RandomAccessFileAni::ReadSync) },
75 };
76
77 return BindClass(env, classDesc, methods);
78 }
79
BindWatcherClassMethods(ani_env * env)80 static ani_status BindWatcherClassMethods(ani_env *env)
81 {
82 auto classDesc = FS::WatcherInner::classDesc.c_str();
83
84 std::array methods = {
85 ani_native_function { "start", nullptr, reinterpret_cast<void *>(FsWatcherAni::Start) },
86 ani_native_function { "stop", nullptr, reinterpret_cast<void *>(FsWatcherAni::Stop) },
87 };
88
89 return BindClass(env, classDesc, methods);
90 }
91
BindFileMethods(ani_env * env)92 static ani_status BindFileMethods(ani_env *env)
93 {
94 auto classDesc = FS::FileInner::classDesc.c_str();
95
96 std::array methods = {
97 ani_native_function { "getParent", nullptr, reinterpret_cast<void *>(FileAni::GetParent) },
98 ani_native_function { "lockSync", nullptr, reinterpret_cast<void *>(FileAni::LockSync) },
99 ani_native_function { "tryLock", nullptr, reinterpret_cast<void *>(FileAni::TryLock) },
100 ani_native_function { "unlock", nullptr, reinterpret_cast<void *>(FileAni::UnLock) },
101 };
102
103 return BindClass(env, classDesc, methods);
104 }
105
BindReaderIteratorMethods(ani_env * env)106 static ani_status BindReaderIteratorMethods(ani_env *env)
107 {
108 auto classDesc = FS::ReaderIteratorInner::classDesc.c_str();
109
110 std::array methods = {
111 ani_native_function { "next", nullptr, reinterpret_cast<void *>(ReaderIteratorAni::Next) },
112 };
113
114 return BindClass(env, classDesc, methods);
115 }
116
BindStatClassMethods(ani_env * env)117 static ani_status BindStatClassMethods(ani_env *env)
118 {
119 auto classDesc = FS::StatInner::classDesc.c_str();
120
121 std::array methods = {
122 ani_native_function { "isBlockDevice", nullptr, reinterpret_cast<void *>(StatAni::IsBlockDevice) },
123 ani_native_function { "isCharacterDevice", nullptr, reinterpret_cast<void *>(StatAni::IsCharacterDevice) },
124 ani_native_function { "isDirectory", nullptr, reinterpret_cast<void *>(StatAni::IsDirectory) },
125 ani_native_function { "isFIFO", nullptr, reinterpret_cast<void *>(StatAni::IsFIFO) },
126 ani_native_function { "isFile", nullptr, reinterpret_cast<void *>(StatAni::IsFile) },
127 ani_native_function { "isSocket", nullptr, reinterpret_cast<void *>(StatAni::IsSocket) },
128 ani_native_function { "isSymbolicLink", nullptr, reinterpret_cast<void *>(StatAni::IsSymbolicLink) },
129 };
130
131 return BindClass(env, classDesc, methods);
132 }
133
BindStreamMethods(ani_env * env)134 static ani_status BindStreamMethods(ani_env *env)
135 {
136 auto classDesc = FS::StreamInner::classDesc.c_str();
137
138 std::array methods = {
139 ani_native_function { "closeSync", nullptr, reinterpret_cast<void *>(StreamAni::Close) },
140 ani_native_function { "flushSync", nullptr, reinterpret_cast<void *>(StreamAni::Flush) },
141 ani_native_function { "readSync", nullptr, reinterpret_cast<void *>(StreamAni::Read) },
142 ani_native_function { "writeSync", nullptr, reinterpret_cast<void *>(StreamAni::Write) },
143 ani_native_function { "seek", nullptr, reinterpret_cast<void *>(StreamAni::Seek) },
144 };
145
146 return BindClass(env, classDesc, methods);
147 }
148
BindTaskSignalClassMethods(ani_env * env)149 static ani_status BindTaskSignalClassMethods(ani_env *env)
150 {
151 auto classDesc = FS::TaskSignal::classDesc.c_str();
152 auto ctorDesc = FS::TaskSignal::ctorDesc.c_str();
153 auto ctorSig = FS::TaskSignal::ctorSig.c_str();
154
155 std::array methods = {
156 ani_native_function { "cancel", nullptr, reinterpret_cast<void *>(TaskSignalAni::Cancel) },
157 ani_native_function { "onCancelNative", nullptr, reinterpret_cast<void *>(TaskSignalAni::OnCancel) },
158 ani_native_function { ctorDesc, ctorSig, reinterpret_cast<void *>(TaskSignalAni::Constructor) },
159 };
160
161 return BindClass(env, classDesc, methods);
162 }
163
BindAtomicFileMethods(ani_env * env)164 static ani_status BindAtomicFileMethods(ani_env *env)
165 {
166 auto classDesc = FS::AtomicFile::classDesc.c_str();
167 auto ctorDesc = FS::AtomicFile::ctorDesc.c_str();
168 auto ctorSig = FS::AtomicFile::ctorSig.c_str();
169
170 std::array methods = {
171 ani_native_function { "getPath", nullptr, reinterpret_cast<void *>(AtomicFileAni::GetPath) },
172 ani_native_function { "getBaseFile", nullptr, reinterpret_cast<void *>(AtomicFileAni::GetBaseFile) },
173 ani_native_function { "readFully", nullptr, reinterpret_cast<void *>(AtomicFileAni::ReadFully) },
174 ani_native_function { "delete", nullptr, reinterpret_cast<void *>(AtomicFileAni::Delete) },
175 ani_native_function { ctorDesc, ctorSig, reinterpret_cast<void *>(AtomicFileAni::Constructor) },
176 };
177
178 return BindClass(env, classDesc, methods);
179 }
180 const static string mkdirCtorSig0 = Builder::BuildSignatureDescriptor({ BuiltInTypes::stringType });
181 const static string mkdirCtorSig1 =
182 Builder::BuildSignatureDescriptor({ BuiltInTypes::stringType, BasicTypes::booleanType });
183
BindStaticMethods(ani_env * env)184 static ani_status BindStaticMethods(ani_env *env)
185 {
186 auto classDesc = Impl::FileIoImpl::classDesc.c_str();
187
188 std::array methods = {
189 ani_native_function { "closeSync", nullptr, reinterpret_cast<void *>(CloseAni::CloseSync) },
190 ani_native_function { "copyDirSync", nullptr, reinterpret_cast<void *>(CopyDirAni::CopyDirSync) },
191 ani_native_function { "copyFileSync", nullptr, reinterpret_cast<void *>(CopyFileAni::CopyFileSync) },
192 ani_native_function { "copySync", nullptr, reinterpret_cast<void *>(CopyAni::CopySync) },
193 ani_native_function { "createRandomAccessFileSync", nullptr,
194 reinterpret_cast<void *>(CreateRandomAccessFileAni::CreateRandomAccessFileSync) },
195 ani_native_function {
196 "createStreamSync", nullptr, reinterpret_cast<void *>(CreateStreamAni::CreateStreamSync) },
197 ani_native_function { "createWatcherSync", nullptr, reinterpret_cast<void *>(WatcherAni::CreateWatcherSync) },
198 ani_native_function { "doAccessSync", nullptr, reinterpret_cast<void *>(AccessAni::AccessSync3) },
199 ani_native_function { "dup", nullptr, reinterpret_cast<void *>(DupAni::Dup) },
200 ani_native_function { "fdatasyncSync", nullptr, reinterpret_cast<void *>(FDataSyncAni::FDataSyncSync) },
201 ani_native_function {
202 "fdopenStreamSync", nullptr, reinterpret_cast<void *>(FdopenStreamAni::FdopenStreamSync) },
203 ani_native_function { "fsyncSync", nullptr, reinterpret_cast<void *>(FsyncAni::FsyncSync) },
204 ani_native_function { "getxattrSync", nullptr, reinterpret_cast<void *>(XattrAni::GetXattrSync) },
205 ani_native_function { "listFileSync", nullptr, reinterpret_cast<void *>(ListFileAni::ListFileSync) },
206 ani_native_function { "lseekSync", nullptr, reinterpret_cast<void *>(LseekAni::LseekSync) },
207 ani_native_function { "lstatSync", nullptr, reinterpret_cast<void *>(LstatAni::LstatSync) },
208 ani_native_function { "mkdirSync", mkdirCtorSig0.c_str(), reinterpret_cast<void *>(MkdirkAni::MkdirSync0) },
209 ani_native_function { "mkdirSync", mkdirCtorSig1.c_str(), reinterpret_cast<void *>(MkdirkAni::MkdirSync1) },
210 ani_native_function { "mkdtempSync", nullptr, reinterpret_cast<void *>(MkdtempAni::MkdtempSync) },
211 ani_native_function { "movedirSync", nullptr, reinterpret_cast<void *>(MoveDirAni::MoveDirSync) },
212 ani_native_function { "moveFileSync", nullptr, reinterpret_cast<void *>(MoveAni::MoveFileSync) },
213 ani_native_function { "openSync", nullptr, reinterpret_cast<void *>(OpenAni::OpenSync) },
214 ani_native_function { "readlinesSync", nullptr, reinterpret_cast<void *>(ReadLinesAni::ReadLinesSync) },
215 ani_native_function { "readSync", nullptr, reinterpret_cast<void *>(ReadAni::ReadSync) },
216 ani_native_function { "readTextSync", nullptr, reinterpret_cast<void *>(ReadTextAni::ReadTextSync) },
217 ani_native_function { "renameSync", nullptr, reinterpret_cast<void *>(RenameAni::RenameSync) },
218 ani_native_function { "rmdirSync", nullptr, reinterpret_cast<void *>(RmdirAni::RmdirSync) },
219 ani_native_function { "setxattrSync", nullptr, reinterpret_cast<void *>(XattrAni::SetXattrSync) },
220 ani_native_function { "statSync", nullptr, reinterpret_cast<void *>(StatAni::StatSync) },
221 ani_native_function { "symlinkSync", nullptr, reinterpret_cast<void *>(SymlinkAni::SymlinkSync) },
222 ani_native_function { "truncateSync", nullptr, reinterpret_cast<void *>(TruncateAni::TruncateSync) },
223 ani_native_function { "unlinkSync", nullptr, reinterpret_cast<void *>(UnlinkAni::UnlinkSync) },
224 ani_native_function { "utimes", nullptr, reinterpret_cast<void *>(UtimesAni::Utimes) },
225 ani_native_function { "writeSync", nullptr, reinterpret_cast<void *>(WriteAni::WriteSync) },
226 };
227 return BindClass(env, classDesc, methods);
228 }
229
DoBindMethods(ani_env * env)230 static ani_status DoBindMethods(ani_env *env)
231 {
232 ani_status status;
233 if ((status = BindStaticMethods(env)) != ANI_OK) {
234 HILOGE("Cannot bind native static methods for BindStaticMethods!");
235 return status;
236 };
237
238 if ((status = BindFileMethods(env)) != ANI_OK) {
239 HILOGE("Cannot bind native methods for file Class");
240 return status;
241 };
242
243 if ((status = BindReaderIteratorMethods(env)) != ANI_OK) {
244 HILOGE("Cannot bind native methods for ReaderIterator Class");
245 return status;
246 };
247
248 if ((status = BindStatClassMethods(env)) != ANI_OK) {
249 HILOGE("Cannot bind native methods for Stat Class!");
250 return status;
251 };
252
253 if ((status = BindRafFileMethods(env)) != ANI_OK) {
254 HILOGE("Cannot bind native methods for RafFile Class");
255 return status;
256 };
257
258 if ((status = BindStreamMethods(env)) != ANI_OK) {
259 HILOGE("Cannot bind native methods for Stream Class!");
260 return status;
261 };
262
263 if ((status = BindTaskSignalClassMethods(env)) != ANI_OK) {
264 HILOGE("Cannot bind native methods for TaskSignal Class!");
265 return status;
266 };
267
268 if ((status = BindWatcherClassMethods(env)) != ANI_OK) {
269 HILOGE("Cannot bind native methods for Watcher Class");
270 return status;
271 };
272
273 if ((status = BindAtomicFileMethods(env)) != ANI_OK) {
274 HILOGE("Cannot bind native methods for AtomicFile Class!");
275 return status;
276 };
277
278 return ANI_OK;
279 }
280
ANI_Constructor(ani_vm * vm,uint32_t * result)281 ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
282 {
283 if (vm == nullptr) {
284 HILOGE("Invalid parameter vm");
285 return ANI_INVALID_ARGS;
286 }
287
288 if (result == nullptr) {
289 HILOGE("Invalid parameter result");
290 return ANI_INVALID_ARGS;
291 }
292
293 ani_env *env;
294 ani_status status = vm->GetEnv(ANI_VERSION_1, &env);
295 if (status != ANI_OK) {
296 HILOGE("Invalid ani version!");
297 return ANI_INVALID_VERSION;
298 }
299
300 status = DoBindMethods(env);
301 if (status != ANI_OK) {
302 return status;
303 }
304
305 *result = ANI_VERSION_1;
306 return ANI_OK;
307 }
308