# temp

**Repository Path**: tetsuou/temp

## Basic Information

- **Project Name**: temp
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-10-26
- **Last Updated**: 2024-11-14

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

```
diff --git a/interfaces/kits/napi/graphic/drawing/canvas_napi/js_canvas.cpp b/interfaces/kits/napi/graphic/drawing/canvas_napi/js_canvas.cpp
index bf5402c42e..6816d5e516 100644
--- a/interfaces/kits/napi/graphic/drawing/canvas_napi/js_canvas.cpp
+++ b/interfaces/kits/napi/graphic/drawing/canvas_napi/js_canvas.cpp
@@ -518,10 +518,8 @@ napi_value JsCanvas::OnDrawShadow(napi_env env, napi_callback_info info)
         ROSEN_LOGE("JsCanvas::OnDrawShadow canvas is null.");
         return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
     }
-
     napi_value argv[ARGC_SEVEN] = { nullptr };
     CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_SEVEN);
-    
     JsPath* jsPath = nullptr;
     GET_UNWRAP_PARAM(ARGC_ZERO, jsPath);
 
@@ -2009,15 +2007,11 @@ napi_value JsCanvas::OnDrawImageRect(napi_env env, napi_callback_info info)
 
     PixelMapNapi* pixelMapNapi = nullptr;
     GET_UNWRAP_PARAM(ARGC_ZERO, pixelMapNapi); // arg #0: pixelmap/image
-    if (pixelMapNapi->GetPixelNapiInner() == nullptr) {
+    auto pixel = pixelMapNapi->GetPixelNapiInner();
+    if (pixel == nullptr) {
         ROSEN_LOGE("JsCanvas::OnDrawImageRect pixelmap GetPixelNapiInner is nullptr");
         return nullptr;
     }
-    std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixelMapNapi->GetPixelNapiInner());
-    if (image == nullptr) {
-        ROSEN_LOGE("JsCanvas::OnDrawImageRect image is nullptr");
-        return nullptr;
-    }
 
     double ltrb[ARGC_FOUR] = {0};
     if (!ConvertFromJsRect(env, argv[ARGC_ONE], ltrb, ARGC_FOUR)) { // arg #1: dstRect
@@ -2028,6 +2022,17 @@ napi_value JsCanvas::OnDrawImageRect(napi_env env, napi_callback_info info)
 
     if (argc == ARGC_TWO) { // without (optional) arg #2: samplingOptions
         DRAWING_PERFORMANCE_TEST_NAP_RETURN(nullptr);
+        if (m_canvas->GetDrawingType() == Drawing::DrawingType::RECORDING) {
+            ExtendRecordingCanvas* canvas_ = reinterpret_cast<ExtendRecordingCanvas*>(m_canvas);
+            Drawing::Rect srcRect(0, 0, pixel->GetWidth(), pixel->GetHeight());
+            canvas_->DrawPixelMapRect(pixel, srcRect, dstRect, Drawing::SamplingOptions());
+            return nullptr;
+        }
+        std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixel);
+        if (image == nullptr) {
+            ROSEN_LOGE("JsCanvas::OnDrawImageRect image is nullptr");
+            return nullptr;
+        }
         m_canvas->DrawImageRect(*image, dstRect, Drawing::SamplingOptions());
     } else {
         JsSamplingOptions* jsSamplingOptions = nullptr;
@@ -2037,7 +2042,18 @@ napi_value JsCanvas::OnDrawImageRect(napi_env env, napi_callback_info info)
             ROSEN_LOGE("JsCanvas::OnDrawImageRect get samplingOptions is nullptr");
             return nullptr;
         }
+        if (m_canvas->GetDrawingType() == Drawing::DrawingType::RECORDING) {
+            ExtendRecordingCanvas* canvas_ = reinterpret_cast<ExtendRecordingCanvas*>(m_canvas);
+            Drawing::Rect srcRect(0, 0, pixel->GetWidth(), pixel->GetHeight());
+            canvas_->DrawPixelMapRect(pixel, srcRect, dstRect, *samplingOptions.get());
+            return nullptr;
+        }
         DRAWING_PERFORMANCE_TEST_NAP_RETURN(nullptr);
+        std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixel);
+        if (image == nullptr) {
+            ROSEN_LOGE("JsCanvas::OnDrawImageRect image is nullptr");
+            return nullptr;
+        }
         m_canvas->DrawImageRect(*image, dstRect, *samplingOptions.get());
     }
 #endif
@@ -2052,11 +2068,22 @@ napi_value JsCanvas::DrawImageRectWithSrc(napi_env env, napi_callback_info info)
 
 #ifdef ROSEN_OHOS
 static napi_value OnDrawingImageRectWithSrc(napi_env env, napi_value* argv, size_t argc, Canvas& canvas,
-                                            const Image& image, const Rect& srcRect, const Rect& dstRect)
+                                            const std::shared_ptr<Media::PixelMap> pixel,
+                                            const Rect& srcRect, const Rect& dstRect)
 {
     if (argc == ARGC_THREE) { // without optional arg #3 (samplingOptions) and arg #4 (constraint):
         DRAWING_PERFORMANCE_TEST_NAP_RETURN(nullptr);
-        canvas.DrawImageRect(image, srcRect, dstRect, Drawing::SamplingOptions());
+        if (canvas.GetDrawingType() == Drawing::DrawingType::RECORDING) {
+            ExtendRecordingCanvas* canvas_ = reinterpret_cast<ExtendRecordingCanvas*>(&canvas);
+            canvas_->DrawPixelMapRect(pixel, srcRect, dstRect, Drawing::SamplingOptions());
+            return nullptr;
+        }
+        std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixel);
+        if (image == nullptr) {
+            ROSEN_LOGE("JsCanvas::OnDrawImageRectWithSrc image is nullptr");
+            return nullptr;
+        }
+        canvas.DrawImageRect(*image, srcRect, dstRect, Drawing::SamplingOptions());
     } else if (argc == ARGC_FOUR) { // without optional arg #4 (constraint):
         JsSamplingOptions* jsSamplingOptions = nullptr;
         GET_UNWRAP_PARAM(ARGC_THREE, jsSamplingOptions);
@@ -2064,8 +2091,18 @@ static napi_value OnDrawingImageRectWithSrc(napi_env env, napi_value* argv, size
         if (samplingOptions == nullptr) {
             return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Incorrect samplingOptions parameter.");
         }
+        if (canvas.GetDrawingType() == Drawing::DrawingType::RECORDING) {
+            ExtendRecordingCanvas* canvas_ = reinterpret_cast<ExtendRecordingCanvas*>(&canvas);
+            canvas_->DrawPixelMapRect(pixel, srcRect, dstRect, *samplingOptions.get());
+            return nullptr;
+        }
         DRAWING_PERFORMANCE_TEST_NAP_RETURN(nullptr);
-        canvas.DrawImageRect(image, srcRect, dstRect, *samplingOptions.get());
+        std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixel);
+        if (image == nullptr) {
+            ROSEN_LOGE("JsCanvas::OnDrawImageRectWithSrc image is nullptr");
+            return nullptr;
+        }
+        canvas.DrawImageRect(*image, srcRect, dstRect, *samplingOptions.get());
     } else if (argc == ARGC_FIVE) {  // with optional arg #3 (samplingOptions) and arg #4 (constraint):
         JsSamplingOptions* jsSamplingOptions = nullptr;
         GET_UNWRAP_PARAM(ARGC_THREE, jsSamplingOptions);
@@ -2078,8 +2115,19 @@ static napi_value OnDrawingImageRectWithSrc(napi_env env, napi_value* argv, size
             constraint,
             static_cast<int32_t>(SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT),
             static_cast<int32_t>(SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT));
+        if (canvas.GetDrawingType() == Drawing::DrawingType::RECORDING) {
+            ExtendRecordingCanvas* canvas_ = reinterpret_cast<ExtendRecordingCanvas*>(&canvas);
+            canvas_->DrawPixelMapRect(pixel, srcRect, dstRect,
+                *samplingOptions.get(), static_cast<SrcRectConstraint>(constraint));
+            return nullptr;
+        }
         DRAWING_PERFORMANCE_TEST_NAP_RETURN(nullptr);
-        canvas.DrawImageRect(image, srcRect, dstRect,
+        std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixel);
+        if (image == nullptr) {
+            ROSEN_LOGE("JsCanvas::OnDrawImageRectWithSrc image is nullptr");
+            return nullptr;
+        }
+        canvas.DrawImageRect(*image, srcRect, dstRect,
             *samplingOptions.get(), static_cast<SrcRectConstraint>(constraint));
     } else { // argc > 5:
         return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "More than 5 parameters are not supported");
@@ -2102,15 +2150,11 @@ napi_value JsCanvas::OnDrawImageRectWithSrc(napi_env env, napi_callback_info inf
 
     PixelMapNapi* pixelMapNapi = nullptr;
     GET_UNWRAP_PARAM(ARGC_ZERO, pixelMapNapi); // arg #0: pixelmap/image
-    if (pixelMapNapi->GetPixelNapiInner() == nullptr) {
+    auto pixel = pixelMapNapi->GetPixelNapiInner();
+    if (pixel == nullptr) {
         ROSEN_LOGE("JsCanvas::OnDrawImageRectWithSrc pixelmap GetPixelNapiInner is nullptr");
         return nullptr;
     }
-    std::shared_ptr<Drawing::Image> image = ExtractDrawingImage(pixelMapNapi->GetPixelNapiInner());
-    if (image == nullptr) {
-        ROSEN_LOGE("JsCanvas::OnDrawImageRectWithSrc image is nullptr");
-        return nullptr;
-    }
 
     double ltrb[ARGC_FOUR] = {0};
     if (!ConvertFromJsRect(env, argv[ARGC_ONE], ltrb, ARGC_FOUR)) { // arg #1: srcRect
@@ -2124,8 +2168,7 @@ napi_value JsCanvas::OnDrawImageRectWithSrc(napi_env env, napi_callback_info inf
             "Incorrect rect dst parameter type. The type of left, top, right and bottom must be number.");
     }
     Drawing::Rect dstRect = Drawing::Rect(ltrb[ARGC_ZERO], ltrb[ARGC_ONE], ltrb[ARGC_TWO], ltrb[ARGC_THREE]);
-
-    return OnDrawingImageRectWithSrc(env, argv, argc, *m_canvas, *image, srcRect, dstRect);
+    return OnDrawingImageRectWithSrc(env, argv, argc, *m_canvas, pixel, srcRect, dstRect);
 #else
     return nullptr;
 #endif

```