1/*
2 * Copyright (c) 2022-2023 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 */
15import type { MediaObserverCallback } from './MediaObserverCallback';
16import { Log } from '../../../utils/Log';
17import { Constants } from '../../common/Constants';
18import type { ChangeData, UserFileManager } from '../../../access/UserFileManagerAccess';
19import { UserFileManagerAccess } from '../../../access/UserFileManagerAccess';
20
21const TAG: string = 'common_MediaObserver';
22
23export class MediaObserver {
24  callbacks: Set<MediaObserverCallback> = new Set<MediaObserverCallback>();
25  private freezeFlag: boolean = false;
26
27  static getInstance(): MediaObserver {
28    if (AppStorage.get(Constants.APP_KEY_MENU_USER_FILE_MANAGER_OBSERVER) == null) {
29      AppStorage.setOrCreate(Constants.APP_KEY_MENU_USER_FILE_MANAGER_OBSERVER, new MediaObserver());
30    }
31    return AppStorage.get(Constants.APP_KEY_MENU_USER_FILE_MANAGER_OBSERVER);
32  }
33
34  registerObserver(callback: MediaObserverCallback) {
35    Log.info(TAG, 'registerObserver');
36    if (!callback) {
37      Log.warn(TAG, 'registerObserver with empty callback');
38      return;
39    }
40
41    if (this.callbacks.has(callback)) {
42      Log.warn(TAG, 'registerObserver already exist');
43      return;
44    }
45    this.callbacks.add(callback);
46  }
47
48  unregisterObserver(callback: MediaObserverCallback) {
49    Log.info(TAG, 'unregisterObserver');
50    if (!callback) {
51      Log.warn(TAG, 'unregisterObserver with empty callback');
52      return;
53    }
54
55    if (this.callbacks.has(callback)) {
56      this.callbacks.delete(callback);
57    } else {
58      Log.warn(TAG, 'unregisterObserver not exist');
59    }
60  }
61
62  freezeNotify(): void {
63    this.freezeFlag = true;
64  }
65
66  unfreezeNotify(): void {
67    this.freezeFlag = false;
68  }
69
70  forceNotify(): void {
71    this.sendNotify('image');
72  }
73
74  sendNotify(mediaType: string) {
75    Log.info(TAG, `sendNotify size: ${this.callbacks.size}`);
76    if (this.freezeFlag) {
77      return;
78    }
79    for (let callback of this.callbacks) {
80      callback.onChange(mediaType);
81    }
82  }
83
84  registerForAllPhotos() {
85    Log.info(TAG, 'registerForAllPhotos');
86    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
87    if (userFileManager) {
88      userFileManager.on(UserFileManagerAccess.REGISTER_TYPE_ALL_PHOTOS, true, (changeData: ChangeData) => {
89        Log.info(TAG, `userFileManager.on for REGISTER_TYPE_ALL_PHOTOS, ${JSON.stringify(changeData)}`);
90        this.sendNotify('image');
91      });
92    } else {
93      Log.error(TAG, 'register is null!');
94    }
95  }
96
97  unregisterForAllPhotos() {
98    Log.info(TAG, 'unregisterForAllPhotos');
99    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
100    if (userFileManager) {
101      userFileManager.off(UserFileManagerAccess.REGISTER_TYPE_ALL_PHOTOS);
102    } else {
103      Log.error(TAG, 'unregister is null!');
104    }
105  }
106
107  registerForAllAlbums() {
108    Log.info(TAG, 'registerForAllAlbums');
109    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
110    if (userFileManager) {
111      userFileManager.on(UserFileManagerAccess.REGISTER_TYPE_ALL_ALBUMS, true, (changeData: ChangeData) => {
112        Log.info(TAG, `userFileManager.on for REGISTER_TYPE_ALL_ALBUMS, ${JSON.stringify(changeData)}`);
113        this.sendNotify('image');
114      });
115    } else {
116      Log.error(TAG, 'register is null!');
117    }
118  }
119
120  unregisterForAllAlbums() {
121    Log.info(TAG, 'unregisterForAllAlbums');
122    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
123    if (userFileManager) {
124      userFileManager.off(UserFileManagerAccess.REGISTER_TYPE_ALL_ALBUMS);
125    } else {
126      Log.error(TAG, 'unregister is null!');
127    }
128  }
129
130  registerForAlbum(albumUri: string) {
131    Log.info(TAG, 'registerForAllAlbums');
132    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
133    if (userFileManager) {
134      userFileManager.on(albumUri, false, (changeData: ChangeData) => {
135        Log.info(TAG, 'userFileManager.on for REGISTER_TYPE_ALL_ALBUMS');
136        this.sendNotify('album');
137      });
138    } else {
139      Log.error(TAG, 'register is null!');
140    }
141  }
142
143  unregisterForAlbum(albumUri: string) {
144    Log.info(TAG, 'unregisterForAllAlbums');
145    let userFileManager: UserFileManager = UserFileManagerAccess.getInstance().getMediaLibrary();
146    if (userFileManager) {
147      userFileManager.off(albumUri);
148    } else {
149      Log.error(TAG, 'unregister is null!');
150    }
151  }
152}