1 /*
2 * Copyright (C) 2025 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 #define MLOG_TAG "NotificationClassification"
17
18 #include "notification_classification.h"
19
20 #include "media_log.h"
21 #include "medialibrary_common_utils.h"
22
23 using namespace std;
24 using namespace OHOS::Media::AccurateRefresh;
25 namespace OHOS {
26 namespace Media {
27 namespace Notification {
28 std::unordered_map<std::variant<AssetRefreshOperation, AlbumRefreshOperation>,
29 std::function<std::vector<MediaChangeInfo>(NotifyInfoInner &)>>
30 NotificationClassification::classificationMap = {
31 {AssetRefreshOperation::ASSET_OPERATION_ADD, HandleAssetAdd},
32 {AssetRefreshOperation::ASSET_OPERATION_ADD_HIDDEN, HandleAssetAddHidden},
33 {AssetRefreshOperation::ASSET_OPERATION_ADD_TRASH, HandleAssetAddTrash},
34 {AssetRefreshOperation::ASSET_OPERATION_REMOVE, HandleAssetRemove},
35 {AssetRefreshOperation::ASSET_OPERATION_REMOVE_HIDDEN, HandleAssetRemoveHidden},
36 {AssetRefreshOperation::ASSET_OPERATION_REMOVE_TRASH, HandleAssetRemoveTrash},
37
38 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_NORMAL, HandleAssetUpdateNormal},
39 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_REMOVE_NORMAL, HandleAssetUpdateRemoveNormal},
40 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_ADD_NORMAL, HandleAssetUpdateAddNormal},
41 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_HIDDEN, HandleAssetUpdateHidden},
42 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_ADD_HIDDEN, HandleAssetUpdateAddHidden},
43 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_REMOVE_HIDDEN, HandleAssetUpdateRemoveHidden},
44
45 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_TRASH, HandleAssetUpdateTrash},
46 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_ADD_TRASH, HandleAssetUpdateAddTrash},
47 {AssetRefreshOperation::ASSET_OPERATION_UPDATE_REMOVE_TRASH, HandleAssetUpdateRemoveTrash},
48 {AssetRefreshOperation::ASSET_OPERATION_TRASH, HandleAssetTrash},
49 {AssetRefreshOperation::ASSET_OPERATION_UNTRASH, HandleAssetUntrash},
50 {AssetRefreshOperation::ASSET_OPERATION_HIDDEN, HandleAssetHidden},
51 {AssetRefreshOperation::ASSET_OPERATION_UNHIDDEN, HandleAssetUnhidden},
52 {AssetRefreshOperation::ASSET_OPERATION_RECHECK, HandleAssetRecheck},
53
54 {AlbumRefreshOperation::ALBUM_OPERATION_ADD, HandleAlbumAdd},
55 {AlbumRefreshOperation::ALBUM_OPERATION_UPDATE, HandleAlbumUpdate},
56 {AlbumRefreshOperation::ALBUM_OPERATION_REMOVE, HandleAlbumRemove},
57 {AlbumRefreshOperation::ALBUM_OPERATION_UPDATE_HIDDEN, HandleAlbumUpdateHidden},
58 {AlbumRefreshOperation::ALBUM_OPERATION_UPDATE_TRASH, HandleAlbumUpdateTrash},
59 {AlbumRefreshOperation::ALBUM_OPERATION_RECHECK, HandleAlbumRecheck},
60 };
61 std::unordered_set<int32_t> NotificationClassification::addAlbumIdSet_;
62 std::mutex NotificationClassification::addAlbumIdMutex_;
63
NotificationClassification()64 NotificationClassification::NotificationClassification()
65 {}
66
~NotificationClassification()67 NotificationClassification::~NotificationClassification()
68 {}
69
ConvertNotification(std::vector<NotifyInfoInner> & notifyInfos,std::vector<MediaChangeInfo> & mediaChangeInfos)70 void NotificationClassification::ConvertNotification(
71 std::vector<NotifyInfoInner> ¬ifyInfos, std::vector<MediaChangeInfo> &mediaChangeInfos)
72 {
73 MEDIA_INFO_LOG("ConvertNotification");
74 for (NotifyInfoInner notifyInfoInner : notifyInfos) {
75 auto it = classificationMap.find(notifyInfoInner.operationType);
76 if (it != classificationMap.end()) {
77 std::vector<MediaChangeInfo> infos = it->second(notifyInfoInner);
78 mediaChangeInfos.insert(mediaChangeInfos.end(), infos.begin(), infos.end());
79 }
80 }
81 }
82
BuildMediaChangeInfo(NotifyInfoInner & notifyInfoInner,bool isForRecheck,NotifyType notifyType,NotifyUriType notifyUri)83 MediaChangeInfo NotificationClassification::BuildMediaChangeInfo(
84 NotifyInfoInner ¬ifyInfoInner, bool isForRecheck, NotifyType notifyType, NotifyUriType notifyUri)
85 {
86 MediaChangeInfo mediaChangeInfo;
87 std::vector<std::variant<PhotoAssetChangeData, AlbumChangeData>> changeInfos = notifyInfoInner.infos;
88 mediaChangeInfo.changeInfos = changeInfos;
89 mediaChangeInfo.isForRecheck = isForRecheck;
90 mediaChangeInfo.notifyUri = notifyUri;
91 mediaChangeInfo.notifyType = notifyType;
92 return mediaChangeInfo;
93 }
94
HandleAssetAdd(NotifyInfoInner & notifyInfoInner)95 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetAdd(NotifyInfoInner ¬ifyInfoInner)
96 {
97 MEDIA_INFO_LOG("HandleAssetAdd");
98 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::PHOTO_URI)};
99 }
100
HandleAssetAddHidden(NotifyInfoInner & notifyInfoInner)101 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetAddHidden(NotifyInfoInner ¬ifyInfoInner)
102 {
103 MEDIA_INFO_LOG("HandleAssetAddHidden");
104 return {
105 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::HIDDEN_PHOTO_URI)};
106 }
107
HandleAssetAddTrash(NotifyInfoInner & notifyInfoInner)108 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetAddTrash(NotifyInfoInner ¬ifyInfoInner)
109 {
110 MEDIA_INFO_LOG("HandleAssetAddTrash");
111 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::TRASH_PHOTO_URI)};
112 }
113
HandleAssetUpdateNormal(NotifyInfoInner & notifyInfoInner)114 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateNormal(NotifyInfoInner ¬ifyInfoInner)
115 {
116 MEDIA_INFO_LOG("HandleAssetUpdateNormal");
117 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_UPDATE, NotifyUriType::PHOTO_URI)};
118 }
119
HandleAssetUpdateRemoveNormal(NotifyInfoInner & notifyInfoInner)120 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateRemoveNormal(NotifyInfoInner ¬ifyInfoInner)
121 {
122 MEDIA_INFO_LOG("HandleAssetUpdateRemoveNormal");
123 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::PHOTO_URI)};
124 }
125
HandleAssetUpdateAddNormal(NotifyInfoInner & notifyInfoInner)126 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateAddNormal(NotifyInfoInner ¬ifyInfoInner)
127 {
128 MEDIA_INFO_LOG("HandleAssetUpdateAddNormal");
129 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::PHOTO_URI)};
130 }
131
HandleAssetUpdateHidden(NotifyInfoInner & notifyInfoInner)132 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateHidden(NotifyInfoInner ¬ifyInfoInner)
133 {
134 MEDIA_INFO_LOG("HandleAssetUpdateHidden");
135 return {
136 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_UPDATE, NotifyUriType::HIDDEN_PHOTO_URI)};
137 }
138
HandleAssetUpdateRemoveHidden(NotifyInfoInner & notifyInfoInner)139 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateRemoveHidden(NotifyInfoInner ¬ifyInfoInner)
140 {
141 MEDIA_INFO_LOG("HandleAssetUpdateRemoveHidden");
142 return {
143 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::HIDDEN_PHOTO_URI)};
144 }
145
HandleAssetUpdateAddHidden(NotifyInfoInner & notifyInfoInner)146 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateAddHidden(NotifyInfoInner ¬ifyInfoInner)
147 {
148 MEDIA_INFO_LOG("HandleAssetUpdateAddHidden");
149 return {
150 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::HIDDEN_PHOTO_URI)};
151 }
152
HandleAssetUpdateTrash(NotifyInfoInner & notifyInfoInner)153 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateTrash(NotifyInfoInner ¬ifyInfoInner)
154 {
155 MEDIA_INFO_LOG("HandleAssetUpdateTrash");
156 return {
157 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_UPDATE, NotifyUriType::TRASH_PHOTO_URI)};
158 }
159
HandleAssetUpdateRemoveTrash(NotifyInfoInner & notifyInfoInner)160 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateRemoveTrash(NotifyInfoInner ¬ifyInfoInner)
161 {
162 MEDIA_INFO_LOG("HandleAssetUpdateRemoveTrash");
163 return {
164 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::TRASH_PHOTO_URI)};
165 }
166
HandleAssetUpdateAddTrash(NotifyInfoInner & notifyInfoInner)167 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUpdateAddTrash(NotifyInfoInner ¬ifyInfoInner)
168 {
169 MEDIA_INFO_LOG("HandleAssetUpdateAddTrash");
170 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::TRASH_PHOTO_URI)};
171 }
172
HandleAssetTrash(NotifyInfoInner & notifyInfoInner)173 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetTrash(NotifyInfoInner ¬ifyInfoInner)
174 {
175 MEDIA_INFO_LOG("HandleAssetTrash");
176 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::PHOTO_URI),
177 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::TRASH_PHOTO_URI)};
178 }
179
HandleAssetUntrash(NotifyInfoInner & notifyInfoInner)180 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUntrash(NotifyInfoInner ¬ifyInfoInner)
181 {
182 MEDIA_INFO_LOG("HandleAssetUntrash");
183 std::vector<NotifyDetailInfo> notifyDetails;
184 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::PHOTO_URI),
185 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::TRASH_PHOTO_URI)};
186 }
187
HandleAssetRemove(NotifyInfoInner & notifyInfoInner)188 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetRemove(NotifyInfoInner ¬ifyInfoInner)
189 {
190 MEDIA_INFO_LOG("HandleAssetRemove");
191 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::PHOTO_URI)};
192 }
193
HandleAssetRemoveHidden(NotifyInfoInner & notifyInfoInner)194 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetRemoveHidden(NotifyInfoInner ¬ifyInfoInner)
195 {
196 MEDIA_INFO_LOG("HandleAssetRemoveHidden");
197 return {
198 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::HIDDEN_PHOTO_URI)};
199 }
200
HandleAssetRemoveTrash(NotifyInfoInner & notifyInfoInner)201 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetRemoveTrash(NotifyInfoInner ¬ifyInfoInner)
202 {
203 MEDIA_INFO_LOG("HandleAssetRemoveTrash");
204 return {
205 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::TRASH_PHOTO_URI)};
206 }
207
HandleAssetHidden(NotifyInfoInner & notifyInfoInner)208 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetHidden(NotifyInfoInner ¬ifyInfoInner)
209 {
210 MEDIA_INFO_LOG("HandleAssetHidden");
211 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::PHOTO_URI),
212 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::HIDDEN_PHOTO_URI)};
213 }
214
HandleAssetUnhidden(NotifyInfoInner & notifyInfoInner)215 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetUnhidden(NotifyInfoInner ¬ifyInfoInner)
216 {
217 MEDIA_INFO_LOG("HandleAssetUnhidden");
218 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::PHOTO_URI),
219 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ASSET_REMOVE, NotifyUriType::HIDDEN_PHOTO_URI)};
220 }
HandleAssetRecheck(NotifyInfoInner & notifyInfoInner)221 std::vector<MediaChangeInfo> NotificationClassification::HandleAssetRecheck(NotifyInfoInner ¬ifyInfoInner)
222 {
223 MEDIA_INFO_LOG("HandleAssetRecheck");
224 return {BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::PHOTO_URI),
225 BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::HIDDEN_PHOTO_URI),
226 BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ASSET_ADD, NotifyUriType::TRASH_PHOTO_URI)};
227 }
228
HandleAlbumAdd(NotifyInfoInner & notifyInfoInner)229 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumAdd(NotifyInfoInner ¬ifyInfoInner)
230 {
231 MEDIA_INFO_LOG("HandleAlbumAdd");
232 return {BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ALBUM_ADD, NotifyUriType::PHOTO_ALBUM_URI)};
233 }
234
HandleAlbumRemove(NotifyInfoInner & notifyInfoInner)235 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumRemove(NotifyInfoInner ¬ifyInfoInner)
236 {
237 MEDIA_INFO_LOG("HandleAlbumRemove");
238 return {
239 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ALBUM_REMOVE, NotifyUriType::PHOTO_ALBUM_URI)};
240 }
241
HandleAlbumUpdate(NotifyInfoInner & notifyInfoInner)242 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumUpdate(NotifyInfoInner ¬ifyInfoInner)
243 {
244 std::lock_guard<std::mutex> lock(addAlbumIdMutex_);
245 MEDIA_INFO_LOG("HandleAlbumUpdate");
246 if (!addAlbumIdSet_.empty()) {
247 return HandleAlbumAddAndUpdate(notifyInfoInner);
248 }
249 return {
250 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ALBUM_UPDATE, NotifyUriType::PHOTO_ALBUM_URI)};
251 }
252
HandleAlbumUpdateHidden(NotifyInfoInner & notifyInfoInner)253 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumUpdateHidden(NotifyInfoInner ¬ifyInfoInner)
254 {
255 MEDIA_INFO_LOG("HandleAlbumHidden");
256 return {
257 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ALBUM_UPDATE, NotifyUriType::HIDDEN_ALBUM_URI)};
258 }
259
HandleAlbumUpdateTrash(NotifyInfoInner & notifyInfoInner)260 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumUpdateTrash(NotifyInfoInner ¬ifyInfoInner)
261 {
262 MEDIA_INFO_LOG("HandleAlbumTrash");
263 return {
264 BuildMediaChangeInfo(notifyInfoInner, false, NotifyType::NOTIFY_ALBUM_UPDATE, NotifyUriType::TRASH_ALBUM_URI)};
265 }
266
HandleAlbumRecheck(NotifyInfoInner & notifyInfoInner)267 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumRecheck(NotifyInfoInner ¬ifyInfoInner)
268 {
269 MEDIA_INFO_LOG("HandleAlbumRecheck");
270 return {BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ALBUM_ADD, NotifyUriType::PHOTO_ALBUM_URI),
271 BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ALBUM_ADD, NotifyUriType::HIDDEN_ALBUM_URI),
272 BuildMediaChangeInfo(notifyInfoInner, true, NotifyType::NOTIFY_ALBUM_ADD, NotifyUriType::TRASH_ALBUM_URI)};
273 }
274
HandleAlbumAddAndUpdate(NotifyInfoInner & notifyInfoInner)275 std::vector<MediaChangeInfo> NotificationClassification::HandleAlbumAddAndUpdate(NotifyInfoInner ¬ifyInfoInner)
276 {
277 MEDIA_INFO_LOG("HandleAlbumAddAndUpdate");
278 std::vector<MediaChangeInfo> mediaChangeInfo;
279 MediaChangeInfo addMediaChangeInfo;
280 MediaChangeInfo updateMediaChangeInfo;
281
282 for (auto &info : notifyInfoInner.infos) {
283 if (auto infoPtr = std::get_if<AccurateRefresh::AlbumChangeData>(&info)) {
284 if (addAlbumIdSet_.find(infoPtr->infoBeforeChange_.albumId_) != addAlbumIdSet_.end()) {
285 addAlbumIdSet_.erase(infoPtr->infoBeforeChange_.albumId_);
286 infoPtr->infoBeforeChange_.albumId_ = AccurateRefresh::INVALID_INT32_VALUE;
287 addMediaChangeInfo.changeInfos.emplace_back(info);
288 continue;
289 }
290 updateMediaChangeInfo.changeInfos.emplace_back(info);
291 }
292 }
293
294 addMediaChangeInfo.isForRecheck = false;
295 addMediaChangeInfo.notifyUri = NotifyUriType::PHOTO_ALBUM_URI;
296 addMediaChangeInfo.notifyType = NotifyType::NOTIFY_ALBUM_ADD;
297 mediaChangeInfo.emplace_back(addMediaChangeInfo);
298
299 updateMediaChangeInfo.isForRecheck = false;
300 updateMediaChangeInfo.notifyUri = NotifyUriType::PHOTO_ALBUM_URI;
301 updateMediaChangeInfo.notifyType = NotifyType::NOTIFY_ALBUM_UPDATE;
302 mediaChangeInfo.emplace_back(updateMediaChangeInfo);
303
304 return mediaChangeInfo;
305 }
306
AddAlbum(const std::string & albumId)307 void NotificationClassification::AddAlbum(const std::string &albumId)
308 {
309 std::lock_guard<std::mutex> lock(addAlbumIdMutex_);
310 MEDIA_INFO_LOG("addAlbumIdSet_ insert albumId: %{public}s", albumId.c_str());
311 if (!MediaLibraryCommonUtils::CanConvertStrToInt32(albumId)) {
312 MEDIA_ERR_LOG("can not convert albumId to int");
313 return;
314 }
315 addAlbumIdSet_.emplace(std::stoi(albumId));
316 }
317 } // namespace Notification
318 } // namespace Media
319 } // namespace OHOS