Debian Codegraph @

src/album/imageengine/imageengineapi.cpp

raw
1 /*
2 * Copyright (C) 2020 ~ 2021 Uniontech Software Technology Co., Ltd.
3 *
4 * Author: ZhangYong <[email protected]>
5 *
6 * Maintainer: ZhangYong <[email protected]>
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21 #include "imageengineapi.h"
22 #include "DBandImgOperate.h"
23 #include "controller/signalmanager.h"
24 #include "application.h"
25 #include "imageengineapi.h"
26 #include <QMetaType>
27 #include <QDirIterator>
28 #include <QStandardPaths>
29 #include <QSqlDatabase>
30 #include <QSqlError>
31 #include <QSqlQuery>
32 #include "utils/unionimage.h"
33 #include "utils/baseutils.h"
34 #include "albumgloabl.h"
35 #include "imagedataservice.h"
36
37 ImageEngineApi *ImageEngineApi::s_ImageEngine = nullptr;
38
39 ImageEngineApi *ImageEngineApi::instance(QObject *parent)
40 {
41 Q_UNUSED(parent);
42 if (!s_ImageEngine) {
43 s_ImageEngine = new ImageEngineApi();
44 }
45 return s_ImageEngine;
46 }
47
48 ImageEngineApi::~ImageEngineApi()
49 {
50 #ifdef NOGLOBAL
51 m_qtpool.clear();
52 m_qtpool.waitForDone();
53 cacheThreadPool.clear();
54 cacheThreadPool.waitForDone();
55 #else
56 QThreadPool::globalInstance()->clear(); //清除队列
57 QThreadPool::globalInstance()->waitForDone();
58 #endif
59
60 //销毁
61 delete m_imageCacheSaveobj;
62 }
63
64 ImageEngineApi::ImageEngineApi(QObject *parent)
65 {
66 Q_UNUSED(parent);
67 //文件加载线程池上限
68
69 qRegisterMetaType<QStringList>("QStringList &");
70 qRegisterMetaType<DBImgInfo>("ImageDataSt &");
71 qRegisterMetaType<DBImgInfo>("ImageDataSt");
72 qRegisterMetaType<DBImgInfoList>("DBImgInfoList");
73 qRegisterMetaType<QMap<QString, DBImgInfo>>("QMap<QString,DBImgInfo>");
74 qRegisterMetaType<QVector<DBImgInfo>>("QVector<ImageDataSt>");
75 #ifdef NOGLOBAL
76 m_qtpool.setMaxThreadCount(4);
77 cacheThreadPool.setMaxThreadCount(4);
78 #else
79 QThreadPool::globalInstance()->setMaxThreadCount(12);
80 QThreadPool::globalInstance()->setExpiryTimeout(10);
81 #endif
82 }
83
84 bool ImageEngineApi::insertObject(void *obj)
85 {
86 m_AllObject.insert(obj, obj);
87 return true;
88 }
89 bool ImageEngineApi::removeObject(void *obj)
90 {
91 QMap<void *, void *>::iterator it;
92 it = m_AllObject.find(obj);
93 if (it != m_AllObject.end()) {
94 m_AllObject.erase(it);
95 return true;
96 }
97 return false;
98 }
99
100 bool ImageEngineApi::ifObjectExist(void *obj)
101 {
102 return m_AllObject.contains(obj);
103 }
104
105 bool ImageEngineApi::removeImage(QString imagepath)
106 {
107 static QStringList dbremovelist;
108 dbremovelist.append(imagepath);
109 if (QThreadPool::globalInstance()->activeThreadCount() < 1) {
110 DBManager::instance()->removeImgInfos(dbremovelist);
111 dbremovelist.clear();
112 emit dApp->signalM->updatePicView(0);
113 }
114
115 if (m_AllImageData.contains(imagepath)) {
116 return m_AllImageData.remove(imagepath);
117 }
118 return false;
119 }
120
121 bool ImageEngineApi::removeImage(QStringList imagepathList)
122 {
123 for (const auto &imagepath : imagepathList) {
124 m_AllImageData.remove(imagepath);
125 }
126 return true;
127 }
128
129 bool ImageEngineApi::insertImage(const QString &imagepath, const QString &remainDay, bool reLoadIsvideo)
130 {
131 bool bexsit = m_AllImageData.contains(imagepath);
132 if (bexsit && remainDay.isEmpty()) {
133 return false;
134 }
135
136 DBImgInfo data;
137 if (bexsit) {
138 data = m_AllImageData[imagepath];
139 }
140
141 if (reLoadIsvideo) {
142 bool isVideo = utils::base::isVideo(imagepath);
143 if (isVideo) {
144 data.itemType = ItemTypeVideo;
145 } else {
146 data.itemType = ItemTypePic;
147 }
148 }
149 addImageData(imagepath, data);
150 return true;
151 }
152
153 bool ImageEngineApi::getImageData(QString imagepath, DBImgInfo &data)
154 {
155 QMap<QString, DBImgInfo>::iterator it;
156 it = m_AllImageData.find(imagepath);
157 if (it == m_AllImageData.end()) {
158 return false;
159 }
160 data = it.value();
161 return true;
162 }
163
164 //void ImageEngineApi::sltImageLocalLoaded(void *imgobject, QStringList &filelist)
165 //{
166 // if (nullptr != imgobject && ifObjectExist(imgobject)) {
167 // static_cast<ImageEngineObject *>(imgobject)->imageLocalLoaded(filelist);
168 // }
169 //}
170
171 //void ImageEngineApi::sltImageDBLoaded(void *imgobject, QStringList &filelist)
172 //{
173 // if (nullptr != imgobject && ifObjectExist(imgobject)) {
174 // static_cast<ImageEngineObject *>(imgobject)->imageFromDBLoaded(filelist);
175 // }
176 //}
177
178 //void ImageEngineApi::sltImageFilesGeted(void *imgobject, QStringList &filelist, QString path)
179 //{
180 // if (nullptr != imgobject && ifObjectExist(imgobject)) {
181 // static_cast<ImageMountGetPathsObject *>(imgobject)->imageGeted(filelist, path);
182 // }
183 //}
184
185 void ImageEngineApi::sltImageFilesImported(void *imgobject, QStringList &filelist)
186 {
187 if (nullptr != imgobject && ifObjectExist(imgobject)) {
188 static_cast<ImageMountImportPathsObject *>(imgobject)->imageMountImported(filelist);
189 }
190 }
191
192 //void ImageEngineApi::sltstopCacheSave()
193 //{
194 //#ifdef NOGLOBAL
195 // cacheThreadPool.waitForDone();
196 //#else
197 // qDebug() << "析构缓存对象线程";
198 // QThreadPool::globalInstance()->clear();
199 // QThreadPool::globalInstance()->waitForDone();
200
201 //#endif
202 //}
203
204 void ImageEngineApi::sigImageBackLoaded(QString path, const DBImgInfo &data)
205 {
206 addImageData(path, data);
207 }
208
209 void ImageEngineApi::slt80ImgInfosReady(QVector<DBImgInfo> ImageDatas)
210 {
211 m_AllImageDataVector = ImageDatas;
212 for (int i = 0; i < ImageDatas.size(); i++) {
213 DBImgInfo data = ImageDatas.at(i);
214 addImageData(data.filePath, data);
215 }
216 emit sigLoadFirstPageThumbnailsToView();
217 }
218
219 bool ImageEngineApi::ImportImagesFromUrlList(QList<QUrl> files, QString albumname, ImageEngineImportObject *obj, bool bdialogselect)
220 {
221 emit dApp->signalM->popupWaitDialog(QObject::tr("Importing..."));
222 ImportImagesThread *imagethread = new ImportImagesThread;
223 imagethread->setData(files, albumname, obj, bdialogselect);
224 obj->addThread(imagethread);
225 #ifdef NOGLOBAL
226 m_qtpool.start(imagethread);
227 #else
228 QThreadPool::globalInstance()->start(imagethread);
229 #endif
230 return true;
231 }
232
233 void ImageEngineApi::setImgPathAndAlbumNames()
234 {
235 GetAllPathAlbumNamesThread *imagethread = new GetAllPathAlbumNamesThread();
236 QThreadPool::globalInstance()->start(imagethread);
237 }
238
239 bool ImageEngineApi::ImportImagesFromFileList(QStringList files, QString albumname, ImageEngineImportObject *obj, bool bdialogselect)
240 {
241 emit dApp->signalM->popupWaitDialog(QObject::tr("Importing..."));
242 ImportImagesThread *imagethread = new ImportImagesThread;
243 imagethread->setData(files, albumname, obj, bdialogselect);
244 obj->addThread(imagethread);
245 #ifdef NOGLOBAL
246 m_qtpool.start(imagethread);
247 #else
248 QThreadPool::globalInstance()->start(imagethread);
249 #endif
250 return true;
251 }
252
253 //bool ImageEngineApi::loadImagesFromPath(ImageEngineObject *obj, QString path)
254 //{
255 // sltImageDBLoaded(obj, QStringList() << path);
256 // insertImage(path, "30");
257 // return true;
258 //}
259
260 bool ImageEngineApi::loadImageDateToMemory(QStringList pathlist, QString devName)
261 {
262 bool iRet = false;
263 //判断是否已经在线程中加载LMH0426
264 QStringList tmpPathlist = pathlist;
265 if (m_AllImageData.count() > 0) {
266 for (auto imagepath : pathlist) {
267 if (m_AllImageData.contains(imagepath)) {
268 tmpPathlist.removeOne(imagepath);
269 }
270 }
271 }
272 if (tmpPathlist.count() > 0) {
273 ImageEngineBackThread *imagethread = new ImageEngineBackThread;
274 imagethread->setData(tmpPathlist, devName);
275 connect(imagethread, &ImageEngineBackThread::sigImageBackLoaded, this, &ImageEngineApi::sigImageBackLoaded, Qt::QueuedConnection);
276 #ifdef NOGLOBAL
277 m_qtpool.start(imagethread);
278 #else
279 QThreadPool::globalInstance()->start(imagethread);
280 #endif
281 iRet = true;
282 } else {
283 iRet = false;
284 }
285 return iRet;
286 }
287
288 void ImageEngineApi::loadFirstPageThumbnails(int num, bool clearCache)
289 {
290 qDebug() << __FUNCTION__ << "---";
291
292 m_FirstPageScreen = num;
293 if (clearCache) {
294 m_AllImageDataVector.clear();
295 }
296 thumbnailLoadThread(num);
297
298 QSqlDatabase db = DBManager::instance()->getDatabase();
299 if (!db.isValid()) {
300 return;
301 }
302 QStringList list;
303 int count = 0;
304 QSqlQuery query(db);
305 query.setForwardOnly(true);
306 bool b = query.prepare(QString("SELECT FilePath, FileName, Dir, Time, ChangeTime, ImportTime, FileType FROM ImageTable3 order by Time desc limit %1").arg(QString::number(num)));
307 // bool b = query.prepare(QString("SELECT FilePath, FileName, Dir, Time, ChangeTime, ImportTime, FileType FROM ImageTable3 order by Time desc"));
308 if (!b || !query.exec()) {
309 qDebug() << "------" << __FUNCTION__ << query.lastError();
310 return;
311 } else {
312 using namespace utils::base;
313 while (query.next()) {
314 DBImgInfo info;
315 info.filePath = query.value(0).toString();
316 if (count < num) {
317 list << info.filePath;
318 count++;
319 }
320 info.fileName = query.value(1).toString();
321 info.dirHash = query.value(2).toString();
322 info.time = stringToDateTime(query.value(3).toString());
323 info.changeTime = QDateTime::fromString(query.value(4).toString(), DATETIME_FORMAT_DATABASE);
324 info.importTime = QDateTime::fromString(query.value(5).toString(), DATETIME_FORMAT_DATABASE);
325 info.itemType = static_cast<ItemType>(query.value(6).toInt());
326 addImageData(info.filePath, info);
327 m_AllImageDataVector.append(info);
328 }
329 }
330
331 db.close();
332 qDebug() << "------" << __FUNCTION__ << "" << m_AllImageDataVector.size();
333 m_firstPageIsLoaded = true;
334 ImageDataService::instance()->readThumbnailByPaths(list);
335
336 emit sigLoadFirstPageThumbnailsToView();
337 }
338
339 void ImageEngineApi::thumbnailLoadThread(int num)
340 {
341 Q_UNUSED(num)
342 if (m_worker != nullptr) {
343 return;
344 }
345 QThread *workerThread = new QThread(this);
346 m_worker = new DBandImgOperate(workerThread);
347
348 m_worker->moveToThread(workerThread);
349 //开始录制
350 connect(this, &ImageEngineApi::sigLoadThumbnailsByNum, m_worker, &DBandImgOperate::sltLoadThumbnailByNum);
351 // connect(this, &ImageEngineApi::sigLoadThumbnailIMG, m_worker, &DBandImgOperate::loadOneImg);
352 //加载设备中文件列表
353 connect(this, &ImageEngineApi::sigLoadMountFileList, m_worker, &DBandImgOperate::sltLoadMountFileList);
354 //旋转一张图片
355 connect(this, &ImageEngineApi::sigRotateImageFile, m_worker, &DBandImgOperate::rotateImageFile);
356
357 //收到获取全部照片信息成功信号
358 connect(m_worker, &DBandImgOperate::sig80ImgInfosReady, this, &ImageEngineApi::slt80ImgInfosReady);
359 connect(m_worker, &DBandImgOperate::sigOneImgReady, this, &ImageEngineApi::sigOneImgReady);
360 //加载设备中文件列表完成,发送到主线程
361 connect(m_worker, &DBandImgOperate::sigMountFileListLoadReady, this, &ImageEngineApi::sigMountFileListLoadReady);
362 workerThread->start();
363 }
364
365 void ImageEngineApi::setThreadShouldStop()
366 {
367 if (nullptr != m_worker) {
368 m_worker->setThreadShouldStop();
369 }
370 }
371 //根据路径制作缩略图,并保存到指定位置
372 //bool ImageEngineApi::makeThumbnailByPaths(QStringList files)
373 //{
374 // if (!m_imageCacheSaveobj) {
375 // m_imageCacheSaveobj = new ImageCacheSaveObject;
376 // connect(dApp->signalM, &SignalManager::cacheThreadStop, this, &ImageEngineApi::sltstopCacheSave);
377 // }
378 // m_imageCacheSaveobj->add(files);
379 // int needCoreCounts = static_cast<int>(std::thread::hardware_concurrency());
380 // needCoreCounts = needCoreCounts / 2;
381 // if (needCoreCounts < 1)
382 // needCoreCounts = 1;
383 // QList<QThread *> threads;
384 // for (int i = 0; i < needCoreCounts; i++) {
385 // makeThumbnailThread *thread = new makeThumbnailThread;
386 // thread->setObject(m_imageCacheSaveobj);
387 // thread->start();
388 // threads.append(thread);
389 // }
390 // for (auto thread : threads) {
391 // thread->wait();
392 // thread->deleteLater();
393 // }
394 // return true;
395 //}
396
397 void ImageEngineApi::setImgPathAndAlbumNames(const QMultiMap<QString, QString> &imgPahtAlbums)
398 {
399 m_allPathAndAlbumNames.clear();
400 m_allPathAndAlbumNames = imgPahtAlbums;
401 }
402
403 const QMultiMap<QString, QString> &ImageEngineApi::getImgPathAndAlbumNames()
404 {
405 return m_allPathAndAlbumNames;
406 }
407
408 void ImageEngineApi::cleanUpTrash(const DBImgInfoList &list)
409 {
410 RefreshTrashThread *imagethread = new RefreshTrashThread();
411 imagethread->setData(list);
412 QThreadPool::globalInstance()->start(imagethread);
413 }
414
415 bool ImageEngineApi::reloadAfterFilterUnExistImage()
416 {
417 ImageLoadFromDBThread *imagethread = new ImageLoadFromDBThread();
418 #ifdef NOGLOBAL
419 m_qtpool.start(imagethread);
420 #else
421 QThreadPool::globalInstance()->start(imagethread);
422 #endif
423 return true;
424 }
425
426 bool ImageEngineApi::isVideo(QString path)
427 {
428 QMutexLocker locker(&m_dataMutex);
429 bool is = false;
430 if (m_AllImageData.contains(path)) {
431 DBImgInfo info = m_AllImageData[path];
432 if (info.itemType == ItemTypeVideo) {
433 is = true;
434 }
435 }
436 return is;
437 }
438
439 int ImageEngineApi::getAllImageDataCount()
440 {
441 QMutexLocker locker(&m_dataMutex);
442 return m_AllImageData.size();
443 }
444
445 void ImageEngineApi::addImageData(QString path, DBImgInfo data)
446 {
447 QMutexLocker locker(&m_dataMutex);
448 m_AllImageData[path] = data;
449 }
450
451 void ImageEngineApi::clearAllImageData()
452 {
453 QMutexLocker locker(&m_dataMutex);
454 m_AllImageData.clear();
455 }
456
457 bool ImageEngineApi::isItemLoadedFromDB(QString path)
458 {
459 QMutexLocker locker(&m_dataMutex);
460 return m_AllImageData.contains(path);
461 }
462
463 //从外部启动,启用线程加载图片
464 bool ImageEngineApi::loadImagesFromNewAPP(QStringList files, ImageEngineImportObject *obj)
465 {
466 ImageFromNewAppThread *imagethread = new ImageFromNewAppThread;
467 imagethread->setDate(files, obj);
468 obj->addThread(imagethread);
469 #ifdef NOGLOBAL
470 m_qtpool.start(imagethread);
471 #else
472 QThreadPool::globalInstance()->start(imagethread);
473 #endif
474 return true;
475 }
476
477 bool ImageEngineApi::importImageFilesFromMount(QString albumname, QStringList paths, ImageMountImportPathsObject *obj)
478 {
479 emit dApp->signalM->popupWaitDialog(QObject::tr("Importing..."));
480 ImageImportFilesFromMountThread *imagethread = new ImageImportFilesFromMountThread;
481 connect(imagethread, &ImageImportFilesFromMountThread::sigImageFilesImported, this, &ImageEngineApi::sltImageFilesImported);
482 // if (albumname == tr("Gallery")) {
483 // albumname = "";
484 // }
485 imagethread->setData(albumname, paths, obj);
486 obj->addThread(imagethread);
487 #ifdef NOGLOBAL
488 m_qtpool.start(imagethread);
489 #else
490 QThreadPool::globalInstance()->start(imagethread);
491 #endif
492 return true;
493 }
494 bool ImageEngineApi::moveImagesToTrash(QStringList files, bool typetrash, bool bneedprogress)
495 {
496 if (files.size() == 0) {
497 return false;
498 }
499
500 emit dApp->signalM->popupWaitDialog(tr("Deleting..."), bneedprogress); //author : jia.dong
501 if (typetrash) //如果为回收站删除,则删除内存数据
502 removeImage(files);
503 ImageMoveImagesToTrashThread *imagethread = new ImageMoveImagesToTrashThread;
504 imagethread->setData(files, typetrash);
505 #ifdef NOGLOBAL
506 m_qtpool.start(imagethread);
507 #else
508 QThreadPool::globalInstance()->start(imagethread);
509 #endif
510 return true;
511 }
512 bool ImageEngineApi::recoveryImagesFromTrash(QStringList files)
513 {
514 emit dApp->signalM->popupWaitDialog(tr("Restoring..."), false);
515 ImageRecoveryImagesFromTrashThread *imagethread = new ImageRecoveryImagesFromTrashThread;
516 imagethread->setData(files);
517 #ifdef NOGLOBAL
518 m_qtpool.start(imagethread);
519 #else
520 QThreadPool::globalInstance()->start(imagethread);
521 #endif
522 return true;
523 }
524
525 QStringList ImageEngineApi::get_AllImagePath()
526 {
527 if (m_AllImageData.size() > 0)
528 return m_AllImageData.keys();
529 return QStringList();
530 }