• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2021 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
16import fileAccess from '@ohos.file.fileAccess'
17import fileExtensionInfo from '@ohos.file.fileExtensionInfo';
18import worker from '@ohos.worker'
19import { logInfo, logError } from '../../../../../../common/src/main/ets/components/Utils/LogUtils'
20
21var TAG = 'DataWorker'
22const parentPort = worker.parentPort
23parentPort.onmessage = function (e) {
24  logInfo(TAG, 'DataWorker onMessage');
25  let data = e.data
26  logInfo(TAG, 'DataWorker onMessage ' + data.request_data);
27
28  let wantInfos = getFileAccessAbilityInfo();
29  logInfo(TAG, 'DataWorker onMessage getFileAccessAbilityInfo' + JSON.stringify(wantInfos));
30
31  let wantInfo = {
32    bundleName: "com.ohos.medialibrary.medialibrarydata",
33    abilityName: "FileExtensionAbility",
34  };
35  let fileAccessHelper = createFileAccessHelper(data, [wantInfo]);
36  logInfo(TAG, 'DataWorker onMessage createFileAccessHelper' + JSON.stringify(fileAccessHelper));
37
38  logInfo(TAG, 'DataWorker onMessage ' + data.request_data);
39  if (data.request_data == 'getRoot') {
40    getRoots(data, fileAccessHelper);
41  } else if (data.request_data == 'listFile') {
42    getFileInfo(data.path, fileAccessHelper).then((files) => {
43      listFile(data, files);
44    });
45  } else if (data.request_data == 'createFile') {
46    createFile(data, fileAccessHelper);
47  } else if (data.request_data == 'coverFile') {
48    coverFile(data, fileAccessHelper);
49  }
50}
51
52function getFileAccessAbilityInfo() {
53  let wantInfos = [];
54  try {
55    logInfo(TAG, 'fileAccess.getFileAccessAbilityInfo - start');
56    fileAccess.getFileAccessAbilityInfo().then((wants) => {
57      logInfo(TAG, 'fileAccess.getFileAccessAbilityInfo - end');
58      wantInfos = wants;
59    }).catch((error) => {
60      logError(TAG, 'getFileAccessAbilityInfo error: ' + error);
61    });
62  } catch (error) {
63    logError(TAG, 'getFileAccessAbilityInfo error: ' + error);
64  }
65  return wantInfos;
66}
67
68function createFileAccessHelper(data, wantInfos) {
69  logInfo(TAG, 'createFileAccessHelper : context ' + data.context + ' wantInfos ' + wantInfos);
70  let fileAccessHelper = null;
71  try {
72    logInfo(TAG, 'fileAccess.createFileAccessHelper - start');
73    fileAccessHelper = fileAccess.createFileAccessHelper(data.context, wantInfos);
74    logInfo(TAG, 'fileAccess.createFileAccessHelper - end');
75  } catch (error) {
76    logError(TAG, 'createFileAccessHelper error: ' + error);
77    return null;
78  }
79  return fileAccessHelper;
80}
81
82parentPort.onmessageerror = function () {
83  logInfo(TAG, 'onmessageerror');
84}
85
86parentPort.onerror = function (data) {
87  logInfo(TAG, 'onerror');
88}
89
90async function getFileInfo(path, fileAccessHelper) {
91  logInfo(TAG, 'getFileInfo path = ' + path);
92
93  let firstFileInfos = await getFirstFileInfos(fileAccessHelper);
94  let index = firstFileInfos.findIndex((fileInfo) => {
95    return fileInfo.uri == path;
96  })
97  if (index != -1) {
98    return firstFileInfos[index];
99  }
100
101  let fileInfo = findOtherFileInfo(fileAccessHelper, path, firstFileInfos);
102  return fileInfo;
103}
104
105async function getFirstFileInfos(fileAccessHelper) {
106  let rootIterator = null;
107  let rootInfos = [];
108  let isDone = false;
109  let rootInfo = null;
110  let fileInfos = [];
111  try {
112    logInfo(TAG, `fileAccessHelper.getRoots - start`);
113    rootIterator = await fileAccessHelper.getRoots();
114    logInfo(TAG, `fileAccessHelper.getRoots - end`);
115    if (!rootIterator) {
116      logInfo(TAG, `getFirstFileInfos return undefined`);
117    }
118    while (!isDone) {
119      let result = rootIterator.next();
120      isDone = result.done;
121      if (!isDone) {
122        rootInfos.push(result.value);
123      }
124    }
125
126    rootInfo = rootInfos[0];
127    isDone = false;
128    try {
129      logInfo(TAG, `rootInfo.listFile - start`);
130      let fileIterator = rootInfo.listFile();
131      logInfo(TAG, `rootInfo.listFile - end`);
132      if (!fileIterator) {
133        logInfo(TAG, `getFirstFileInfo fileIterator return undefined`);
134      }
135      while (!isDone) {
136        let result = fileIterator.next();
137        isDone = result.done;
138        if (!isDone) {
139          fileInfos.push(result.value);
140        }
141      }
142    } catch (error) {
143      logError(TAG, `getFirstFileInfo fileIterator error : ` + error);
144    }
145  } catch (error) {
146    logError(TAG, `getFirstFileInfo error : ` + error);
147  }
148  return fileInfos;
149}
150
151function findOtherFileInfo(fileAccessHelper, path, fileInfos) {
152  if (fileInfos.length == 0) {
153    return null;
154  }
155  logInfo(TAG, 'findOtherFileInfo' + path + fileInfos.length);
156  let index = fileInfos.findIndex((fileInfo) => {
157    return fileInfo.uri == path;
158  });
159  if (index != -1) {
160    return fileInfos[index];
161  }
162
163  let arr = fileInfos;
164  for (let i = 0; i < arr.length; i++) {
165    let fileInfo = arr[i];
166    let files = getOtherFileInfos(fileInfo);
167    if (files.length == 0) {
168      continue;
169    }
170    let file = findOtherFileInfo(fileAccessHelper, path, files);
171    if (JSON.stringify(file) !== 'undefined') {
172      return file;
173    }
174  }
175}
176
177function getOtherFileInfos(fileInfo) {
178  logInfo(TAG, `getOtherFileInfos ` + JSON.stringify(fileInfo) + fileInfo.uri);
179  let subFileInfos = [];
180  let isDone = false;
181  if ((fileInfo.mode & fileExtensionInfo.DocumentFlag.REPRESENTS_FILE) == fileExtensionInfo.DocumentFlag.REPRESENTS_FILE) {
182    logInfo(TAG, `getOtherFileInfos file cannot listFile`);
183  }
184  try {
185    logInfo(TAG, `fileInfo.listFile - start`);
186    let fileIterator = fileInfo.listFile();
187    logInfo(TAG, `fileInfo.listFile - end`);
188    if (!fileIterator) {
189      logInfo(TAG, `getOtherFileInfos fileInfo return undefined`);
190    }
191    while (!isDone) {
192      let result = fileIterator.next();
193      isDone = result.done;
194      if (!isDone) {
195        subFileInfos.push(result.value);
196      }
197    }
198  } catch (error) {
199    logError(TAG, `getOtherFileInfos fileInfo error : ` + error);
200  }
201  return subFileInfos;
202}
203
204function getRoots(data, fileAccessHelper) {
205  logInfo(TAG, `getRoots ` + JSON.stringify(data));
206  let rootIterator = null;
207  let rootInfos = [];
208  let isDone = false;
209  let rootInfo = null;
210  try {
211    rootIterator = null;
212    logInfo(TAG, `fileAccessHelper.getRoots - start`);
213    fileAccessHelper.getRoots().then(iterator => {
214      logInfo(TAG, `fileAccessHelper.getRoots - end`);
215      rootIterator = iterator;
216      if (!rootIterator) {
217        logInfo(TAG, `getRoots rootIterator return undefined`);
218      }
219      while (!isDone) {
220        let result = rootIterator.next();
221        isDone = result.done;
222        if (!isDone) {
223          rootInfos.push(result.value);
224        }
225      }
226
227      rootInfo = rootInfos[0];
228      let fileInfos = [];
229      let files = [];
230      isDone = false;
231      try {
232        logInfo(TAG, `rootInfo.listFile - start`);
233        let fileIterator = rootInfo.listFile();
234        logInfo(TAG, `rootInfo.listFile - start`);
235        if (!fileIterator) {
236          logInfo(TAG, `getListFile fileIterator return undefined`);
237        }
238        while (!isDone) {
239          let result = fileIterator.next();
240          isDone = result.done;
241          if (!isDone) {
242            fileInfos.push(result.value);
243            files.push({
244              name: result.value.fileName,
245              path: result.value.uri,
246              type: result.value.mimeType,
247              size: result.value.size,
248              addedTime: result.value.mTime,
249              modifiedTime: result.value.mTime,
250              mode: result.value.mode,
251            })
252          }
253        }
254      } catch (error) {
255        logError(TAG, `getListFileData fileIterator error : ` + error)
256      }
257      handleData(files, data);
258    }).catch((error) => {
259      logError(TAG, 'getRoot error' + error.message)
260    });
261  } catch (error) {
262    logError(TAG, `getRoots error : ` + error)
263  }
264}
265
266function listFile(data, fileInfo) {
267  logInfo(TAG, 'listFile start path = ' + data.path + " type = " + data.MediaType + " offset = " + data.offset)
268  let subFileInfos = [];
269  let files = [];
270  let isDone = false;
271  if ((fileInfo.mode & fileExtensionInfo.DocumentFlag.REPRESENTS_FILE) == fileExtensionInfo.DocumentFlag.REPRESENTS_FILE) {
272    logInfo(TAG, `getListFileData file cannot listFile`);
273  }
274  try {
275    logInfo(TAG, `fileInfo.listFile - start`);
276    let fileIterator = fileInfo.listFile();
277    logInfo(TAG, `fileInfo.listFile - end`);
278    if (!fileIterator) {
279      logInfo(TAG, `getListFile fileIterator return undefined`);
280    }
281    while (!isDone) {
282      let result = fileIterator.next();
283      isDone = result.done;
284      if (!isDone) {
285        subFileInfos.push(result.value);
286        files.push({
287          name: result.value.fileName,
288          path: result.value.uri,
289          type: result.value.mimeType,
290          size: result.value.size,
291          addedTime: result.value.mTime,
292          modifiedTime: result.value.mTime,
293          mode: result.value.mode,
294        })
295      }
296    }
297    handleData(files, data);
298  } catch (error) {
299    logError(TAG, `getListFileData fileInfo error : ` + error)
300    handleData([], data)
301  }
302}
303
304function createFile(data, fileAccessHelper) {
305  logInfo(TAG, 'createFile path = ' + data.path + ' files = ' + data.save_name)
306
307  logInfo(TAG, `createFile - start`);
308  fileAccessHelper.createFile(data.path, data.save_name, (ret, uri) => {
309    logInfo(TAG, `createFile - end`);
310    data.retCode = ret.code;
311    if (ret.code == 0) {
312      handleData(uri, data)
313    } else if (ret.code == -2002 || ret.code == -3000) {
314      logError(TAG, 'created file type does not match the directory')
315    } else {
316      logError(TAG, 'createFile error ' + ret.code)
317      handleData([], data)
318    }
319  })
320}
321
322function coverFile(data, fileAccessHelper) {
323  logInfo(TAG, 'coverFile path = ' + data.path + ' files = ' + data.cover_name)
324
325  getFileInfo(data.path, fileAccessHelper).then((file) => {
326    let subFileInfos = getOtherFileInfos(file);
327    let index = subFileInfos.findIndex((fileInfo) => {
328      return fileInfo.fileName == data.cover_name;
329    });
330    let delFile = null;
331    logInfo(TAG, `coverFile - delFile` + index);
332    if (index != -1) {
333      delFile = subFileInfos[index];
334    }
335
336    logInfo(TAG, `delete - start` + delFile.uri + " - " + delFile.fileName);
337    fileAccessHelper.delete(delFile.uri, (ret, uri) => {
338      logInfo(TAG, `delete - end` + ret.code + uri);
339      data.retCode = ret.code;
340      if (ret.code == 0) {
341        data.save_name = data.cover_name;
342        data.cover_name = "";
343        createFile(data, fileAccessHelper);
344      } else {
345        logError(TAG, 'coverFile error ' + ret.code)
346        handleData([], data)
347      }
348    })
349  });
350}
351
352function handleData(file, data) {
353  logInfo(TAG, 'handleData data' + JSON.stringify(data))
354  var info = JSON.stringify(file)
355  logInfo(TAG, `info = ${info}`)
356  var buf = new ArrayBuffer(info.length * 2)
357  var bufView = new Uint16Array(buf)
358  for (var index = 0; index < info.length; index++) {
359    bufView[index] = info.charCodeAt(index)
360  }
361  parentPort.postMessage({ data: bufView, params: data })
362}
363
364