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_proxy.h"
17
18 #include "file_access_framework_errno.h"
19 #include "hilog_wrapper.h"
20 #include "hitrace_meter.h"
21 #include "ipc_types.h"
22 #include "message_option.h"
23 #include "message_parcel.h"
24
25 namespace OHOS {
26 namespace FileAccessFwk {
OpenFile(const Uri & uri,const int flags,int & fd)27 int FileAccessExtProxy::OpenFile(const Uri &uri, const int flags, int &fd)
28 {
29 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OpenFile");
30 MessageParcel data;
31 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
32 HILOG_ERROR("WriteInterfaceToken failed");
33 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
34 return E_IPCS;
35 }
36
37 if (!data.WriteParcelable(&uri)) {
38 HILOG_ERROR("fail to WriteParcelable uri");
39 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
40 return E_IPCS;
41 }
42
43 if (!data.WriteInt32(flags)) {
44 HILOG_ERROR("fail to WriteInt32 flags");
45 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
46 return E_IPCS;
47 }
48
49 MessageParcel reply;
50 MessageOption option;
51 int err = Remote()->SendRequest(CMD_OPEN_FILE, data, reply, option);
52 if (err != ERR_OK) {
53 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
54 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
55 return err;
56 }
57
58 int ret = E_IPCS;
59 if (!reply.ReadInt32(ret)) {
60 HILOG_ERROR("fail to ReadInt32 ret");
61 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
62 return E_IPCS;
63 }
64
65 if (ret != ERR_OK) {
66 HILOG_ERROR("OpenFile operation failed ret : %{public}d", ret);
67 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
68 return ret;
69 }
70
71 fd = reply.ReadFileDescriptor();
72 if (fd < ERR_OK) {
73 HILOG_ERROR("fail to ReadFileDescriptor fd: %{public}d", fd);
74 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
75 return E_GETRESULT;
76 }
77
78 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
79 return ERR_OK;
80 }
81
CreateFile(const Uri & parent,const std::string & displayName,Uri & newFile)82 int FileAccessExtProxy::CreateFile(const Uri &parent, const std::string &displayName, Uri &newFile)
83 {
84 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CreateFile");
85 MessageParcel data;
86 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
87 HILOG_ERROR("WriteInterfaceToken failed");
88 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
89 return E_IPCS;
90 }
91
92 if (!data.WriteParcelable(&parent)) {
93 HILOG_ERROR("fail to WriteParcelable parent");
94 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
95 return E_IPCS;
96 }
97
98 if (!data.WriteString(displayName)) {
99 HILOG_ERROR("fail to WriteString displayName");
100 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
101 return E_IPCS;
102 }
103
104 MessageParcel reply;
105 MessageOption option;
106 int err = Remote()->SendRequest(CMD_CREATE_FILE, data, reply, option);
107 if (err != ERR_OK) {
108 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
109 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
110 return err;
111 }
112
113 int ret = E_IPCS;
114 if (!reply.ReadInt32(ret)) {
115 HILOG_ERROR("fail to ReadInt32 ret");
116 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
117 return E_IPCS;
118 }
119
120 if (ret != ERR_OK) {
121 HILOG_ERROR("CreateFile operation failed ret : %{public}d", ret);
122 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
123 return ret;
124 }
125
126 std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
127 if (tempUri == nullptr) {
128 HILOG_ERROR("ReadParcelable value is nullptr.");
129 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
130 return E_IPCS;
131 }
132
133 newFile = Uri(*tempUri);
134 if (newFile.ToString().empty()) {
135 HILOG_ERROR("get uri is empty.");
136 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
137 return E_GETRESULT;
138 }
139
140 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
141 return ERR_OK;
142 }
143
Mkdir(const Uri & parent,const std::string & displayName,Uri & newFile)144 int FileAccessExtProxy::Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile)
145 {
146 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Mkdir");
147 MessageParcel data;
148 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
149 HILOG_ERROR("WriteInterfaceToken failed");
150 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
151 return E_IPCS;
152 }
153
154 if (!data.WriteParcelable(&parent)) {
155 HILOG_ERROR("fail to WriteParcelable parent");
156 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
157 return E_IPCS;
158 }
159
160 if (!data.WriteString(displayName)) {
161 HILOG_ERROR("fail to WriteString displayName");
162 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
163 return E_IPCS;
164 }
165
166 MessageParcel reply;
167 MessageOption option;
168 int err = Remote()->SendRequest(CMD_MKDIR, data, reply, option);
169 if (err != ERR_OK) {
170 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
171 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
172 return err;
173 }
174
175 int ret = E_IPCS;
176 if (!reply.ReadInt32(ret)) {
177 HILOG_ERROR("fail to ReadInt32 ret");
178 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
179 return E_IPCS;
180 }
181
182 if (ret != ERR_OK) {
183 HILOG_ERROR("Mkdir operation failed ret : %{public}d", ret);
184 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
185 return ret;
186 }
187
188 std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
189 if (tempUri == nullptr) {
190 HILOG_ERROR("ReadParcelable value is nullptr.");
191 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
192 return E_IPCS;
193 }
194
195 newFile = Uri(*tempUri);
196 if (newFile.ToString().empty()) {
197 HILOG_ERROR("get uri is empty.");
198 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
199 return E_GETRESULT;
200 }
201
202 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
203 return ERR_OK;
204 }
205
Delete(const Uri & sourceFile)206 int FileAccessExtProxy::Delete(const Uri &sourceFile)
207 {
208 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Delete");
209 MessageParcel data;
210 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
211 HILOG_ERROR("WriteInterfaceToken failed");
212 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
213 return E_IPCS;
214 }
215
216 if (!data.WriteParcelable(&sourceFile)) {
217 HILOG_ERROR("fail to WriteParcelable sourceFile");
218 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
219 return E_IPCS;
220 }
221
222 MessageParcel reply;
223 MessageOption option;
224 int err = Remote()->SendRequest(CMD_DELETE, data, reply, option);
225 if (err != ERR_OK) {
226 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
227 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
228 return err;
229 }
230
231 int ret = E_IPCS;
232 if (!reply.ReadInt32(ret)) {
233 HILOG_ERROR("fail to ReadInt32 ret");
234 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
235 return E_IPCS;
236 }
237
238 if (ret != ERR_OK) {
239 HILOG_ERROR("Delete operation failed ret : %{public}d", ret);
240 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
241 return ret;
242 }
243
244 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
245 return ERR_OK;
246 }
247
Move(const Uri & sourceFile,const Uri & targetParent,Uri & newFile)248 int FileAccessExtProxy::Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile)
249 {
250 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Move");
251 MessageParcel data;
252 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
253 HILOG_ERROR("WriteInterfaceToken failed");
254 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
255 return E_IPCS;
256 }
257
258 if (!data.WriteParcelable(&sourceFile)) {
259 HILOG_ERROR("fail to WriteParcelable sourceFile");
260 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
261 return E_IPCS;
262 }
263
264 if (!data.WriteParcelable(&targetParent)) {
265 HILOG_ERROR("fail to WriteParcelable targetParent");
266 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
267 return E_IPCS;
268 }
269
270 MessageParcel reply;
271 MessageOption option;
272 int err = Remote()->SendRequest(CMD_MOVE, data, reply, option);
273 if (err != ERR_OK) {
274 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
275 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
276 return err;
277 }
278
279 int ret = E_IPCS;
280 if (!reply.ReadInt32(ret)) {
281 HILOG_ERROR("fail to ReadInt32 ret");
282 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
283 return E_IPCS;
284 }
285
286 if (ret != ERR_OK) {
287 HILOG_ERROR("Move operation failed ret : %{public}d", ret);
288 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
289 return ret;
290 }
291
292 std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
293 if (tempUri == nullptr) {
294 HILOG_ERROR("ReadParcelable value is nullptr.");
295 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
296 return E_IPCS;
297 }
298
299 newFile = Uri(*tempUri);
300 if (newFile.ToString().empty()) {
301 HILOG_ERROR("get uri is empty.");
302 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
303 return E_GETRESULT;
304 }
305
306 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
307 return ERR_OK;
308 }
309
Rename(const Uri & sourceFile,const std::string & displayName,Uri & newFile)310 int FileAccessExtProxy::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile)
311 {
312 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename");
313 MessageParcel data;
314 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
315 HILOG_ERROR("WriteInterfaceToken failed");
316 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
317 return E_IPCS;
318 }
319
320 if (!data.WriteParcelable(&sourceFile)) {
321 HILOG_ERROR("fail to WriteParcelable sourceFile");
322 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
323 return E_IPCS;
324 }
325
326 if (!data.WriteString(displayName)) {
327 HILOG_ERROR("fail to WriteString displayName");
328 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
329 return E_IPCS;
330 }
331
332 MessageParcel reply;
333 MessageOption option;
334 int err = Remote()->SendRequest(CMD_RENAME, data, reply, option);
335 if (err != ERR_OK) {
336 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
337 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
338 return err;
339 }
340
341 int ret = E_IPCS;
342 if (!reply.ReadInt32(ret)) {
343 HILOG_ERROR("fail to ReadInt32 ret");
344 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
345 return E_IPCS;
346 }
347
348 if (ret != ERR_OK) {
349 HILOG_ERROR("Rename operation failed ret : %{public}d", ret);
350 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
351 return ret;
352 }
353
354 std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
355 if (tempUri == nullptr) {
356 HILOG_ERROR("ReadParcelable value is nullptr.");
357 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
358 return E_IPCS;
359 }
360
361 newFile = Uri(*tempUri);
362 if (newFile.ToString().empty()) {
363 HILOG_ERROR("get uri is empty.");
364 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
365 return E_GETRESULT;
366 }
367
368 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
369 return ERR_OK;
370 }
371
GetListFileResult(MessageParcel & reply,std::vector<FileInfo> & fileInfoVec)372 static int GetListFileResult(MessageParcel &reply, std::vector<FileInfo> &fileInfoVec)
373 {
374 int ret = E_IPCS;
375 if (!reply.ReadInt32(ret)) {
376 HILOG_ERROR("fail to ReadInt32 ret");
377 return E_IPCS;
378 }
379
380 if (ret != ERR_OK) {
381 HILOG_ERROR("ListFile operation failed ret : %{public}d", ret);
382 return ret;
383 }
384
385 int64_t count = 0;
386 if (!reply.ReadInt64(count)) {
387 HILOG_ERROR("ListFile operation failed to Read count");
388 return E_IPCS;
389 }
390
391 fileInfoVec.clear();
392 for (int64_t i = 0; i < count; i++) {
393 std::unique_ptr<FileInfo> fileInfoPtr(reply.ReadParcelable<FileInfo>());
394 if (fileInfoPtr != nullptr) {
395 fileInfoVec.push_back(*fileInfoPtr);
396 }
397 }
398 return ERR_OK;
399 }
400
ListFile(const FileInfo & fileInfo,const int64_t offset,const int64_t maxCount,const FileFilter & filter,std::vector<FileInfo> & fileInfoVec)401 int FileAccessExtProxy::ListFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount,
402 const FileFilter &filter, std::vector<FileInfo> &fileInfoVec)
403 {
404 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ListFile");
405 MessageParcel data;
406 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
407 HILOG_ERROR("WriteInterfaceToken failed");
408 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
409 return E_IPCS;
410 }
411
412 if (!data.WriteParcelable(&fileInfo)) {
413 HILOG_ERROR("fail to WriteParcelable fileInfo");
414 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
415 return E_IPCS;
416 }
417
418 if (!data.WriteInt64(offset)) {
419 HILOG_ERROR("fail to WriteInt64 offset");
420 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
421 return E_IPCS;
422 }
423
424 if (!data.WriteInt64(maxCount)) {
425 HILOG_ERROR("fail to WriteInt64 maxCount");
426 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
427 return E_IPCS;
428 }
429
430 if (!data.WriteParcelable(&filter)) {
431 HILOG_ERROR("fail to WriteParcelable filter");
432 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
433 return E_IPCS;
434 }
435
436 MessageParcel reply;
437 MessageOption option;
438 int err = Remote()->SendRequest(CMD_LIST_FILE, data, reply, option);
439 if (err != ERR_OK) {
440 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
441 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
442 return err;
443 }
444
445 err = GetListFileResult(reply, fileInfoVec);
446 if (err != ERR_OK) {
447 HILOG_ERROR("fail to GetListFileResult. err: %{public}d", err);
448 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
449 return err;
450 }
451
452 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
453 return ERR_OK;
454 }
455
ScanFile(const FileInfo & fileInfo,const int64_t offset,const int64_t maxCount,const FileFilter & filter,std::vector<FileInfo> & fileInfoVec)456 int FileAccessExtProxy::ScanFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount,
457 const FileFilter &filter, std::vector<FileInfo> &fileInfoVec)
458 {
459 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ScanFile");
460 MessageParcel data;
461 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
462 HILOG_ERROR("WriteInterfaceToken failed");
463 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
464 return E_IPCS;
465 }
466
467 if (!data.WriteParcelable(&fileInfo)) {
468 HILOG_ERROR("fail to WriteParcelable fileInfo");
469 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
470 return E_IPCS;
471 }
472
473 if (!data.WriteInt64(offset)) {
474 HILOG_ERROR("fail to WriteInt64 offset");
475 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
476 return E_IPCS;
477 }
478
479 if (!data.WriteInt64(maxCount)) {
480 HILOG_ERROR("fail to WriteInt64 maxCount");
481 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
482 return E_IPCS;
483 }
484
485 if (!data.WriteParcelable(&filter)) {
486 HILOG_ERROR("fail to WriteParcelable filter");
487 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
488 return E_IPCS;
489 }
490
491 MessageParcel reply;
492 MessageOption option;
493 int err = Remote()->SendRequest(CMD_SCAN_FILE, data, reply, option);
494 if (err != ERR_OK) {
495 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
496 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
497 return err;
498 }
499
500 err = GetListFileResult(reply, fileInfoVec);
501 if (err != ERR_OK) {
502 HILOG_ERROR("fail to GetListFileResult. err: %{public}d", err);
503 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
504 return err;
505 }
506
507 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
508 return ERR_OK;
509 }
510
GetRoots(std::vector<RootInfo> & rootInfoVec)511 int FileAccessExtProxy::GetRoots(std::vector<RootInfo> &rootInfoVec)
512 {
513 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetRoots");
514 MessageParcel data;
515 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
516 HILOG_ERROR("WriteInterfaceToken failed");
517 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
518 return E_IPCS;
519 }
520
521 MessageParcel reply;
522 MessageOption option;
523 int err = Remote()->SendRequest(CMD_GET_ROOTS, data, reply, option);
524 if (err != ERR_OK) {
525 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
526 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
527 return err;
528 }
529
530 int ret = E_IPCS;
531 if (!reply.ReadInt32(ret)) {
532 HILOG_ERROR("fail to ReadInt32 ret");
533 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
534 return E_IPCS;
535 }
536
537 if (ret != ERR_OK) {
538 HILOG_ERROR("GetRoots operation failed ret : %{public}d", ret);
539 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
540 return ret;
541 }
542
543 uint64_t count = 0;
544 if (!reply.ReadUint64(count)) {
545 HILOG_ERROR("GetRoots operation failed to Read count");
546 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
547 return E_IPCS;
548 }
549
550 rootInfoVec.clear();
551 for (uint64_t i = 0; i < count; i++) {
552 std::unique_ptr<RootInfo> rootInfoPtr(reply.ReadParcelable<RootInfo>());
553 if (rootInfoPtr != nullptr) {
554 rootInfoVec.push_back(*rootInfoPtr);
555 }
556 }
557
558 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
559 return ERR_OK;
560 }
561
UriToFileInfo(const Uri & selectFile,FileInfo & fileInfo)562 int FileAccessExtProxy::UriToFileInfo(const Uri &selectFile, FileInfo &fileInfo)
563 {
564 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UriToFileInfo");
565 MessageParcel data;
566 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
567 HILOG_ERROR("WriteInterfaceToken failed");
568 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
569 return E_IPCS;
570 }
571
572 if (!data.WriteParcelable(&selectFile)) {
573 HILOG_ERROR("fail to WriteParcelable selectFile");
574 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
575 return E_IPCS;
576 }
577
578 MessageParcel reply;
579 MessageOption option;
580 int err = Remote()->SendRequest(CMD_URI_TO_FILEINFO, data, reply, option);
581 if (err != ERR_OK) {
582 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
583 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
584 return err;
585 }
586
587 int ret = E_IPCS;
588 if (!reply.ReadInt32(ret)) {
589 HILOG_ERROR("fail to ReadInt32 ret");
590 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
591 return E_IPCS;
592 }
593
594 if (ret != ERR_OK) {
595 HILOG_ERROR("UriToFileInfo operation failed ret : %{public}d", ret);
596 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
597 return ret;
598 }
599
600 std::unique_ptr<FileInfo> fileInfoTemp(reply.ReadParcelable<FileInfo>());
601 if (fileInfoTemp == nullptr) {
602 HILOG_ERROR("ReadParcelable value is nullptr.");
603 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
604 return E_IPCS;
605 }
606
607 fileInfo = *fileInfoTemp;
608 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
609 return ERR_OK;
610 }
611
Access(const Uri & uri,bool & isExist)612 int FileAccessExtProxy::Access(const Uri &uri, bool &isExist)
613 {
614 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Access");
615 MessageParcel data;
616 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
617 HILOG_ERROR("WriteInterfaceToken failed");
618 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
619 return E_IPCS;
620 }
621
622 if (!data.WriteParcelable(&uri)) {
623 HILOG_ERROR("fail to WriteParcelable uri");
624 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
625 return E_IPCS;
626 }
627
628 MessageParcel reply;
629 MessageOption option;
630 int err = Remote()->SendRequest(CMD_ACCESS, data, reply, option);
631 if (err != ERR_OK) {
632 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
633 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
634 return err;
635 }
636
637 int ret = E_IPCS;
638 if (!reply.ReadInt32(ret)) {
639 HILOG_ERROR("fail to ReadInt32 ret");
640 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
641 return E_IPCS;
642 }
643
644 if (ret != ERR_OK) {
645 HILOG_ERROR("Access operation failed ret : %{public}d", ret);
646 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
647 return ret;
648 }
649
650 if (!reply.ReadBool(isExist)) {
651 HILOG_ERROR("fail to ReadInt32 isExist");
652 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
653 return E_IPCS;
654 }
655
656 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
657 return ERR_OK;
658 }
659
RegisterNotify(sptr<IFileAccessNotify> & notify)660 int FileAccessExtProxy::RegisterNotify(sptr<IFileAccessNotify> ¬ify)
661 {
662 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify");
663 MessageParcel data;
664 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
665 HILOG_ERROR("WriteInterfaceToken failed");
666 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
667 return E_IPCS;
668 }
669
670 if (!data.WriteRemoteObject(notify->AsObject())) {
671 HILOG_ERROR("write subscribe type or parcel failed.");
672 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
673 return E_IPCS;
674 }
675
676 MessageParcel reply;
677 MessageOption option;
678 int err = Remote()->SendRequest(CMD_REGISTER_NOTIFY, data, reply, option);
679 if (err != ERR_OK) {
680 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
681 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
682 return err;
683 }
684
685 int ret = E_IPCS;
686 if (!reply.ReadInt32(ret)) {
687 HILOG_ERROR("fail to ReadInt32 ret");
688 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
689 return E_IPCS;
690 }
691
692 if (ret != ERR_OK) {
693 HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret);
694 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
695 return ret;
696 }
697 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
698 return ERR_OK;
699 }
700
UnregisterNotify(sptr<IFileAccessNotify> & notify)701 int FileAccessExtProxy::UnregisterNotify(sptr<IFileAccessNotify> ¬ify)
702 {
703 StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify");
704 MessageParcel data;
705 if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
706 HILOG_ERROR("WriteInterfaceToken failed");
707 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
708 return E_IPCS;
709 }
710
711 if (!data.WriteRemoteObject(notify->AsObject())) {
712 HILOG_ERROR("write subscribe type or parcel failed.");
713 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
714 return E_IPCS;
715 }
716
717 MessageParcel reply;
718 MessageOption option;
719 int err = Remote()->SendRequest(CMD_UNREGISTER_NOTIFY, data, reply, option);
720 if (err != ERR_OK) {
721 HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
722 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
723 return err;
724 }
725
726 int ret = E_IPCS;
727 if (!reply.ReadInt32(ret)) {
728 HILOG_ERROR("fail to ReadInt32 ret");
729 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
730 return E_IPCS;
731 }
732
733 if (ret != ERR_OK) {
734 HILOG_ERROR("UnregisterNotify operation failed ret : %{public}d", ret);
735 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
736 return ret;
737 }
738 FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
739 return ERR_OK;
740 }
741 } // namespace FileAccessFwk
742 } // namespace OHOS
743