• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// @ts-nocheck
2/*
3 * Copyright (c) 2022 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16import fileIO from '@ohos.fileio';
17import MediaLib from '@ohos.multimedia.mediaLibrary';
18import { MediaConstants } from '../constants/MediaConstants';
19import createOrGet from '../utils/SingleInstanceUtils';
20import { Log } from '../utils/Log';
21import { startTrace, finishTrace } from '../utils/TraceControllerUtils';
22import { hiSysEventDataQueryTimedOut } from '../utils/hisysEventUtil';
23
24const TAG = "MediaModel"
25
26export class MediaModelItem {
27    fileAsset: MediaLib.FileAsset;
28    counts: number;
29}
30
31class MediaModel {
32    private media: MediaLib.MediaLibrary = undefined;
33    private imageDir: string = "";
34    private cameraDir: string = "";
35
36    constructor() {
37    }
38
39    onCreate(context) {
40        if (this.media == undefined) {
41            this.media = MediaLib.getMediaLibrary(context);
42        }
43    }
44
45    getMediaLibrary(): MediaLib.MediaLibrary {
46        return this.media;
47    }
48
49    async getPublicDirectory(directoryType: MediaLib.DirectoryType): Promise<string> {
50        if (directoryType == MediaLib.DirectoryType.DIR_IMAGE) {
51            if (this.imageDir == "" || this.imageDir == undefined) {
52                let getPublicDirectoryImage = hiSysEventDataQueryTimedOut('getPublicDirectoryImage')
53                this.imageDir = await this.media.getPublicDirectory(directoryType);
54                clearTimeout(getPublicDirectoryImage);
55                Log.debug(TAG, `imageDir ${this.imageDir}`);
56            }
57            Log.debug(TAG, `return imageDir ${this.imageDir}`);
58            return this.imageDir;
59        } else if (directoryType == MediaLib.DirectoryType.DIR_CAMERA) {
60            if (this.cameraDir == "" || this.cameraDir == undefined) {
61                let getPublicDirectoryCamera = hiSysEventDataQueryTimedOut('getPublicDirectoryCamera')
62                this.cameraDir = await this.media.getPublicDirectory(directoryType);
63                clearTimeout(getPublicDirectoryCamera);
64                Log.debug(TAG, `cameraDir ${this.cameraDir}`);
65            }
66            Log.debug(TAG, `return cameraDir ${this.cameraDir}`);
67            return this.cameraDir;
68        } else {
69            Log.warn(TAG, `invaild directoryType: ${directoryType}`);
70            return "";
71        }
72    }
73
74    async createOne(mediaType: MediaLib.MediaType, displayName: string, relativePath: string): Promise<MediaLib.FileAsset> {
75        return await this.media.createAsset(mediaType, displayName, relativePath);
76    }
77
78    async copyOne(source: MediaLib.FileAsset, target: MediaLib.FileAsset) {
79        Log.info(TAG, `copy start: src:${source.uri} target: ${target.uri}`);
80        startTrace('openAssetR');
81        let fd = await this.openAsset('R', source);
82        finishTrace('openAssetR');
83        if (fd <= 0) {
84            throw 'fd is invalid';
85            return;
86        }
87
88        startTrace('openAssetRW');
89        let targetFd = await this.openAsset('RW', target);
90        finishTrace('openAssetRW');
91        if (targetFd <= 0) {
92            throw 'targetFd is invalid';
93            return;
94        }
95
96        startTrace('copyFile');
97        await fileIO.copyFile(fd, targetFd);
98        finishTrace('copyFile');
99
100        startTrace('sourceClose');
101        await this.closeAsset(fd, source);
102        finishTrace('sourceClose');
103        startTrace('targetClose');
104        await this.closeAsset(targetFd, target);
105        finishTrace('targetClose');
106
107        Log.debug(TAG, 'copy end');
108    }
109
110    async deleteOne(uri: string) {
111        Log.debug(TAG, `deleteAsset uri: ${uri}`);
112        await this.media.deleteAsset(uri);
113    }
114
115    async deleteAll(fetchOption: MediaLib.MediaFetchOptions) {
116        Log.info(TAG, 'deleteAll');
117        startTrace('deleteAll');
118        let fetchFileResult: MediaLib.FetchFileResult = undefined;
119        try {
120            fetchFileResult = await this.media.getFileAssets(fetchOption);
121            Log.debug(TAG, `deleteAll getFileAssets`);
122            let deleteAllGetAllObject = hiSysEventDataQueryTimedOut('deleteAllGetAllObject')
123            let fileAssets: MediaLib.FileAsset[] = await fetchFileResult.getAllObject();
124            clearTimeout(deleteAllGetAllObject);
125            for (let i = 0;i < fileAssets.length; i++) {
126                await fileAssets[i].trash(true);
127            }
128            Log.debug(TAG, `deleteAll getFirstObject`);
129        } catch (err) {
130            Log.error(TAG, `deleteAll error:${JSON.stringify(err)}`);
131        } finally {
132             if (fetchFileResult) {
133                fetchFileResult.close();
134            }
135        }
136        finishTrace('deleteAll');
137        Log.debug(TAG, 'deleteAll finish');
138    }
139
140    async getAllMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> {
141        Log.info(TAG, 'getAllMediaItems');
142        startTrace('getAllMediaItems');
143        let fileAssets: Array<MediaLib.FileAsset> = [];
144        let fetchFileResult: MediaLib.FetchFileResult = undefined;
145        try {
146            fetchFileResult = await this.media.getFileAssets(fetchOption);
147            Log.debug(TAG, `getAllMediaItems getFileAssets:${fetchFileResult.getCount()}`);
148            let getAllMediaItemsGetAllObject = hiSysEventDataQueryTimedOut('getAllMediaItemsGetAllObject')
149            fileAssets = await fetchFileResult.getAllObject();
150            clearTimeout(getAllMediaItemsGetAllObject);
151            Log.debug(TAG, `getAllMediaItems getAllObject:${fileAssets.length}`);
152        } catch (err) {
153            Log.error(TAG, `getAllMediaItems error:${JSON.stringify(err)}`);
154        }  finally {
155            if (fetchFileResult) {
156                fetchFileResult.close();
157            }
158        }
159        finishTrace('getAllMediaItems');
160        Log.debug(TAG, 'getAllMediaItems finish');
161        return fileAssets;
162    }
163
164    async getAllFavorMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> {
165        Log.info(TAG, 'getAllFavorMediaItems');
166        startTrace('getAllFavorMediaItems');
167        let fileAssets: Array<MediaLib.FileAsset> = [];
168        let fetchFileResult: MediaLib.FetchFileResult = undefined;
169        try {
170            let getPrivateAlbumGetAllFavors = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllFavors')
171            let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_FAVORITE);
172            clearTimeout(getPrivateAlbumGetAllFavors);
173            if (albums.length > 0) {
174                fetchFileResult = await albums[0].getFileAssets(fetchOption);
175                Log.debug(TAG, `getAllFavorMediaItems getFileAssets`);
176                let getAllObjectGetAllFavors = hiSysEventDataQueryTimedOut('getAllObjectGetAllFavors')
177                fileAssets = await fetchFileResult.getAllObject();
178                clearTimeout(getAllObjectGetAllFavors);
179                Log.debug(TAG, `getAllFavorMediaItems getFirstObject`);
180            }
181        } catch (err) {
182            Log.error(TAG, `getAllFavorMediaItems error:${JSON.stringify(err)}`);
183        } finally {
184            if (fetchFileResult) {
185                fetchFileResult.close();
186            }
187        }
188        finishTrace('getAllFavorMediaItems');
189        Log.debug(TAG, 'getAllFavorMediaItems finish');
190        return fileAssets;
191    }
192
193    async getAllTrashMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> {
194        Log.info(TAG, 'getAllTrashMediaItems');
195        startTrace('getAllTrashMediaItems');
196        let fileAssets: Array<MediaLib.FileAsset> = [];
197        let fetchFileResult: MediaLib.FetchFileResult = undefined;
198        try {
199            let getPrivateAlbumGetAllTrashItems = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllTrashItems')
200            let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH);
201            clearTimeout(getPrivateAlbumGetAllTrashItems);
202            if (albums.length > 0) {
203                fetchFileResult = await albums[0].getFileAssets(fetchOption);
204                Log.debug(TAG, `getAllTrashMediaItems getFileAssets`);
205                let getAllObjectGetAllTrashItems = hiSysEventDataQueryTimedOut('getAllObjectGetAllTrashItems')
206                fileAssets = await fetchFileResult.getAllObject();
207                clearTimeout(getAllObjectGetAllTrashItems);
208                Log.debug(TAG, `getAllTrashMediaItems getFirstObject`);
209            }
210        } catch (err) {
211            Log.error(TAG, `getAllTrashMediaItems error:${JSON.stringify(err)}`);
212        } finally {
213            if (fetchFileResult) {
214                fetchFileResult.close();
215            }
216        }
217        finishTrace('getAllTrashMediaItems');
218        Log.debug(TAG, 'getAllTrashMediaItems finish');
219        return fileAssets;
220    }
221
222    async getAllMediaItem(albumId: string, fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> {
223        if (albumId == MediaConstants.ALBUM_ID_FAVOR) {
224            return await this.getAllFavorMediaItem(fetchOption, isCountOnly);
225        } else if (albumId == MediaConstants.ALBUM_ID_RECYCLE) {
226            return await this.getAllTrashMediaItem(fetchOption, isCountOnly);
227        } else {
228            return await this.getAllCommonMediaItem(fetchOption, isCountOnly);
229        }
230    }
231
232    async getAllCommonMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> {
233        Log.info(TAG, 'getAllCommonMediaItem');
234        startTrace('getAllCommonMediaItem');
235        let item: MediaModelItem = new MediaModelItem();
236        let fetchFileResult: MediaLib.FetchFileResult = undefined;
237        try {
238            fetchFileResult = await this.media.getFileAssets(fetchOption);
239            Log.debug(TAG, `getAllCommonMediaItem getFileAssets`);
240            item.counts = await fetchFileResult.getCount();
241            if (!isCountOnly && item.counts > 0) {
242                let getFirstObjectGetAllCommon = hiSysEventDataQueryTimedOut('getFirstObjectGetAllCommon')
243                item.fileAsset = await fetchFileResult.getFirstObject();
244                clearTimeout(getFirstObjectGetAllCommon);
245            }
246            Log.debug(TAG, `getAllCommonMediaItem getFirstObject`);
247        } catch (err) {
248            Log.error(TAG, `getAllCommonMediaItem error:${JSON.stringify(err)}`);
249        } finally {
250            if (fetchFileResult) {
251                fetchFileResult.close();
252            }
253        }
254        finishTrace('getAllCommonMediaItem');
255        Log.debug(TAG, 'getAllCommonMediaItem finish');
256        return item;
257    }
258
259    async getAllFavorMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> {
260        Log.info(TAG, 'getAllFavorMediaItem');
261        startTrace('getAllFavorMediaItem');
262        let item: MediaModelItem = new MediaModelItem();
263        let fetchFileResult: MediaLib.FetchFileResult = undefined;
264        try {
265            let getPrivateAlbumGetAllFavorItem = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllFavorItem')
266            let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_FAVORITE);
267            clearTimeout(getPrivateAlbumGetAllFavorItem);
268            if (albums.length > 0) {
269                fetchFileResult = await albums[0].getFileAssets(fetchOption);
270                Log.debug(TAG, `getAllFavorMediaItem getFileAssets`);
271                item.counts = await fetchFileResult.getCount();
272                if (!isCountOnly && item.counts > 0) {
273                    let getFirstObjectGetAllFavorItem = hiSysEventDataQueryTimedOut('getFirstObjectGetAllFavorItem')
274                    item.fileAsset = await fetchFileResult.getFirstObject();
275                    clearTimeout(getFirstObjectGetAllFavorItem);
276                }
277                Log.debug(TAG, `getAllFavorMediaItem getFirstObject`);
278            }
279        } catch (err) {
280            Log.error(TAG, `getAllFavorMediaItem error:${JSON.stringify(err)}`);
281        } finally {
282            if (fetchFileResult) {
283                fetchFileResult.close();
284            }
285        }
286        finishTrace('getAllFavorMediaItem');
287        Log.debug(TAG, 'getAllFavorMediaItem finish');
288        return item;
289    }
290
291    async getAllTrashMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> {
292        Log.info(TAG, 'getAllTrashMediaItem');
293        startTrace('getAllTrashMediaItem');
294        let item: MediaModelItem = new MediaModelItem();
295        let fetchFileResult: MediaLib.FetchFileResult = undefined;
296        try {
297            let getPrivateAlbumGetAllTrashItem = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllTrashItem')
298            let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH);
299            clearTimeout(getPrivateAlbumGetAllTrashItem);
300            if (albums.length > 0) {
301                fetchFileResult = await albums[0].getFileAssets(fetchOption);
302                Log.debug(TAG, `getAllTrashMediaItem getFileAssets`);
303                item.counts = await fetchFileResult.getCount();
304                if (!isCountOnly && item.counts > 0) {
305                    let getFirstObjectGetAllTrashItem = hiSysEventDataQueryTimedOut('getFirstObjectGetAllTrashItem')
306                    item.fileAsset = await fetchFileResult.getFirstObject();
307                    clearTimeout(getFirstObjectGetAllTrashItem);
308                }
309                Log.debug(TAG, `getAllTrashMediaItem getFirstObject`);
310            }
311        } catch (err) {
312            Log.error(TAG, `getAllTrashMediaItem error:${JSON.stringify(err)}`);
313        } finally {
314            if (fetchFileResult) {
315                fetchFileResult.close();
316            }
317        }
318        finishTrace('getAllTrashMediaItem');
319        Log.debug(TAG, 'getAllTrashMediaItem finish');
320        return item
321    }
322
323    async getAlbumCount(fetchOption: MediaLib.MediaFetchOptions): Promise<number> {
324        Log.info(TAG, 'getAlbumCount');
325        startTrace('getAlbumCount');
326        let count = 0;
327        let fetchFileResult: MediaLib.FetchFileResult = undefined;
328        try {
329            let getAlbumsGetAlbumCount = hiSysEventDataQueryTimedOut('getAlbumsGetAlbumCount')
330            let albums: Array<MediaLib.Album> = await this.media.getAlbums(fetchOption);
331            clearTimeout(getAlbumsGetAlbumCount);
332            if (albums.length == 0) {
333                return count;
334            }
335            fetchFileResult = await albums[0].getFileAssets();
336            count = fetchFileResult.getCount();
337        } catch (err) {
338            Log.error(TAG, `getAlbumCount error:${JSON.stringify(err)}`);
339        } finally {
340            if (fetchFileResult) {
341                fetchFileResult.close();
342            }
343        }
344        finishTrace('getAlbumCount');
345        Log.debug(TAG, 'getAlbumCount finish');
346        return count;
347    }
348
349    async getActivePeers(): Promise<Array<MediaLib.PeerInfo>> {
350        Log.info(TAG, 'getActivePeers');
351        startTrace('getActivePeers');
352        let peers: Array<MediaLib.PeerInfo> = undefined;
353        try {
354            let getActivePeers = hiSysEventDataQueryTimedOut('getActivePeers')
355            peers = await this.media.getActivePeers();
356            clearTimeout(getActivePeers);
357        } catch (err) {
358            Log.error(TAG, `getActivePeers error:${JSON.stringify(err)}`);
359        }
360        finishTrace('getActivePeers');
361        Log.debug(TAG, 'getActivePeers finish');
362        return peers;
363    }
364
365    async getAlbums(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.Album>> {
366        Log.info(TAG, 'getAlbums');
367        startTrace('getAlbums');
368        let albums: Array<MediaLib.Album> = undefined;
369        try {
370            let getAlbums = hiSysEventDataQueryTimedOut('getAlbums')
371            albums = await this.media.getAlbums(fetchOption);
372            clearTimeout(getAlbums);
373            Log.info(TAG, `getAlbums albums ${albums.length}`);
374        } catch (err) {
375            Log.error(TAG, `getAlbums error:${JSON.stringify(err)}`);
376        }
377        finishTrace('getAlbums');
378        Log.debug(TAG, 'getAlbums finish');
379        return albums;
380    }
381
382    async getTrashMedia(fetchOption: MediaLib.MediaFetchOptions): Promise<MediaLib.FileAsset> {
383        Log.info(TAG, 'getTrashMedia');
384        startTrace('getTrashMedia');
385        let fileAsset: MediaLib.FileAsset = undefined;
386        let fetchFileResult: MediaLib.FetchFileResult = undefined;
387        try {
388            let getPrivateAlbumGetTrash = hiSysEventDataQueryTimedOut('getPrivateAlbumGetTrash')
389            let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH);
390            clearTimeout(getPrivateAlbumGetTrash);
391            if (albums.length > 0) {
392                fetchFileResult = await albums[0].getFileAssets(fetchOption);
393                Log.debug(TAG, `getTrashMedia getFileAssets`);
394                if (fetchFileResult.getCount() > 0) {
395                    let getFirstObjectGetTrash = hiSysEventDataQueryTimedOut('getFirstObjectGetTrash')
396                    fileAsset = await fetchFileResult.getFirstObject();
397                    clearTimeout(getFirstObjectGetTrash);
398                }
399                Log.debug(TAG, `getTrashMedia getFirstObject`);
400            }
401        } catch (err) {
402            Log.error(TAG, `getTrashMedia error:${JSON.stringify(err)}`);
403        } finally {
404            if (fetchFileResult) {
405                fetchFileResult.close();
406            }
407        }
408        finishTrace('getTrashMedia');
409        Log.debug(TAG, 'getTrashMedia finish');
410        return fileAsset;
411    }
412
413    async openAsset(mode: string, fileAsset: MediaLib.FileAsset) {
414        Log.debug(TAG, 'openAsset start');
415        let fd: number = await fileAsset.open(mode);
416        Log.info(TAG, `openAsset end. fd: ${fd}`);
417        if (fd <= 0) {
418            Log.info(TAG, 'openAsset Fail');
419        }
420        return fd;
421    }
422
423    async closeAsset(fd: number, fileAsset: MediaLib.FileAsset) {
424        Log.debug(TAG, 'closeAsset start');
425        await fileAsset.close(fd);
426    }
427}
428
429let mediaModel = createOrGet(MediaModel, TAG);
430
431export default mediaModel as MediaModel;