1 /* 2 * Copyright (C) 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 */ 15 16 #ifndef INTERFACES_KITS_JS_MEDIALIBRARY_INCLUDE_THUMBNAIL_MANAGER_H 17 #define INTERFACES_KITS_JS_MEDIALIBRARY_INCLUDE_THUMBNAIL_MANAGER_H 18 19 #include <condition_variable> 20 #include <list> 21 #include <memory> 22 #include <mutex> 23 #include <string> 24 #include <thread> 25 26 #include "image_type.h" 27 #include "napi/native_api.h" 28 #include "nocopyable.h" 29 #include "safe_map.h" 30 #include "safe_queue.h" 31 #include "pixel_map.h" 32 #include "unique_fd.h" 33 #include "userfile_manager_types.h" 34 35 namespace OHOS { 36 namespace Media { 37 class ThumbnailRequest; 38 class ThumbnailManager; 39 using RequestSharedPtr = std::shared_ptr<ThumbnailRequest>; 40 using PixelMapPtr = std::unique_ptr<PixelMap>; 41 42 enum class ThumbnailStatus : int32_t { 43 THUMB_INITIAL = 0, 44 THUMB_FAST, 45 THUMB_QUALITY, 46 THUMB_REMOVE, 47 }; 48 49 struct RequestPhotoParams { 50 std::string uri; 51 std::string path; 52 Size size; 53 RequestPhotoType type; 54 }; 55 56 class ThumbnailCallback { 57 public: ThumbnailCallback(napi_env env,napi_ref callback)58 ThumbnailCallback(napi_env env, napi_ref callback) : env_(env), callBackRef_(callback) 59 { } 60 virtual ~ThumbnailCallback() = default; 61 napi_env env_; 62 napi_ref callBackRef_; 63 }; 64 65 class ThumnailUv { 66 public: ThumnailUv(const RequestSharedPtr & request,ThumbnailManager * manager)67 ThumnailUv(const RequestSharedPtr &request, ThumbnailManager *manager) : request_(request), 68 manager_(manager) {} 69 RequestSharedPtr request_; 70 ThumbnailManager *manager_; 71 }; 72 73 class ThumbnailRequest { 74 public: 75 explicit ThumbnailRequest(const RequestPhotoParams ¶ms, napi_env env, napi_ref callback); 76 virtual ~ThumbnailRequest(); 77 bool UpdateStatus(ThumbnailStatus status); 78 void ReleaseCallbackRef(); 79 ThumbnailStatus GetStatus(); 80 bool NeedContinue(); 81 GetUri()82 std::string GetUri() const 83 { 84 return uri_; 85 } 86 GetPath()87 std::string GetPath() const 88 { 89 return path_; 90 } 91 GetRequestSize()92 Size GetRequestSize() const 93 { 94 return requestSize_; 95 } 96 GetPixelMap()97 PixelMapPtr GetPixelMap() 98 { 99 return std::move(pixelMap); 100 } 101 SetPixelMap(PixelMapPtr ptr)102 void SetPixelMap(PixelMapPtr ptr) 103 { 104 pixelMap = std::move(ptr); 105 } 106 GetFastPixelMap()107 PixelMapPtr GetFastPixelMap() 108 { 109 return std::move(fastPixelMap); 110 } 111 SetFastPixelMap(PixelMapPtr ptr)112 void SetFastPixelMap(PixelMapPtr ptr) 113 { 114 fastPixelMap = std::move(ptr); 115 } 116 SetUUID(const std::string & uuid)117 void SetUUID(const std::string &uuid) 118 { 119 uuid_ = uuid; 120 } 121 GetUUID()122 std::string GetUUID() const 123 { 124 return uuid_; 125 } 126 SetFd(int32_t fd)127 void SetFd(int32_t fd) 128 { 129 fd_ = UniqueFd(fd); 130 } 131 GetFd()132 const UniqueFd &GetFd() const 133 { 134 return fd_; 135 } 136 137 ThumbnailCallback callback_; 138 RequestPhotoType requestPhotoType; 139 int32_t error = 0; 140 private: 141 std::string uri_; 142 std::string path_; 143 Size requestSize_; 144 ThumbnailStatus status_ = ThumbnailStatus::THUMB_INITIAL; 145 std::mutex mutex_; 146 std::string uuid_; 147 UniqueFd fd_; 148 149 PixelMapPtr fastPixelMap; 150 PixelMapPtr pixelMap; 151 }; 152 153 class MMapFdPtr { 154 public: 155 explicit MMapFdPtr(int32_t fd, bool isNeedRelease); 156 ~MMapFdPtr(); 157 void* GetFdPtr(); 158 off_t GetFdSize(); 159 bool IsValid(); 160 private: 161 void* fdPtr_; 162 off_t size_; 163 bool isValid_ = false; 164 bool isNeedRelease_ = false; 165 }; 166 167 constexpr int THREAD_NUM = 5; 168 class ThumbnailManager : NoCopyable { 169 public: 170 virtual ~ThumbnailManager(); 171 static std::shared_ptr<ThumbnailManager> GetInstance(); 172 173 void Init(); 174 std::string AddPhotoRequest(const RequestPhotoParams ¶ms, napi_env env, napi_ref callback); 175 void RemovePhotoRequest(const std::string &requestId); 176 static std::unique_ptr<PixelMap> QueryThumbnail(const std::string &uri, const Size &size, 177 const std::string &path); 178 void DeleteRequestIdFromMap(const std::string &requestId); 179 void AddQualityPhotoRequest(const RequestSharedPtr &request); 180 private: 181 ThumbnailManager() = default; 182 void DealWithFastRequest(const RequestSharedPtr &request); 183 void DealWithQualityRequest(const RequestSharedPtr &request); 184 185 void ImageWorker(int num); 186 void AddFastPhotoRequest(const RequestSharedPtr &request); 187 void NotifyImage(const RequestSharedPtr &request); 188 bool RequestFastImage(const RequestSharedPtr &request); 189 190 SafeMap<std::string, RequestSharedPtr> thumbRequest_; 191 SafeQueue<RequestSharedPtr> fastQueue_; 192 SafeQueue<RequestSharedPtr> qualityQueue_; 193 194 std::mutex queueLock_; 195 std::condition_variable queueCv_; 196 std::vector<std::thread> threads_; 197 198 static std::shared_ptr<ThumbnailManager> instance_; 199 static std::mutex mutex_; 200 static bool init_; 201 std::atomic<bool> isThreadRunning_; 202 }; 203 } // Media 204 } // OHOS 205 206 #endif // INTERFACES_KITS_JS_MEDIALIBRARY_INCLUDE_THUMBNAIL_MANAGER_H 207 208