1  /*
2   * Copyright (C) 2024 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  #ifndef OHOS_PHOTO_PICTURE_DATA_OPERATIONS_H
17  #define OHOS_PHOTO_PICTURE_DATA_OPERATIONS_H
18  
19  #include <cstdint>
20  #include <functional>
21  #include <memory>
22  #include <mutex>
23  #include <string>
24  #include <list>
25  #include <thread>
26  #include "picture.h"
27  #include "media_log.h"
28  #include "medialibrary_async_worker.h"
29  
30  namespace OHOS {
31  namespace Media {
32  enum PictureType {
33      LOW_QUALITY_PICTURE = 0,
34      HIGH_QUALITY_PICTURE
35  };
36  
37  class PicturePair : public RefBase {
38  public:
39      std::shared_ptr<Media::Picture> picture_;
40      std::string photoId_ = "default";
41      time_t expireTime_;
42      bool isCleanImmediately_ = true;
43      bool isEdited_ = false;
PicturePair(std::shared_ptr<Media::Picture> picture,std::string photoId,time_t expireTime,bool isCleanImmediately,bool isEdited)44      explicit PicturePair(std::shared_ptr<Media::Picture> picture, std::string photoId,
45          time_t expireTime, bool isCleanImmediately, bool isEdited)
46      {
47          picture_ = std::move(picture);
48          photoId_ = std::move(photoId);
49          expireTime_ = expireTime;
50          isCleanImmediately_ = isCleanImmediately;
51          isEdited_ = isEdited;
52      }
53  
PicturePair(const PicturePair & other)54      PicturePair(const PicturePair& other)
55      {
56          picture_ = std::move(other.picture_);
57          photoId_ = std::move(other.photoId_);
58          expireTime_ = other.expireTime_;
59          isCleanImmediately_ = other.isCleanImmediately_;
60          isEdited_ = other.isEdited_;
61      }
62  
63      PicturePair& operator=(const PicturePair& other)
64      {
65          if (this != &other) {
66              picture_ = std::move(other.picture_);
67              photoId_ = std::move(other.photoId_);
68              expireTime_ = other.expireTime_;
69              isCleanImmediately_ = other.isCleanImmediately_;
70              isEdited_ = other.isEdited_;
71          }
72          return *this;
73      }
74  
~PicturePair()75      ~PicturePair()
76      {
77          if (picture_) {
78              picture_ = nullptr;
79          }
80      }
81  };
82  
83  class SavePictureData : public AsyncTaskData {
84  public:
SavePictureData(sptr<PicturePair> picturePair)85      SavePictureData(sptr<PicturePair> picturePair) : picturePair_(picturePair){};
86      ~SavePictureData() override = default;
87  
88      sptr<PicturePair> picturePair_;
89  };
90  class PictureDataOperations : public RefBase {
91  public:
92      explicit PictureDataOperations();
93      ~PictureDataOperations();
94      void CleanDateForPeriodical();
95      void CleanPictureMapData(std::map<std::string, sptr<PicturePair>>& pictureMap, PictureType pictureType);
96      void InsertPictureData(const std::string& imageId, sptr<PicturePair>& picturePair, PictureType pictureType);
97      std::shared_ptr<Media::Picture> GetDataWithImageId(const std::string& imageId,
98          bool &isHighQualityPicture, bool isCleanImmediately = true);
99      std::shared_ptr<Media::Picture> GetDataWithImageIdAndPictureType(const std::string& imageId,
100          PictureType pictureType, bool isCleanImmediately = true);
101      void DeleteDataWithImageId(const std::string& imageId, PictureType pictureType);
102      bool IsExsitDataForPictureType(PictureType pictureType);
103      bool IsExsitDataForPictureType(const std::string& imageId, PictureType pictureType);
104      void SaveLowQualityPicture(const std::string& imageId = "default");
105      void FinishAccessingPicture(const std::string& imageId, PictureType pictureType);
106      void SavePictureWithImageId(const std::string& imageId);
107      static void SavePictureExecutor(AsyncTaskData *data);
108      int32_t AddSavePictureTask(sptr<PicturePair>& picturePair);
109      int32_t GetPendingTaskSize();
110  private:
111      bool SavePicture(const std::string& imageId, std::map<std::string, sptr<PicturePair>>& pictureMap,
112          bool isLowQualityPicture);
113      void CleanHighQualityPictureDataInternal(const std::string& imageId, sptr<PicturePair>& picturePair,
114          std::list<std::string>& pictureImageIdList);
115  
116      const int MAX_PICTURE_CAPBILITY = 3;
117      int max_capibilty = MAX_PICTURE_CAPBILITY;
118      std::mutex pictureMapMutex_;
119      std::map<std::string, sptr<PicturePair>> lowQualityPictureMap_;
120      std::map<std::string, sptr<PicturePair>> highQualityPictureMap_;
121      std::list<std::string> highQualityPictureImageId;
122      std::list<std::string> pendingSavedPicturelist_;
123      static int32_t taskSize;
124  }; // class PictureDataOperation
125  } // namespace Media
126  }  // namespace OHOS
127  #endif // OHOS_PHOTO_PICTURE_DATA_OPERATION_H