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 try { 119 let fetchFileResult: MediaLib.FetchFileResult = await this.media.getFileAssets(fetchOption); 120 Log.debug(TAG, `deleteAll getFileAssets`); 121 let deleteAllGetAllObject = hiSysEventDataQueryTimedOut('deleteAllGetAllObject') 122 let fileAssets: MediaLib.FileAsset[] = await fetchFileResult.getAllObject(); 123 clearTimeout(deleteAllGetAllObject); 124 for (let i = 0;i < fileAssets.length; i++) { 125 await fileAssets[i].trash(true); 126 } 127 Log.debug(TAG, `deleteAll getFirstObject`); 128 fetchFileResult.close(); 129 } catch (err) { 130 Log.error(TAG, `deleteAll error:${JSON.stringify(err)}`); 131 } 132 finishTrace('deleteAll'); 133 Log.debug(TAG, 'deleteAll finish'); 134 } 135 136 async getAllMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> { 137 Log.info(TAG, 'getAllMediaItems'); 138 startTrace('getAllMediaItems'); 139 let fileAssets: Array<MediaLib.FileAsset> = []; 140 try { 141 let fetchFileResult: MediaLib.FetchFileResult = await this.media.getFileAssets(fetchOption); 142 Log.debug(TAG, `getAllMediaItems getFileAssets:${fetchFileResult.getCount()}`); 143 let getAllMediaItemsGetAllObject = hiSysEventDataQueryTimedOut('getAllMediaItemsGetAllObject') 144 fileAssets = await fetchFileResult.getAllObject(); 145 clearTimeout(getAllMediaItemsGetAllObject); 146 Log.debug(TAG, `getAllMediaItems getAllObject:${fileAssets.length}`); 147 fetchFileResult.close(); 148 } catch (err) { 149 Log.error(TAG, `getAllMediaItems error:${JSON.stringify(err)}`); 150 } 151 finishTrace('getAllMediaItems'); 152 Log.debug(TAG, 'getAllMediaItems finish'); 153 return fileAssets; 154 } 155 156 async getAllFavorMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> { 157 Log.info(TAG, 'getAllFavorMediaItems'); 158 startTrace('getAllFavorMediaItems'); 159 let fileAssets: Array<MediaLib.FileAsset> = []; 160 try { 161 let getPrivateAlbumGetAllFavors = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllFavors') 162 let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_FAVORITE); 163 clearTimeout(getPrivateAlbumGetAllFavors); 164 if (albums.length > 0) { 165 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(fetchOption); 166 Log.debug(TAG, `getAllFavorMediaItems getFileAssets`); 167 let getAllObjectGetAllFavors = hiSysEventDataQueryTimedOut('getAllObjectGetAllFavors') 168 fileAssets = await fetchFileResult.getAllObject(); 169 clearTimeout(getAllObjectGetAllFavors); 170 Log.debug(TAG, `getAllFavorMediaItems getFirstObject`); 171 fetchFileResult.close(); 172 } 173 fetchFileResult.close(); 174 } catch (err) { 175 Log.error(TAG, `getAllFavorMediaItems error:${JSON.stringify(err)}`); 176 } 177 finishTrace('getAllFavorMediaItems'); 178 Log.debug(TAG, 'getAllFavorMediaItems finish'); 179 return fileAssets; 180 } 181 182 async getAllTrashMediaItems(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.FileAsset>> { 183 Log.info(TAG, 'getAllTrashMediaItems'); 184 startTrace('getAllTrashMediaItems'); 185 let fileAssets: Array<MediaLib.FileAsset> = []; 186 try { 187 let getPrivateAlbumGetAllTrashItems = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllTrashItems') 188 let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH); 189 clearTimeout(getPrivateAlbumGetAllTrashItems); 190 if (albums.length > 0) { 191 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(fetchOption); 192 Log.debug(TAG, `getAllTrashMediaItems getFileAssets`); 193 let getAllObjectGetAllTrashItems = hiSysEventDataQueryTimedOut('getAllObjectGetAllTrashItems') 194 fileAssets = await fetchFileResult.getAllObject(); 195 clearTimeout(getAllObjectGetAllTrashItems); 196 Log.debug(TAG, `getAllTrashMediaItems getFirstObject`); 197 fetchFileResult.close(); 198 } 199 fetchFileResult.close(); 200 } catch (err) { 201 Log.error(TAG, `getAllTrashMediaItems error:${JSON.stringify(err)}`); 202 } 203 finishTrace('getAllTrashMediaItems'); 204 Log.debug(TAG, 'getAllTrashMediaItems finish'); 205 return fileAssets; 206 } 207 208 async getAllMediaItem(albumId: string, fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> { 209 if (albumId == MediaConstants.ALBUM_ID_FAVOR) { 210 return await this.getAllFavorMediaItem(fetchOption, isCountOnly); 211 } else if (albumId == MediaConstants.ALBUM_ID_RECYCLE) { 212 return await this.getAllTrashMediaItem(fetchOption, isCountOnly); 213 } else { 214 return await this.getAllCommonMediaItem(fetchOption, isCountOnly); 215 } 216 } 217 218 async getAllCommonMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> { 219 Log.info(TAG, 'getAllCommonMediaItem'); 220 startTrace('getAllCommonMediaItem'); 221 let item: MediaModelItem = new MediaModelItem(); 222 try { 223 let fetchFileResult: MediaLib.FetchFileResult = await this.media.getFileAssets(fetchOption); 224 Log.debug(TAG, `getAllCommonMediaItem getFileAssets`); 225 item.counts = await fetchFileResult.getCount(); 226 if (!isCountOnly && item.counts > 0) { 227 let getFirstObjectGetAllCommon = hiSysEventDataQueryTimedOut('getFirstObjectGetAllCommon') 228 item.fileAsset = await fetchFileResult.getFirstObject(); 229 clearTimeout(getFirstObjectGetAllCommon); 230 } 231 Log.debug(TAG, `getAllCommonMediaItem getFirstObject`); 232 fetchFileResult.close(); 233 } catch (err) { 234 Log.error(TAG, `getAllCommonMediaItem error:${JSON.stringify(err)}`); 235 } 236 finishTrace('getAllCommonMediaItem'); 237 Log.debug(TAG, 'getAllCommonMediaItem finish'); 238 return item; 239 } 240 241 async getAllFavorMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> { 242 Log.info(TAG, 'getAllFavorMediaItem'); 243 startTrace('getAllFavorMediaItem'); 244 let item: MediaModelItem = new MediaModelItem(); 245 try { 246 let getPrivateAlbumGetAllFavorItem = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllFavorItem') 247 let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_FAVORITE); 248 clearTimeout(getPrivateAlbumGetAllFavorItem); 249 if (albums.length > 0) { 250 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(fetchOption); 251 Log.debug(TAG, `getAllFavorMediaItem getFileAssets`); 252 item.counts = await fetchFileResult.getCount(); 253 if (!isCountOnly && item.counts > 0) { 254 let getFirstObjectGetAllFavorItem = hiSysEventDataQueryTimedOut('getFirstObjectGetAllFavorItem') 255 item.fileAsset = await fetchFileResult.getFirstObject(); 256 clearTimeout(getFirstObjectGetAllFavorItem); 257 } 258 Log.debug(TAG, `getAllFavorMediaItem getFirstObject`); 259 fetchFileResult.close(); 260 } 261 } catch (err) { 262 Log.error(TAG, `getAllFavorMediaItem error:${JSON.stringify(err)}`); 263 } 264 finishTrace('getAllFavorMediaItem'); 265 Log.debug(TAG, 'getAllFavorMediaItem finish'); 266 return item; 267 } 268 269 async getAllTrashMediaItem(fetchOption: MediaLib.MediaFetchOptions, isCountOnly: boolean): Promise<MediaModelItem> { 270 Log.info(TAG, 'getAllTrashMediaItem'); 271 startTrace('getAllTrashMediaItem'); 272 let item: MediaModelItem = new MediaModelItem(); 273 try { 274 let getPrivateAlbumGetAllTrashItem = hiSysEventDataQueryTimedOut('getPrivateAlbumGetAllTrashItem') 275 let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH); 276 clearTimeout(getPrivateAlbumGetAllTrashItem); 277 if (albums.length > 0) { 278 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(fetchOption); 279 Log.debug(TAG, `getAllTrashMediaItem getFileAssets`); 280 item.counts = await fetchFileResult.getCount(); 281 if (!isCountOnly && item.counts > 0) { 282 let getFirstObjectGetAllTrashItem = hiSysEventDataQueryTimedOut('getFirstObjectGetAllTrashItem') 283 item.fileAsset = await fetchFileResult.getFirstObject(); 284 clearTimeout(getFirstObjectGetAllTrashItem); 285 } 286 Log.debug(TAG, `getAllTrashMediaItem getFirstObject`); 287 fetchFileResult.close(); 288 } 289 } catch (err) { 290 Log.error(TAG, `getAllTrashMediaItem error:${JSON.stringify(err)}`); 291 } 292 finishTrace('getAllTrashMediaItem'); 293 Log.debug(TAG, 'getAllTrashMediaItem finish'); 294 return item 295 } 296 297 async getAlbumCount(fetchOption: MediaLib.MediaFetchOptions): Promise<number> { 298 Log.info(TAG, 'getAlbumCount'); 299 startTrace('getAlbumCount'); 300 let count = 0; 301 try { 302 let getAlbumsGetAlbumCount = hiSysEventDataQueryTimedOut('getAlbumsGetAlbumCount') 303 let albums: Array<MediaLib.Album> = await this.media.getAlbums(fetchOption); 304 clearTimeout(getAlbumsGetAlbumCount); 305 if (albums.length == 0) { 306 return count; 307 } 308 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(); 309 count = fetchFileResult.getCount(); 310 fetchFileResult.close(); 311 } catch (err) { 312 Log.error(TAG, `getAlbumCount error:${JSON.stringify(err)}`); 313 } 314 finishTrace('getAlbumCount'); 315 Log.debug(TAG, 'getAlbumCount finish'); 316 return count; 317 } 318 319 async getActivePeers(): Promise<Array<MediaLib.PeerInfo>> { 320 Log.info(TAG, 'getActivePeers'); 321 startTrace('getActivePeers'); 322 let peers: Array<MediaLib.PeerInfo> = undefined; 323 try { 324 let getActivePeers = hiSysEventDataQueryTimedOut('getActivePeers') 325 peers = await this.media.getActivePeers(); 326 clearTimeout(getActivePeers); 327 } catch (err) { 328 Log.error(TAG, `getActivePeers error:${JSON.stringify(err)}`); 329 } 330 finishTrace('getActivePeers'); 331 Log.debug(TAG, 'getActivePeers finish'); 332 return peers; 333 } 334 335 async getAlbums(fetchOption: MediaLib.MediaFetchOptions): Promise<Array<MediaLib.Album>> { 336 Log.info(TAG, 'getAlbums'); 337 startTrace('getAlbums'); 338 let albums: Array<MediaLib.Album> = undefined; 339 try { 340 let getAlbums = hiSysEventDataQueryTimedOut('getAlbums') 341 albums = await this.media.getAlbums(fetchOption); 342 clearTimeout(getAlbums); 343 Log.info(TAG, `getAlbums albums ${albums.length}`); 344 } catch (err) { 345 Log.error(TAG, `getAlbums error:${JSON.stringify(err)}`); 346 } 347 finishTrace('getAlbums'); 348 Log.debug(TAG, 'getAlbums finish'); 349 return albums; 350 } 351 352 async getTrashMedia(fetchOption: MediaLib.MediaFetchOptions): Promise<MediaLib.FileAsset> { 353 Log.info(TAG, 'getTrashMedia'); 354 startTrace('getTrashMedia'); 355 let fileAsset: MediaLib.FileAsset = undefined; 356 try { 357 let getPrivateAlbumGetTrash = hiSysEventDataQueryTimedOut('getPrivateAlbumGetTrash') 358 let albums = await this.media.getPrivateAlbum(MediaLib.PrivateAlbumType.TYPE_TRASH); 359 clearTimeout(getPrivateAlbumGetTrash); 360 if (albums.length > 0) { 361 let fetchFileResult: MediaLib.FetchFileResult = await albums[0].getFileAssets(fetchOption); 362 Log.debug(TAG, `getTrashMedia getFileAssets`); 363 if (fetchFileResult.getCount() > 0) { 364 let getFirstObjectGetTrash = hiSysEventDataQueryTimedOut('getFirstObjectGetTrash') 365 fileAsset = await fetchFileResult.getFirstObject(); 366 clearTimeout(getFirstObjectGetTrash); 367 } 368 Log.debug(TAG, `getTrashMedia getFirstObject`); 369 fetchFileResult.close(); 370 } 371 } catch (err) { 372 Log.error(TAG, `getTrashMedia error:${JSON.stringify(err)}`); 373 } 374 finishTrace('getTrashMedia'); 375 Log.debug(TAG, 'getTrashMedia finish'); 376 return fileAsset; 377 } 378 379 async openAsset(mode: string, fileAsset: MediaLib.FileAsset) { 380 Log.debug(TAG, 'openAsset start'); 381 let fd: number = await fileAsset.open(mode); 382 Log.info(TAG, `openAsset end. fd: ${fd}`); 383 if (fd <= 0) { 384 Log.info(TAG, 'openAsset Fail'); 385 } 386 return fd; 387 } 388 389 async closeAsset(fd: number, fileAsset: MediaLib.FileAsset) { 390 Log.debug(TAG, 'closeAsset start'); 391 await fileAsset.close(fd); 392 } 393} 394 395let mediaModel = createOrGet(MediaModel, TAG); 396 397export default mediaModel as MediaModel;