1 /*
2 * Copyright (C) 2022 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 #define MLOG_TAG "Thumbnail"
16
17 #include "thumbnail_service.h"
18
19 #include "display_manager.h"
20 #include "medialibrary_async_worker.h"
21 #include "medialibrary_errno.h"
22 #include "media_log.h"
23 #include "thumbnail_aging_helper.h"
24 #include "thumbnail_const.h"
25 #include "thumbnail_generate_helper.h"
26 #include "thumbnail_helper_factory.h"
27 #include "thumbnail_uri_utils.h"
28
29 using namespace std;
30 using namespace OHOS::DistributedKv;
31 using namespace OHOS::NativeRdb;
32 using namespace OHOS::AbilityRuntime;
33
34 namespace OHOS {
35 namespace Media {
36 std::shared_ptr<ThumbnailService> ThumbnailService::thumbnailServiceInstance_{nullptr};
37 std::mutex ThumbnailService::instanceLock_;
ThumbnailService(void)38 ThumbnailService::ThumbnailService(void)
39 {
40 rdbStorePtr_ = nullptr;
41 kvStorePtr_ = nullptr;
42 }
43
GetInstance()44 shared_ptr<ThumbnailService> ThumbnailService::GetInstance()
45 {
46 if (thumbnailServiceInstance_ == nullptr) {
47 std::lock_guard<std::mutex> lockGuard(instanceLock_);
48 if (thumbnailServiceInstance_ != nullptr) {
49 return thumbnailServiceInstance_;
50 }
51 thumbnailServiceInstance_ = shared_ptr<ThumbnailService>(new (std::nothrow)ThumbnailService());
52 }
53
54 return thumbnailServiceInstance_;
55 }
56
GetDefaultWindowSize(int32_t & size)57 static int32_t GetDefaultWindowSize(int32_t &size)
58 {
59 auto &displayMgr = OHOS::Rosen::DisplayManager::GetInstance();
60 auto display = displayMgr.GetDefaultDisplay();
61 if (display == nullptr) {
62 return E_ERR;
63 }
64 auto width = display->GetWidth();
65 auto height = display->GetHeight();
66 MEDIA_INFO_LOG("display window size::w %{public}d, h %{public}d", width, height);
67 auto maxSize = max(width, height);
68 if (maxSize > FULL_SCREEN_SIZE) {
69 size = FULL_SCREEN_SIZE;
70 }
71 return E_OK;
72 }
73
Init(const shared_ptr<RdbStore> & rdbStore,const shared_ptr<SingleKvStore> & kvStore,const shared_ptr<Context> & context)74 int32_t ThumbnailService::Init(const shared_ptr<RdbStore> &rdbStore,
75 const shared_ptr<SingleKvStore> &kvStore,
76 const shared_ptr<Context> &context)
77 {
78 rdbStorePtr_ = rdbStore;
79 kvStorePtr_ = kvStore;
80 context_ = context;
81
82 return GetDefaultWindowSize(windowSize_);
83 }
84
ReleaseService()85 void ThumbnailService::ReleaseService()
86 {
87 StopAllWorker();
88 rdbStorePtr_ = nullptr;
89 kvStorePtr_ = nullptr;
90 context_ = nullptr;
91 thumbnailServiceInstance_ = nullptr;
92 }
93
GetThumbnail(const string & uri)94 shared_ptr<DataShare::ResultSetBridge> ThumbnailService::GetThumbnail(const string &uri)
95 {
96 string fileId;
97 string networkId;
98 string uriString = uri;
99
100 Size size;
101 bool success = ThumbnailUriUtils::ParseThumbnailInfo(uriString, fileId, size, networkId);
102 if (!success) {
103 return nullptr;
104 }
105 ThumbRdbOpt opts = {
106 .store = rdbStorePtr_,
107 .kvStore = kvStorePtr_,
108 .context = context_,
109 .networkId = networkId,
110 .row = fileId,
111 .uri = uri
112 };
113 shared_ptr<DataShare::ResultSetBridge> resultSet;
114 shared_ptr<IThumbnailHelper> thumbnailHelper = ThumbnailHelperFactory::GetThumbnailHelper(size);
115 if (thumbnailHelper == nullptr) {
116 MEDIA_ERR_LOG("thumbnailHelper nullptr");
117 return nullptr;
118 }
119 if (ThumbnailHelperFactory::IsThumbnailFromLcd(size)) {
120 opts.size = windowSize_;
121 }
122 int32_t err = thumbnailHelper->GetThumbnailPixelMap(opts, resultSet);
123 if (err != E_OK) {
124 MEDIA_ERR_LOG("GetThumbnailPixelMap failed : %{public}d", err);
125 return nullptr;
126 }
127 return resultSet;
128 }
129
CreateThumbnailAsync(const std::string & uri)130 int32_t ThumbnailService::CreateThumbnailAsync(const std::string &uri)
131 {
132 string fileId;
133 string networkId;
134 if (!ThumbnailUriUtils::ParseFileUri(uri, fileId, networkId)) {
135 MEDIA_ERR_LOG("ParseThumbnailInfo faild");
136 return E_ERR;
137 }
138
139 ThumbRdbOpt opts = {
140 .store = rdbStorePtr_,
141 .kvStore = kvStorePtr_,
142 .row = fileId
143 };
144 Size size = { DEFAULT_THUMBNAIL_SIZE, DEFAULT_THUMBNAIL_SIZE };
145 shared_ptr<IThumbnailHelper> thumbnailHelper = ThumbnailHelperFactory::GetThumbnailHelper(size);
146 if (thumbnailHelper == nullptr) {
147 MEDIA_ERR_LOG("thumbnailHelper nullptr");
148 return E_ERR;
149 }
150 int32_t err = thumbnailHelper->CreateThumbnail(opts);
151 if (err != E_OK) {
152 MEDIA_ERR_LOG("CreateThumbnail failed : %{public}d", err);
153 return err;
154 }
155
156 size = { DEFAULT_LCD_SIZE, DEFAULT_LCD_SIZE };
157 shared_ptr<IThumbnailHelper> lcdHelper = ThumbnailHelperFactory::GetThumbnailHelper(size);
158 if (lcdHelper == nullptr) {
159 MEDIA_ERR_LOG("lcdHelper nullptr");
160 return E_ERR;
161 }
162 opts.size = windowSize_;
163 err = lcdHelper->CreateThumbnail(opts);
164 if (err != E_OK) {
165 MEDIA_ERR_LOG("CreateLcd failed : %{public}d", err);
166 return err;
167 }
168 return err;
169 }
170
CreateThumbnail(const std::string & uri)171 int32_t ThumbnailService::CreateThumbnail(const std::string &uri)
172 {
173 string fileId;
174 string networkId;
175 Size size;
176 bool success = ThumbnailUriUtils::ParseThumbnailInfo(uri, fileId, size, networkId);
177 if (!success) {
178 MEDIA_ERR_LOG("ParseThumbnailInfo faild");
179 return E_ERR;
180 }
181
182 ThumbRdbOpt opts = {
183 .store = rdbStorePtr_,
184 .kvStore = kvStorePtr_,
185 .context = context_,
186 .row = fileId
187 };
188 shared_ptr<IThumbnailHelper> thumbnailHelper = ThumbnailHelperFactory::GetThumbnailHelper(size);
189 if (thumbnailHelper == nullptr) {
190 MEDIA_ERR_LOG("thumbnailHelper nullptr");
191 return E_ERR;
192 }
193 if (ThumbnailHelperFactory::IsThumbnailFromLcd(size)) {
194 opts.size = windowSize_;
195 }
196 int32_t err = thumbnailHelper->CreateThumbnail(opts, true);
197 if (err != E_OK) {
198 MEDIA_ERR_LOG("CreateLcd failed : %{public}d", err);
199 return err;
200 }
201 return err;
202 }
203
InterruptBgworker()204 void ThumbnailService::InterruptBgworker()
205 {
206 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
207 if (asyncWorker != nullptr) {
208 asyncWorker->Interrupt();
209 }
210 }
211
StopAllWorker()212 void ThumbnailService::StopAllWorker()
213 {
214 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
215 if (asyncWorker != nullptr) {
216 asyncWorker->Stop();
217 }
218 }
219
GenerateThumbnails()220 int32_t ThumbnailService::GenerateThumbnails()
221 {
222 ThumbRdbOpt opts = {
223 .store = rdbStorePtr_,
224 .kvStore = kvStorePtr_,
225 .table = MEDIALIBRARY_TABLE
226 };
227 int32_t err = ThumbnailGenerateHelper::CreateLcdBatch(opts);
228 if (err != E_OK) {
229 MEDIA_ERR_LOG("CreateLcdBatch failed : %{public}d", err);
230 }
231
232 err = ThumbnailGenerateHelper::CreateThumbnailBatch(opts);
233 if (err != E_OK) {
234 MEDIA_ERR_LOG("CreateThumbnailBatch failed : %{public}d", err);
235 }
236
237 return err;
238 }
239
LcdAging()240 int32_t ThumbnailService::LcdAging()
241 {
242 ThumbRdbOpt opts = {
243 .store = rdbStorePtr_,
244 .kvStore = kvStorePtr_,
245 .table = MEDIALIBRARY_TABLE,
246 };
247 int32_t err = ThumbnailAgingHelper::AgingLcdBatch(opts);
248 if (err != E_OK) {
249 MEDIA_ERR_LOG("AgingLcdBatch failed : %{public}d", err);
250 }
251
252 return E_OK;
253 }
254
LcdDistributeAging(const string & udid)255 int32_t ThumbnailService::LcdDistributeAging(const string &udid)
256 {
257 ThumbRdbOpt opts = {
258 .store = rdbStorePtr_,
259 .kvStore = kvStorePtr_,
260 .udid = udid
261 };
262 int32_t err = ThumbnailAgingHelper::AgingDistributeLcdBatch(opts);
263 if (err != E_OK) {
264 MEDIA_ERR_LOG("AgingDistributeLcdBatch failed : %{public}d", err);
265 return err;
266 }
267 return E_OK;
268 }
269
InvalidateDistributeThumbnail(const string & udid)270 int32_t ThumbnailService::InvalidateDistributeThumbnail(const string &udid)
271 {
272 ThumbRdbOpt opts = {
273 .store = rdbStorePtr_,
274 .kvStore = kvStorePtr_,
275 .udid = udid
276 };
277 int32_t err = ThumbnailAgingHelper::InvalidateDistributeBatch(opts);
278 if (err != E_OK) {
279 MEDIA_ERR_LOG("InvalidateDistributeBatch failed : %{public}d", err);
280 }
281 return err;
282 }
283
ParseThumbnailInfo(const string & uriString)284 bool ThumbnailService::ParseThumbnailInfo(const string &uriString)
285 {
286 return ThumbnailUriUtils::ParseThumbnailInfo(uriString);
287 }
288
InvalidateThumbnail(const std::string & id)289 void ThumbnailService::InvalidateThumbnail(const std::string &id)
290 {
291 ThumbRdbOpt opts = {
292 .store = rdbStorePtr_,
293 .kvStore = kvStorePtr_,
294 .table = MEDIALIBRARY_TABLE,
295 .row = id,
296 };
297 ThumbnailData thumbnailData;
298 thumbnailData.thumbnailKey = "invalid";
299 thumbnailData.lcdKey = "invalid";
300 ThumbnailUtils::DeleteOriginImage(opts, thumbnailData);
301 ThumbnailUtils::CleanThumbnailInfo(opts, true, true);
302 }
303 } // namespace Media
304 } // namespace OHOS
305