1 /* 2 * Copyright (c) 2021-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 FOUNDATION_ACE_FRAMEWORKS_CORE_IMAGE_IMAGE_PROVIDER_H 17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_IMAGE_IMAGE_PROVIDER_H 18 19 #include <string> 20 21 #include "include/codec/SkCodec.h" 22 #ifdef USE_ROSEN_DRAWING 23 #include "draw/color.h" 24 #endif 25 26 #include "base/memory/ace_type.h" 27 #include "base/resource/internal_resource.h" 28 #include "core/components/common/layout/constants.h" 29 #include "core/components_ng/render/canvas_image.h" 30 #ifdef USE_ROSEN_DRAWING 31 #include "core/components_ng/render/drawing_forward.h" 32 #endif 33 #include "core/image/image_loader.h" 34 #include "core/image/image_source_info.h" 35 #include "core/pipeline/pipeline_base.h" 36 37 class SkSVGDOM; 38 namespace OHOS::Ace { 39 40 class ImageObject; 41 42 class SvgDom; 43 using ImageObjSuccessCallback = std::function<void(ImageSourceInfo, const RefPtr<ImageObject>)>; 44 using UploadSuccessCallback = std::function<void(ImageSourceInfo, const RefPtr<NG::CanvasImage>&)>; 45 using SvgDomSuccessCallback = std::function<void(ImageSourceInfo, const RefPtr<SvgDom>&)>; 46 using FailedCallback = std::function<void(ImageSourceInfo, const std::string&)>; 47 using CancelableTask = CancelableCallback<void()>; 48 using OnPostBackgroundTask = std::function<void(CancelableTask)>; 49 50 struct LoadCallback { LoadCallbackLoadCallback51 LoadCallback( 52 const ImageObjSuccessCallback& success, const UploadSuccessCallback& upload, const FailedCallback& failed) 53 : successCallback(success), uploadCallback(upload), failedCallback(failed) 54 {} 55 ~LoadCallback() = default; 56 57 ImageObjSuccessCallback successCallback; 58 UploadSuccessCallback uploadCallback; 59 FailedCallback failedCallback; 60 }; 61 62 class ImageProvider { 63 public: 64 static void TryLoadImageInfo(const RefPtr<PipelineBase>& context, const std::string& src, 65 std::function<void(bool, int32_t, int32_t)>&& loadCallback); 66 67 static void GetSVGImageDOMAsyncFromSrc(const std::string& src, std::function<void(const sk_sp<SkSVGDOM>&)> callback, 68 std::function<void()> failedCallback, const WeakPtr<PipelineBase> context, uint64_t svgThemeColor = 0, 69 OnPostBackgroundTask onBackgroundTaskPostCallback = nullptr); 70 71 #ifndef USE_ROSEN_DRAWING 72 static void GetSVGImageDOMAsyncFromData(const sk_sp<SkData>& skData, 73 std::function<void(const sk_sp<SkSVGDOM>&)> callback, std::function<void()> failedCallback, 74 const WeakPtr<PipelineBase> context, uint64_t svgThemeColor = 0, 75 OnPostBackgroundTask onBackgroundTaskPostCallback = nullptr); 76 #else 77 static void GetSVGImageDOMAsyncFromData(const std::shared_ptr<RSData>& data, 78 std::function<void(const sk_sp<SkSVGDOM>&)> callback, std::function<void()> failedCallback, 79 const WeakPtr<PipelineBase> context, uint64_t svgThemeColor = 0, 80 OnPostBackgroundTask onBackgroundTaskPostCallback = nullptr); 81 #endif 82 83 #ifndef USE_ROSEN_DRAWING 84 // upload image data to gpu context for painting asynchronously. 85 static void UploadImageToGPUForRender(const WeakPtr<PipelineBase> context, const sk_sp<SkImage>& image, 86 const sk_sp<SkData>& data, const std::function<void(sk_sp<SkImage>, sk_sp<SkData>)>&& callback, 87 const std::string src); 88 #else 89 // upload image data to gpu context for painting asynchronously. 90 static void UploadImageToGPUForRender(const WeakPtr<PipelineBase> context, 91 const std::shared_ptr<RSImage>& image, 92 const std::shared_ptr<RSData>& data, 93 const std::function<void(std::shared_ptr<RSImage>, 94 std::shared_ptr<RSData>)>&& callback, 95 const std::string src); 96 #endif 97 98 // get out source image data asynchronously. 99 static void FetchImageObject(const ImageSourceInfo& imageInfo, const ImageObjSuccessCallback& successCallback, 100 const UploadSuccessCallback& uploadSuccessCallback, const FailedCallback& failedCallback, 101 const WeakPtr<PipelineBase>& context, bool syncMode, bool useSkiaSvg, bool needAutoResize, 102 const OnPostBackgroundTask& onBackgroundTaskPostCallback = nullptr); 103 104 #ifndef USE_ROSEN_DRAWING 105 static sk_sp<SkImage> ResizeSkImage( 106 const sk_sp<SkImage>& rawImage, const std::string& src, Size imageSize, bool forceResize = false); 107 108 static sk_sp<SkImage> ApplySizeToSkImage( 109 const sk_sp<SkImage>& rawImage, int32_t dstWidth, int32_t dstHeight, const std::string& srcKey = std::string()); 110 111 static bool IsWideGamut(const sk_sp<SkColorSpace>& colorSpace); 112 #else 113 static std::shared_ptr<RSImage> ResizeDrawingImage( 114 const std::shared_ptr<RSImage>& rawImage, const std::string& src, Size imageSize, bool forceResize = false); 115 116 static std::shared_ptr<RSImage> ApplySizeToDrawingImage( 117 const std::shared_ptr<RSImage>& rawRSImage, int32_t dstWidth, int32_t dstHeight, 118 const std::string& srcKey = std::string()); 119 120 static bool IsWideGamut(const std::shared_ptr<RSColorSpace>& rsColorSpace); 121 #endif 122 123 static bool NeedExchangeWidthAndHeight(SkEncodedOrigin origin); 124 125 // This is a synchronization interface for getting out source image. 126 #ifndef USE_ROSEN_DRAWING 127 static sk_sp<SkImage> GetSkImage( 128 const std::string& src, const WeakPtr<PipelineBase> context, Size targetSize = Size()); 129 #else 130 static std::shared_ptr<RSImage> GetDrawingImage( 131 const std::string& src, const WeakPtr<PipelineBase> context, Size targetSize = Size()); 132 #endif 133 134 static RefPtr<ImageObject> GeneratorAceImageObject( 135 const ImageSourceInfo& imageInfo, const RefPtr<PipelineBase> context, bool useSkiaSvg); 136 137 #ifndef USE_ROSEN_DRAWING 138 static sk_sp<SkData> LoadImageRawData(const ImageSourceInfo& imageInfo, const RefPtr<PipelineBase> context); 139 140 static sk_sp<SkData> LoadImageRawDataFromFileCache( 141 const RefPtr<PipelineBase> context, const std::string key, const std::string suffix = ""); 142 #else 143 static std::shared_ptr<RSData> LoadImageRawData( 144 const ImageSourceInfo& imageInfo, const RefPtr<PipelineBase> context); 145 146 static std::shared_ptr<RSData> LoadImageRawDataFromFileCache( 147 const RefPtr<PipelineBase> context, const std::string key, const std::string suffix = ""); 148 #endif 149 150 static RefPtr<ImageObject> QueryImageObjectFromCache( 151 const ImageSourceInfo& imageInfo, const RefPtr<PipelineBase>& pipelineContext); 152 #ifndef USE_ROSEN_DRAWING 153 static SkColorType PixelFormatToSkColorType(const RefPtr<PixelMap>& pixmap); 154 static SkAlphaType AlphaTypeToSkAlphaType(const RefPtr<PixelMap>& pixmap); 155 static SkImageInfo MakeSkImageInfoFromPixelMap(const RefPtr<PixelMap>& pixmap); 156 static sk_sp<SkColorSpace> ColorSpaceToSkColorSpace(const RefPtr<PixelMap>& pixmap); 157 #else 158 static Rosen::Drawing::ColorType PixelFormatToDrawingColorType(const RefPtr<PixelMap>& pixmap); 159 static Rosen::Drawing::AlphaType AlphaTypeToDrawingAlphaType(const RefPtr<PixelMap>& pixmap); 160 static RSBitmapFormat MakeRSBitmapFormatFromPixelMap(const RefPtr<PixelMap>& pixmap); 161 static std::shared_ptr<RSColorSpace> ColorSpaceToDrawingColorSpace(const RefPtr<PixelMap>& pixmap); 162 static RSImageInfo MakeRSImageInfoFromPixelMap(const RefPtr<PixelMap>& pixmap); 163 #endif 164 165 static bool TrySetLoadingImage(const ImageSourceInfo& imageInfo, const ImageObjSuccessCallback& successCallback, 166 const UploadSuccessCallback& uploadCallback, const FailedCallback& failedCallback); 167 168 static void ProccessLoadingResult(const RefPtr<TaskExecutor>& taskExecutor, const ImageSourceInfo& imageInfo, 169 bool canStartUploadImageObj, const RefPtr<ImageObject>& imageObj, const RefPtr<PipelineBase>& context, 170 const std::string& errorMsg = ""); 171 172 static bool TryUploadingImage( 173 const std::string& key, const UploadSuccessCallback& successCallback, const FailedCallback& failedCallback); 174 175 static void ProccessUploadResult(const RefPtr<TaskExecutor>& taskExecutor, const ImageSourceInfo& imageInfo, 176 const Size& imageSize, const RefPtr<NG::CanvasImage>& canvasImage, const std::string& errorMsg = ""); 177 178 private: 179 static std::mutex loadingImageMutex_; 180 static std::unordered_map<std::string, std::vector<LoadCallback>> loadingImage_; 181 182 static std::mutex uploadMutex_; 183 static std::unordered_map<std::string, std::vector<LoadCallback>> uploadingImage_; 184 }; 185 186 } // namespace OHOS::Ace 187 188 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_IMAGE_IMAGE_PROVIDER_H 189