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
16 #include "file_access_ext_stub.h"
17
18 #include <cstdint>
19 #include <map>
20 #include <memory>
21 #include <string>
22 #include <utility>
23 #include <vector>
24
25 #include "access_token.h"
26 #include "accesstoken_kit.h"
27 #include "file_access_extension_info.h"
28 #include "file_access_framework_errno.h"
29 #include "hilog_wrapper.h"
30 #include "hitrace_meter.h"
31 #include "ipc_object_stub.h"
32 #include "ipc_skeleton.h"
33 #include "ipc_types.h"
34 #include "unique_fd.h"
35 #include "uri.h"
36
37 namespace OHOS {
38 namespace FileAccessFwk {
39 namespace {
40 const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_MANAGER";
41 }
FileAccessExtStub()42 FileAccessExtStub::FileAccessExtStub()
43 {
44 stubFuncMap_[CMD_OPEN_FILE] = &FileAccessExtStub::CmdOpenFile;
45 stubFuncMap_[CMD_CREATE_FILE] = &FileAccessExtStub::CmdCreateFile;
46 stubFuncMap_[CMD_MKDIR] = &FileAccessExtStub::CmdMkdir;
47 stubFuncMap_[CMD_DELETE] = &FileAccessExtStub::CmdDelete;
48 stubFuncMap_[CMD_MOVE] = &FileAccessExtStub::CmdMove;
49 stubFuncMap_[CMD_RENAME] = &FileAccessExtStub::CmdRename;
50 stubFuncMap_[CMD_LIST_FILE] = &FileAccessExtStub::CmdListFile;
51 stubFuncMap_[CMD_SCAN_FILE] = &FileAccessExtStub::CmdScanFile;
52 stubFuncMap_[CMD_GET_ROOTS] = &FileAccessExtStub::CmdGetRoots;
53 stubFuncMap_[CMD_ACCESS] = &FileAccessExtStub::CmdAccess;
54 stubFuncMap_[CMD_URI_TO_FILEINFO] = &FileAccessExtStub::CmdUriToFileInfo;
55 stubFuncMap_[CMD_REGISTER_NOTIFY] = &FileAccessExtStub::CmdRegisterNotify;
56 stubFuncMap_[CMD_UNREGISTER_NOTIFY] = &FileAccessExtStub::CmdUnregisterNotify;
57 }
58
~FileAccessExtStub()59 FileAccessExtStub::~FileAccessExtStub()
60 {
61 stubFuncMap_.clear();
62 }
63
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)64 int FileAccessExtStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
65 MessageOption& option)
66 {
67 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnRemoteRequest");
68 if (!CheckCallingPermission(FILE_ACCESS_PERMISSION)) {
69 HILOG_ERROR("permission error");
70 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
71 return E_PERMISSION;
72 }
73
74 std::u16string descriptor = FileAccessExtStub::GetDescriptor();
75 std::u16string remoteDescriptor = data.ReadInterfaceToken();
76 if (descriptor != remoteDescriptor) {
77 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
78 return ERR_INVALID_STATE;
79 }
80
81 const auto &itFunc = stubFuncMap_.find(code);
82 if (itFunc != stubFuncMap_.end()) {
83 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
84 return (this->*(itFunc->second))(data, reply);
85 }
86
87 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
88 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
89 }
90
CmdOpenFile(MessageParcel & data,MessageParcel & reply)91 ErrCode FileAccessExtStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply)
92 {
93 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdOpenFile");
94 std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
95 if (uri == nullptr) {
96 HILOG_ERROR("Parameter OpenFile fail to ReadParcelable uri");
97 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
98 return E_IPCS;
99 }
100
101 int flags = E_IPCS;
102 if (!data.ReadInt32(flags)) {
103 HILOG_ERROR("Parameter OpenFile fail to ReadInt32 flags");
104 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
105 return E_IPCS;
106 }
107
108 if (flags < 0) {
109 HILOG_ERROR("Parameter OpenFile flags is invalid");
110 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
111 return EINVAL;
112 }
113
114 int fd = -1;
115 int ret = OpenFile(*uri, flags, fd);
116 UniqueFd uniqueFd(fd);
117 if (!reply.WriteInt32(ret)) {
118 HILOG_ERROR("Parameter OpenFile fail to WriteInt32 ret");
119 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
120 return E_IPCS;
121 }
122
123 if (!reply.WriteFileDescriptor(fd)) {
124 HILOG_ERROR("Parameter OpenFile fail to WriteFileDescriptor fd");
125 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
126 return E_IPCS;
127 }
128
129 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
130 return ERR_OK;
131 }
132
CmdCreateFile(MessageParcel & data,MessageParcel & reply)133 ErrCode FileAccessExtStub::CmdCreateFile(MessageParcel &data, MessageParcel &reply)
134 {
135 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdCreateFile");
136 std::shared_ptr<Uri> parent(data.ReadParcelable<Uri>());
137 if (parent == nullptr) {
138 HILOG_ERROR("Parameter CreateFile fail to ReadParcelable parent");
139 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
140 return E_IPCS;
141 }
142
143 std::string displayName = "";
144 if (!data.ReadString(displayName)) {
145 HILOG_ERROR("Parameter CreateFile fail to ReadString displayName");
146 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
147 return E_IPCS;
148 }
149
150 if (displayName.empty()) {
151 HILOG_ERROR("Parameter CreateFile displayName is empty");
152 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
153 return EINVAL;
154 }
155
156 std::string newFile = "";
157 OHOS::Uri newFileUri(newFile);
158 int ret = CreateFile(*parent, displayName, newFileUri);
159 if (!reply.WriteInt32(ret)) {
160 HILOG_ERROR("Parameter CreateFile fail to WriteInt32 ret");
161 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
162 return E_IPCS;
163 }
164
165 if (!reply.WriteParcelable(&newFileUri)) {
166 HILOG_ERROR("Parameter CreateFile fail to WriteParcelable newFileUri");
167 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
168 return E_IPCS;
169 }
170
171 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
172 return ERR_OK;
173 }
174
CmdMkdir(MessageParcel & data,MessageParcel & reply)175 ErrCode FileAccessExtStub::CmdMkdir(MessageParcel &data, MessageParcel &reply)
176 {
177 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdMkdir");
178 std::shared_ptr<Uri> parent(data.ReadParcelable<Uri>());
179 if (parent == nullptr) {
180 HILOG_ERROR("Parameter Mkdir fail to ReadParcelable parent");
181 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
182 return E_IPCS;
183 }
184
185 std::string displayName = "";
186 if (!data.ReadString(displayName)) {
187 HILOG_ERROR("Parameter Mkdir fail to ReadString displayName");
188 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
189 return E_IPCS;
190 }
191
192 if (displayName.empty()) {
193 HILOG_ERROR("Parameter Mkdir displayName is empty");
194 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
195 return EINVAL;
196 }
197
198 std::string newFile = "";
199 OHOS::Uri newFileUri(newFile);
200 int ret = Mkdir(*parent, displayName, newFileUri);
201 if (!reply.WriteInt32(ret)) {
202 HILOG_ERROR("Parameter Mkdir fail to WriteInt32 ret");
203 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
204 return E_IPCS;
205 }
206
207 if (!reply.WriteParcelable(&newFileUri)) {
208 HILOG_ERROR("Parameter Mkdir fail to WriteParcelable newFileUri");
209 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
210 return E_IPCS;
211 }
212
213 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
214 return ERR_OK;
215 }
216
CmdDelete(MessageParcel & data,MessageParcel & reply)217 ErrCode FileAccessExtStub::CmdDelete(MessageParcel &data, MessageParcel &reply)
218 {
219 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdDelete");
220 std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
221 if (uri == nullptr) {
222 HILOG_ERROR("Parameter Delete fail to ReadParcelable uri");
223 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
224 return E_IPCS;
225 }
226
227 int ret = Delete(*uri);
228 if (!reply.WriteInt32(ret)) {
229 HILOG_ERROR("Parameter Delete fail to WriteInt32 ret");
230 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
231 return E_IPCS;
232 }
233
234 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
235 return ERR_OK;
236 }
237
CmdMove(MessageParcel & data,MessageParcel & reply)238 ErrCode FileAccessExtStub::CmdMove(MessageParcel &data, MessageParcel &reply)
239 {
240 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdMove");
241 std::shared_ptr<Uri> sourceFile(data.ReadParcelable<Uri>());
242 if (sourceFile == nullptr) {
243 HILOG_ERROR("Parameter Move fail to ReadParcelable sourceFile");
244 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
245 return E_IPCS;
246 }
247
248 std::shared_ptr<Uri> targetParent(data.ReadParcelable<Uri>());
249 if (targetParent == nullptr) {
250 HILOG_ERROR("Parameter Move fail to ReadParcelable targetParent");
251 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
252 return E_IPCS;
253 }
254
255 std::string newFile = "";
256 OHOS::Uri newFileUri(newFile);
257 int ret = Move(*sourceFile, *targetParent, newFileUri);
258 if (!reply.WriteInt32(ret)) {
259 HILOG_ERROR("Parameter Move fail to WriteInt32 ret");
260 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
261 return E_IPCS;
262 }
263
264 if (!reply.WriteParcelable(&newFileUri)) {
265 HILOG_ERROR("Parameter Move fail to WriteParcelable newFileUri");
266 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
267 return E_IPCS;
268 }
269
270 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
271 return ERR_OK;
272 }
273
CmdRename(MessageParcel & data,MessageParcel & reply)274 ErrCode FileAccessExtStub::CmdRename(MessageParcel &data, MessageParcel &reply)
275 {
276 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdRename");
277 std::shared_ptr<Uri> sourceFile(data.ReadParcelable<Uri>());
278 if (sourceFile == nullptr) {
279 HILOG_ERROR("Parameter Rename fail to ReadParcelable sourceFile");
280 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
281 return E_IPCS;
282 }
283
284 std::string displayName = "";
285 if (!data.ReadString(displayName)) {
286 HILOG_ERROR("Parameter Rename fail to ReadString displayName");
287 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
288 return E_IPCS;
289 }
290
291 if (displayName.empty()) {
292 HILOG_ERROR("Parameter Rename displayName is empty");
293 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
294 return EINVAL;
295 }
296
297 std::string newFile = "";
298 OHOS::Uri newFileUri(newFile);
299 int ret = Rename(*sourceFile, displayName, newFileUri);
300 if (!reply.WriteInt32(ret)) {
301 HILOG_ERROR("Parameter Rename fail to WriteInt32 ret");
302 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
303 return E_IPCS;
304 }
305
306 if (!reply.WriteParcelable(&newFileUri)) {
307 HILOG_ERROR("Parameter Rename fail to WriteParcelable newFileUri");
308 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
309 return E_IPCS;
310 }
311
312 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
313 return ERR_OK;
314 }
315
CmdListFile(MessageParcel & data,MessageParcel & reply)316 ErrCode FileAccessExtStub::CmdListFile(MessageParcel &data, MessageParcel &reply)
317 {
318 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdListFile");
319 std::shared_ptr<FileInfo> fileInfo(data.ReadParcelable<FileInfo>());
320 if (fileInfo == nullptr) {
321 HILOG_ERROR("Parameter ListFile fail to ReadParcelable fileInfo");
322 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
323 return E_IPCS;
324 }
325
326 int64_t offset = 0;
327 if (!data.ReadInt64(offset)) {
328 HILOG_ERROR("parameter ListFile offset is invalid");
329 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
330 return E_IPCS;
331 }
332
333 int64_t maxCount = 0;
334 if (!data.ReadInt64(maxCount)) {
335 HILOG_ERROR("parameter ListFile maxCount is invalid");
336 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
337 return E_IPCS;
338 }
339
340 std::shared_ptr<FileFilter> filter(data.ReadParcelable<FileFilter>());
341 if (filter == nullptr) {
342 HILOG_ERROR("parameter ListFile FileFilter is invalid");
343 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
344 return E_IPCS;
345 }
346
347 std::vector<FileInfo> fileInfoVec;
348 int ret = ListFile(*fileInfo, offset, maxCount, *filter, fileInfoVec);
349 if (!reply.WriteInt32(ret)) {
350 HILOG_ERROR("Parameter ListFile fail to WriteInt32 ret");
351 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
352 return E_IPCS;
353 }
354
355 int64_t count {fileInfoVec.size()};
356 if (!reply.WriteInt64(count)) {
357 HILOG_ERROR("Parameter ListFile fail to WriteInt64 count");
358 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
359 return E_IPCS;
360 }
361
362 for (const auto &fileInfo : fileInfoVec) {
363 if (!reply.WriteParcelable(&fileInfo)) {
364 HILOG_ERROR("parameter ListFile fail to WriteParcelable fileInfoVec");
365 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
366 return E_IPCS;
367 }
368 }
369
370 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
371 return ERR_OK;
372 }
373
CmdScanFile(MessageParcel & data,MessageParcel & reply)374 ErrCode FileAccessExtStub::CmdScanFile(MessageParcel &data, MessageParcel &reply)
375 {
376 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdScanFile");
377 std::shared_ptr<FileInfo> fileInfo(data.ReadParcelable<FileInfo>());
378 if (fileInfo == nullptr) {
379 HILOG_ERROR("Parameter ScanFile fail to ReadParcelable fileInfo");
380 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
381 return E_IPCS;
382 }
383
384 int64_t offset = 0;
385 if (!data.ReadInt64(offset)) {
386 HILOG_ERROR("parameter ScanFile offset is invalid");
387 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
388 return E_IPCS;
389 }
390
391 int64_t maxCount = 0;
392 if (!data.ReadInt64(maxCount)) {
393 HILOG_ERROR("parameter ScanFile maxCount is invalid");
394 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
395 return E_IPCS;
396 }
397
398 std::shared_ptr<FileFilter> filter(data.ReadParcelable<FileFilter>());
399 if (filter == nullptr) {
400 HILOG_ERROR("parameter ScanFile FileFilter is invalid");
401 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
402 return E_IPCS;
403 }
404
405 std::vector<FileInfo> fileInfoVec;
406 int ret = ScanFile(*fileInfo, offset, maxCount, *filter, fileInfoVec);
407 if (!reply.WriteInt32(ret)) {
408 HILOG_ERROR("Parameter ScanFile fail to WriteInt32 ret");
409 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
410 return E_IPCS;
411 }
412
413 int64_t count {fileInfoVec.size()};
414 if (!reply.WriteInt64(count)) {
415 HILOG_ERROR("Parameter ScanFile fail to WriteInt64 count");
416 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
417 return E_IPCS;
418 }
419
420 for (const auto &fileInfo : fileInfoVec) {
421 if (!reply.WriteParcelable(&fileInfo)) {
422 HILOG_ERROR("parameter ScanFile fail to WriteParcelable fileInfoVec");
423 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
424 return E_IPCS;
425 }
426 }
427
428 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
429 return ERR_OK;
430 }
431
CmdGetRoots(MessageParcel & data,MessageParcel & reply)432 ErrCode FileAccessExtStub::CmdGetRoots(MessageParcel &data, MessageParcel &reply)
433 {
434 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdGetRoots");
435
436 std::vector<RootInfo> rootInfoVec;
437 int ret = GetRoots(rootInfoVec);
438 if (!reply.WriteInt32(ret)) {
439 HILOG_ERROR("Parameter GetRoots fail to WriteInt32 ret");
440 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
441 return E_IPCS;
442 }
443
444 int64_t count {rootInfoVec.size()};
445 if (!reply.WriteInt64(count)) {
446 HILOG_ERROR("Parameter GetRoots fail to WriteInt64 count");
447 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
448 return E_IPCS;
449 }
450
451 for (const auto &rootInfo : rootInfoVec) {
452 if (!reply.WriteParcelable(&rootInfo)) {
453 HILOG_ERROR("parameter ListFile fail to WriteParcelable rootInfo");
454 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
455 return E_IPCS;
456 }
457 }
458
459 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
460 return ERR_OK;
461 }
462
CmdUriToFileInfo(MessageParcel & data,MessageParcel & reply)463 ErrCode FileAccessExtStub::CmdUriToFileInfo(MessageParcel &data, MessageParcel &reply)
464 {
465 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdUriToFileInfo");
466 std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
467 if (uri == nullptr) {
468 HILOG_ERROR("SelectFile uri is nullptr");
469 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
470 return E_URIS;
471 }
472
473 FileInfo fileInfoTemp;
474 int ret = UriToFileInfo(*uri, fileInfoTemp);
475 if (!reply.WriteInt32(ret)) {
476 HILOG_ERROR("Parameter UriToFileInfo fail to WriteInt32 ret");
477 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
478 return E_IPCS;
479 }
480
481 if (!reply.WriteParcelable(&fileInfoTemp)) {
482 HILOG_ERROR("Parameter UriToFileInfo fail to WriteParcelable fileInfoTemp");
483 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
484 return E_IPCS;
485 }
486
487 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
488 return ERR_OK;
489 }
490
CmdAccess(MessageParcel & data,MessageParcel & reply)491 ErrCode FileAccessExtStub::CmdAccess(MessageParcel &data, MessageParcel &reply)
492 {
493 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdAccess");
494 std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
495 if (uri == nullptr) {
496 HILOG_ERROR("Access uri is nullptr");
497 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
498 return E_URIS;
499 }
500
501 bool isExist = false;
502 int ret = Access(*uri, isExist);
503 if (!reply.WriteInt32(ret)) {
504 HILOG_ERROR("Parameter Access fail to WriteInt32 ret");
505 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
506 return E_IPCS;
507 }
508
509 if (!reply.WriteBool(isExist)) {
510 HILOG_ERROR("Parameter Access fail to WriteBool isExist");
511 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
512 return E_IPCS;
513 }
514
515 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
516 return ERR_OK;
517 }
518
CheckCallingPermission(const std::string & permission)519 bool FileAccessExtStub::CheckCallingPermission(const std::string &permission)
520 {
521 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CheckCallingPermission");
522 Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
523 int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission);
524 if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
525 HILOG_ERROR("FileAccessExtStub::CheckCallingPermission have no fileAccess permission");
526 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
527 return false;
528 }
529
530 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
531 return true;
532 }
533
CmdRegisterNotify(MessageParcel & data,MessageParcel & reply)534 ErrCode FileAccessExtStub::CmdRegisterNotify(MessageParcel &data, MessageParcel &reply)
535 {
536 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdRegisterNotify");
537 auto remote = data.ReadRemoteObject();
538 if (remote == nullptr) {
539 HILOG_INFO("get remote obj fail.");
540 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
541 return E_IPCS;
542 }
543
544 auto notify = iface_cast<IFileAccessNotify>(remote);
545 if (notify == nullptr) {
546 HILOG_INFO("get notify fail");
547 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
548 return E_IPCS;
549 }
550
551 int ret = RegisterNotify(notify);
552 if (!reply.WriteInt32(ret)) {
553 HILOG_ERROR("Parameter RegisterNotify fail to WriteInt32 ret");
554 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
555 return E_IPCS;
556 }
557 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
558 return ERR_OK;
559 }
560
CmdUnregisterNotify(MessageParcel & data,MessageParcel & reply)561 ErrCode FileAccessExtStub::CmdUnregisterNotify(MessageParcel &data, MessageParcel &reply)
562 {
563 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdUnregisterNotify");
564 auto remote = data.ReadRemoteObject();
565 if (remote == nullptr) {
566 HILOG_INFO("get remote obj fail.");
567 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
568 return E_IPCS;
569 }
570
571 auto notify = iface_cast<IFileAccessNotify>(remote);
572 if (notify == nullptr) {
573 HILOG_INFO("get notify fail");
574 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
575 return E_IPCS;
576 }
577
578 int ret = UnregisterNotify(notify);
579 if (!reply.WriteInt32(ret)) {
580 HILOG_ERROR("Parameter UnregisterNotify fail to WriteInt32 ret");
581 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
582 return E_IPCS;
583 }
584 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
585 return ERR_OK;
586 }
587 } // namespace FileAccessFwk
588 } // namespace OHOS