Merge branch 'master' of gitee.com:openharmony/graphic_ui into weekly_20210510

BUILD.gn

@@ -32,6 +32,7 @@ config("graphic_define_config") {
 
   defines = [
     "ENABLE_VECTOR_FONT=1",
+    "ENABLE_BITMAP_FONT=0",
     "ENABLE_SHAPING=0",
     "ENABLE_ICU=1",
     "ENABLE_MULTI_FONT=0",
@@ -68,7 +69,6 @@ shared_library("ui") {
     "frameworks/common/task.cpp",
     "frameworks/common/text.cpp",
     "frameworks/common/typed_text.cpp",
-    "frameworks/common/ui_font_header.cpp",
     "frameworks/components/root_view.cpp",
     "frameworks/components/text_adapter.cpp",
     "frameworks/components/ui_abstract_clock.cpp",
@@ -136,6 +136,8 @@ shared_library("ui") {
     "frameworks/font/ui_font.cpp",
     "frameworks/font/ui_font_adaptor.cpp",
     "frameworks/font/ui_font_allocator.cpp",
+    "frameworks/font/ui_font_bitmap.cpp",
+    "frameworks/font/ui_font_builder.cpp",
     "frameworks/font/ui_font_cache.cpp",
     "frameworks/font/ui_font_vector.cpp",
     "frameworks/font/ui_line_break.cpp",
@@ -151,6 +153,8 @@ shared_library("ui") {
     "frameworks/themes/theme_manager.cpp",
     "frameworks/window/window.cpp",
     "frameworks/window/window_impl.cpp",
+    "frameworks/engines/gfx/gfx_engine_manager.cpp",
+    "frameworks/engines/gfx/hi3516/hi3516_engine.cpp",
   ]
   include_dirs = [ "//foundation/graphic/ui/frameworks" ]
   deps = [

frameworks/common/graphic_startup.cpp

@@ -47,24 +47,26 @@ void GraphicStartUp::InitFontEngine(uintptr_t cacheMemAddr,
                                     const char* dPath,
                                     const char* ttfName)
 {
-#if ENABLE_VECTOR_FONT
-    UIFont* fontEngine = UIFont::GetInstance();
-    if (fontEngine == nullptr) {
+    UIFont* uiFont = UIFont::GetInstance();
+    if (uiFont == nullptr) {
         GRAPHIC_LOGE("Get UIFont error");
         return;
     }
-    fontEngine->SetPsramMemory(cacheMemAddr, cacheMemLen);
-    int8_t ret = fontEngine->SetFontPath(const_cast<char*>(dPath), nullptr);
+    uiFont->SetPsramMemory(cacheMemAddr, cacheMemLen);
+    int8_t ret = uiFont->SetFontPath(const_cast<char*>(dPath), nullptr);
     if (ret == INVALID_RET_VALUE) {
         GRAPHIC_LOGW("SetFontPath failed");
     }
-    if (ttfName != nullptr) {
-        uint8_t ret2 = fontEngine->RegisterFontInfo(ttfName);
-        if (ret2 == INVALID_UCHAR_ID) {
-            GRAPHIC_LOGW("SetTtfName failed");
+    if (uiFont->IsVectorFont()) {
+        if (ttfName != nullptr) {
+            uint8_t ret2 = uiFont->RegisterFontInfo(ttfName);
+            if (ret2 == INVALID_UCHAR_ID) {
+                GRAPHIC_LOGW("SetTtfName failed");
+            }
         }
+    } else {
+        (void)uiFont->SetCurrentLangId(0); // set language
     }
-#endif
 }
 
 void GraphicStartUp::InitLineBreakEngine(uintptr_t cacheMemAddr, uint32_t cacheMemLen, const char* path,

frameworks/common/image.cpp

@@ -224,12 +224,16 @@ bool Image::SetSrc(const ImageInfo* src)
     return true;
 }
 
-void Image::DrawImage(const Rect& coords, const Rect& mask, const Style& style, uint8_t opaScale) const
+void Image::DrawImage(BufferInfo& gfxDstBuffer,
+                      const Rect& coords,
+                      const Rect& mask,
+                      const Style& style,
+                      uint8_t opaScale) const
 {
     if (srcType_ == IMG_SRC_VARIABLE) {
-        DrawImage::DrawCommon(coords, mask, imageInfo_, style, opaScale);
+        DrawImage::DrawCommon(gfxDstBuffer, coords, mask, imageInfo_, style, opaScale);
     } else if (srcType_ == IMG_SRC_FILE) {
-        DrawImage::DrawCommon(coords, mask, path_, style, opaScale);
+        DrawImage::DrawCommon(gfxDstBuffer, coords, mask, path_, style, opaScale);
     } else {
         GRAPHIC_LOGE("Image::DrawImage:: failed with error srctype!\n");
     }

frameworks/common/screen.cpp

@@ -15,9 +15,10 @@
 
 #include "common/screen.h"
 #include "core/render_manager.h"
-#include "dock/screen_device_proxy.h"
 #include "draw/draw_utils.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/mem_api.h"
+#include "securec.h"
 
 namespace OHOS {
 Screen& Screen::GetInstance()
@@ -28,26 +29,32 @@ Screen& Screen::GetInstance()
 
 uint16_t Screen::GetWidth()
 {
-    return ScreenDeviceProxy::GetInstance()->GetScreenWidth();
+    return BaseGfxEngine::GetInstance()->GetScreenWidth();
 }
 
 uint16_t Screen::GetHeight()
 {
-    return ScreenDeviceProxy::GetInstance()->GetScreenHeight();
+    return BaseGfxEngine::GetInstance()->GetScreenHeight();
 }
 
 bool Screen::GetCurrentScreenBitmap(ImageInfo& info)
 {
-    uint16_t screenWidth = ScreenDeviceProxy::GetInstance()->GetScreenWidth();
-    uint16_t screenHeight = ScreenDeviceProxy::GetInstance()->GetScreenHeight();
-    info.header.colorMode = ScreenDeviceProxy::GetInstance()->GetBufferMode();
+    BufferInfo* bufferInfo = BaseGfxEngine::GetInstance()->GetBufferInfo();
+    if (bufferInfo == nullptr) {
+        return false;
+    }
+    uint16_t screenWidth = BaseGfxEngine::GetInstance()->GetScreenWidth();
+    uint16_t screenHeight = BaseGfxEngine::GetInstance()->GetScreenHeight();
+    info.header.colorMode = bufferInfo->mode;
     info.dataSize = screenWidth * screenHeight * DrawUtils::GetByteSizeByColorMode(info.header.colorMode);
     info.data = reinterpret_cast<uint8_t*>(ImageCacheMalloc(info));
     info.header.width = screenWidth;
     info.header.height = screenHeight;
     info.header.reserved = 0;
     info.header.compressMode = 0;
-    if (!ScreenDeviceProxy::GetInstance()->GetScreenBitmapBuffer(const_cast<uint8_t*>(info.data), info.dataSize)) {
+
+    if (memcpy_s(static_cast<void *>(const_cast<uint8_t *>(info.data)), info.dataSize,
+                 bufferInfo->virAddr, info.dataSize) != EOK) {
         ImageCacheFree(info);
         return false;
     }

frameworks/common/text.cpp

@@ -18,6 +18,7 @@
 #include "draw/draw_label.h"
 #include "font/ui_font.h"
 #include "font/ui_font_adaptor.h"
+#include "font/ui_font_builder.h"
 #include "gfx_utils/graphic_log.h"
 #include "securec.h"
 
@@ -82,7 +83,8 @@ void Text::SetFont(const char* name, uint8_t size)
     }
     if (UIFont::GetInstance()->IsVectorFont()) {
         uint8_t fontId = UIFont::GetInstance()->GetFontId(name);
-        if ((fontId != GetTotalFontId()) && ((fontId_ != fontId) || (fontSize_ != size))) {
+        if ((fontId != UIFontBuilder::GetInstance()->GetTotalFontId()) &&
+            ((fontId_ != fontId) || (fontSize_ != size))) {
             fontId_ = fontId;
             fontSize_ = size;
             needRefresh_ = true;
@@ -127,17 +129,18 @@ void Text::SetFont(const char* name, uint8_t size, char*& destName, uint8_t& des
 
 void Text::SetFontId(uint8_t fontId)
 {
-    if ((fontId >= GetTotalFontId()) || (fontId_ == fontId)) {
+    if ((fontId >= UIFontBuilder::GetInstance()->GetTotalFontId()) || (fontId_ == fontId)) {
         GRAPHIC_LOGE("Text::SetFontId invalid fontId(%d)", fontId);
         return;
     }
-    UITextLanguageFontParam* fontParam = GetTextLangFontsTable(fontId);
+    UITextLanguageFontParam* fontParam = UIFontBuilder::GetInstance()->GetTextLangFontsTable(fontId);
     if (fontParam == nullptr) {
         return;
     }
     if (UIFont::GetInstance()->IsVectorFont()) {
         uint8_t fontId = UIFont::GetInstance()->GetFontId(fontParam->ttfName);
-        if ((fontId != GetTotalFontId()) && ((fontId_ != fontId) || (fontSize_ != fontParam->size))) {
+        if ((fontId != UIFontBuilder::GetInstance()->GetTotalFontId()) && ((fontId_ != fontId) ||
+            (fontSize_ != fontParam->size))) {
             fontId_ = fontId;
             fontSize_ = fontParam->size;
             needRefresh_ = true;
@@ -177,8 +180,8 @@ void Text::ReMeasureTextWidthInEllipsisMode(const Rect& textRect, const Style& s
         }
     }
 }
-
-void Text::OnDraw(const Rect& invalidatedArea,
+void Text::OnDraw(BufferInfo& gfxDstBuffer,
+                  const Rect& invalidatedArea,
                   const Rect& viewOrigRect,
                   const Rect& textRect,
                   int16_t offsetX,
@@ -193,11 +196,12 @@ void Text::OnDraw(const Rect& invalidatedArea,
     Rect mask = invalidatedArea;
 
     if (mask.Intersect(mask, textRect)) {
-        Draw(mask, textRect, style, offsetX, ellipsisIndex, opaScale);
+        Draw(gfxDstBuffer, mask, textRect, style, offsetX, ellipsisIndex, opaScale);
     }
 }
 
-void Text::Draw(const Rect& mask,
+void Text::Draw(BufferInfo& gfxDstBuffer,
+                const Rect& mask,
                 const Rect& coords,
                 const Style& style,
                 int16_t offsetX,
@@ -236,13 +240,13 @@ void Text::Draw(const Rect& mask,
                                     0,
                                     static_cast<UITextLanguageDirect>(direct_),
                                     nullptr};
-            DrawLabel::DrawTextOneLine(labelLine);
+            DrawLabel::DrawTextOneLine(gfxDstBuffer, labelLine);
             if ((i == (lineCount - 1)) && (ellipsisIndex != TEXT_ELLIPSIS_END_INV)) {
                 labelLine.offset.x = 0;
                 labelLine.text = TEXT_ELLIPSIS;
                 labelLine.lineLength = TEXT_ELLIPSIS_DOT_NUM;
                 labelLine.length = TEXT_ELLIPSIS_DOT_NUM;
-                DrawLabel::DrawTextOneLine(labelLine);
+                DrawLabel::DrawTextOneLine(gfxDstBuffer, labelLine);
             }
         }
         lineBegin += textLine_[i].lineBytes;

frameworks/components/root_view.cpp

@@ -17,11 +17,12 @@
 
 #include "common/screen.h"
 #include "core/render_manager.h"
-#include "dock/screen_device_proxy.h"
+#include "draw/draw_utils.h"
 #include "gfx_utils/graphic_log.h"
 #if ENABLE_WINDOW
 #include "window/window_impl.h"
 #endif
+#include "securec.h"
 namespace OHOS {
 namespace {
 #if LOCAL_RENDER
@@ -39,6 +40,7 @@ RootView::RootView()
 #if defined __linux__ || defined __LITEOS__ || defined __APPLE__
     pthread_mutex_init(&lock_, nullptr);
 #endif
+    InitDrawContext();
 }
 
 RootView* RootView::GetInstance()
@@ -47,6 +49,13 @@ RootView* RootView::GetInstance()
     return &instance;
 }
 
+RootView::~RootView()
+{
+    DestroyDrawContext();
+#if defined __linux__ || defined __LITEOS__ || defined __APPLE__
+    pthread_mutex_destroy(&lock_);
+#endif
+}
 #if ENABLE_WINDOW
 Window* RootView::GetBoundWindow() const
 {
@@ -465,16 +474,13 @@ void RootView::Render()
     pthread_mutex_lock(&lock_);
 #endif
 
-    Rect mask;
 #if LOCAL_RENDER
     if (!invalidateMap_.empty()) {
-        mask = GetRect();
-        RenderManager::RenderRect(mask, this);
+        RenderManager::RenderRect(GetRect(), this);
         invalidateMap_.clear();
 #else
     if (renderFlag_) {
-        mask = invalidRect_;
-        RenderManager::RenderRect(mask, this);
+        RenderManager::RenderRect(invalidRect_, this);
         invalidRect_ = {0, 0, 0, 0};
         renderFlag_ = false;
 #endif
@@ -485,7 +491,7 @@ void RootView::Render()
             boundWindow_->Update();
         }
 #endif
-        ScreenDeviceProxy::GetInstance()->OnRenderFinish(mask);
+        BaseGfxEngine::GetInstance()->Flush();
     }
 
 #if defined __linux__ || defined __LITEOS__ || defined __APPLE__
@@ -493,6 +499,37 @@ void RootView::Render()
 #endif
 }
 
+void RootView::BlitMapBuffer(Rect& curViewRect, TransformMap& transMap, const Rect& invalidatedArea)
+{
+    Rect invalidRect = curViewRect;
+    transMap.SetTransMapRect(curViewRect);
+    invalidRect.Join(invalidRect, transMap.GetBoxRect());
+
+    if (invalidRect.Intersect(invalidRect, invalidatedArea)) {
+        uint8_t pxSize = DrawUtils::GetPxSizeByColorMode(dc_.mapBufferInfo->mode);
+        ImageInfo imageInfo;
+        imageInfo.header.colorMode = dc_.mapBufferInfo->mode;
+        imageInfo.dataSize = dc_.mapBufferInfo->width * dc_.mapBufferInfo->height * (pxSize >> 3);
+        imageInfo.header.width = dc_.mapBufferInfo->width;
+        imageInfo.header.height = dc_.mapBufferInfo->height;
+        imageInfo.header.reserved = 0;
+        imageInfo.data = reinterpret_cast<uint8_t*>(dc_.mapBufferInfo->virAddr);
+        TransformDataInfo imageTranDataInfo = {imageInfo.header, imageInfo.data, pxSize, LEVEL0,
+                                               BILINEAR};
+        BaseGfxEngine::GetInstance()->DrawTransform(*dc_.bufferInfo, invalidRect, {0, 0}, Color::Black(),
+                                                    OPA_OPAQUE, transMap, imageTranDataInfo);
+    }
+}
+
+void RootView::ClearMapBuffer()
+{
+    uint8_t pxSize = DrawUtils::GetPxSizeByColorMode(dc_.mapBufferInfo->mode);
+    uint32_t dataSize = dc_.mapBufferInfo->width * dc_.mapBufferInfo->height * (pxSize >> 3);
+    if (memset_s(dc_.mapBufferInfo->virAddr, dataSize, 0, dataSize) != EOK) {
+        GRAPHIC_LOGE("animator buffer memset failed.");
+    }
+}
+
 void RootView::DrawTop(UIView* view, const Rect& rect)
 {
     if (view == nullptr) {
@@ -511,6 +548,8 @@ void RootView::DrawTop(UIView* view, const Rect& rect)
     Rect origRect;
     Rect relativeRect;
     bool enableAnimator = false;
+    TransformMap curTransMap;
+
     while (par != nullptr) {
         if (curView != nullptr) {
             if (curView->IsVisible()) {
@@ -522,13 +561,21 @@ void RootView::DrawTop(UIView* view, const Rect& rect)
                         curView->GetTransformMap().SetInvalid(true);
                         curView->SetPosition(relativeRect.GetX() - origRect.GetX(),
                                              relativeRect.GetY() - origRect.GetY());
-                        curViewRect = curView->GetMaskedRect();
-                        ScreenDeviceProxy::GetInstance()->EnableAnimatorBuffer(true);
-                        ScreenDeviceProxy::GetInstance()->SetAnimatorRect(origRect);
-                        ScreenDeviceProxy::GetInstance()->SetAnimatorTransMap(curView->GetTransformMap());
+
+                        ClearMapBuffer();
+                        curTransMap = curView->GetTransformMap();
                         enableAnimator = true;
                     }
-                    curView->OnDraw(curViewRect);
+
+                    if (enableAnimator) {
+                        Rect invalidatedArea;
+                        invalidatedArea.SetWidth(dc_.mapBufferInfo->width);
+                        invalidatedArea.SetHeight(dc_.mapBufferInfo->height);
+                        curView->OnDraw(*dc_.mapBufferInfo, invalidatedArea);
+                        curViewRect = invalidatedArea;
+                    } else {
+                        curView->OnDraw(*dc_.bufferInfo, curViewRect);
+                    }
 
                     if ((curView->IsViewGroup()) && (stackCount < COMPONENT_NESTING_DEPTH)) {
                         if (enableAnimator && (transViewGroup == nullptr)) {
@@ -543,10 +590,15 @@ void RootView::DrawTop(UIView* view, const Rect& rect)
                         mask.Intersect(mask, curViewRect);
                         continue;
                     }
-                    curView->OnPostDraw(curViewRect);
+
+                    if (enableAnimator) {
+                        curView->OnPostDraw(*dc_.mapBufferInfo, curViewRect);
+                    } else {
+                        curView->OnPostDraw(*dc_.bufferInfo, curViewRect);
+                    }
+
                     if (enableAnimator && (transViewGroup == nullptr)) {
-                        ScreenDeviceProxy::GetInstance()->EnableAnimatorBuffer(false);
-                        ScreenDeviceProxy::GetInstance()->DrawAnimatorBuffer(mask);
+                        BlitMapBuffer(origRect, curTransMap, mask);
                         curView->GetTransformMap().SetInvalid(false);
                         enableAnimator = false;
                         curView->SetPosition(relativeRect.GetX(), relativeRect.GetY());
@@ -559,12 +611,14 @@ void RootView::DrawTop(UIView* view, const Rect& rect)
         if (--stackCount >= 0) {
             curViewRect = par->GetMaskedRect();
             mask = g_maskStack[stackCount];
-            if (enableAnimator || curViewRect.Intersect(curViewRect, mask)) {
-                par->OnPostDraw(curViewRect);
+            if (enableAnimator) {
+                par->OnPostDraw(*dc_.mapBufferInfo, curViewRect);
+            } else if (curViewRect.Intersect(curViewRect, mask)) {
+                par->OnPostDraw(*dc_.bufferInfo, curViewRect);
             }
+
             if (enableAnimator && transViewGroup == g_viewStack[stackCount]) {
-                ScreenDeviceProxy::GetInstance()->EnableAnimatorBuffer(false);
-                ScreenDeviceProxy::GetInstance()->DrawAnimatorBuffer(mask);
+                BlitMapBuffer(origRect, curTransMap, mask);
                 transViewGroup->GetTransformMap().SetInvalid(false);
                 enableAnimator = false;
                 transViewGroup->SetPosition(relativeRect.GetX(), relativeRect.GetY());
@@ -638,4 +692,83 @@ bool RootView::FindSubView(const UIView& parentView, const UIView* subView)
     }
     return false;
 }
-} // namespace OHOS
+
\ No newline at end of file
+void RootView::InitMapBufferInfo(BufferInfo* bufferInfo)
+{
+    uint32_t bufferSize = bufferInfo->width * bufferInfo->height *
+        (DrawUtils::GetPxSizeByColorMode(bufferInfo->mode) >> 3);  // 3: Shift right 3 bits
+
+    dc_.mapBufferInfo = new BufferInfo();
+    if (dc_.mapBufferInfo == nullptr) {
+        return;
+    }
+
+    if (memcpy_s(dc_.mapBufferInfo, sizeof(BufferInfo), bufferInfo, sizeof(BufferInfo)) != EOK) {
+        delete dc_.mapBufferInfo;
+        dc_.mapBufferInfo = nullptr;
+        return;
+    }
+    dc_.mapBufferInfo->virAddr = dc_.mapBufferInfo->phyAddr =
+        BaseGfxEngine::GetInstance()->AllocBuffer(bufferSize, BUFFER_MAP_SURFACE);
+}
+
+void RootView::DestroyMapBufferInfo()
+{
+    if (dc_.mapBufferInfo != nullptr) {
+        BaseGfxEngine::GetInstance()->FreeBuffer(static_cast<uint8_t *>(dc_.mapBufferInfo->virAddr));
+        dc_.mapBufferInfo->virAddr = dc_.mapBufferInfo->phyAddr = nullptr;
+        delete dc_.mapBufferInfo;
+        dc_.mapBufferInfo = nullptr;
+    }
+}
+
+void RootView::InitDrawContext()
+{
+    dc_.bufferInfo = BaseGfxEngine::GetInstance()->GetBufferInfo();
+
+    if (dc_.bufferInfo != nullptr) {
+        InitMapBufferInfo(dc_.bufferInfo);
+    }
+}
+
+void RootView::DestroyDrawContext()
+{
+    DestroyMapBufferInfo();
+}
+
+void RootView::UpdateBufferInfo(BufferInfo* fbBufferInfo)
+{
+    if (dc_.bufferInfo == nullptr) {
+        dc_.bufferInfo = fbBufferInfo;
+        InitMapBufferInfo(fbBufferInfo);
+    } else {
+        if (dc_.bufferInfo->width != fbBufferInfo->width ||
+            dc_.bufferInfo->height != fbBufferInfo->height ||
+            dc_.bufferInfo->mode != fbBufferInfo->mode) {
+            DestroyMapBufferInfo();
+            InitMapBufferInfo(fbBufferInfo);
+        }
+        dc_.bufferInfo = fbBufferInfo;
+    }
+}
+
+void RootView::SaveDrawContext()
+{
+    bakDc_.bufferInfo = dc_.bufferInfo;
+    dc_.bufferInfo = nullptr;
+
+    bakDc_.mapBufferInfo = dc_.mapBufferInfo;
+    dc_.mapBufferInfo = nullptr;
+}
+
+void RootView::RestoreDrawContext()
+{
+    DestroyDrawContext();
+
+    dc_.bufferInfo = bakDc_.bufferInfo;
+    bakDc_.bufferInfo = nullptr;
+
+    dc_.mapBufferInfo = bakDc_.mapBufferInfo;
+    bakDc_.mapBufferInfo = nullptr;
+}
+} // namespace OHOS

frameworks/components/ui_analog_clock.cpp

@@ -16,8 +16,7 @@
 #include "components/ui_analog_clock.h"
 #include "components/ui_image_view.h"
 #include "draw/draw_image.h"
-#include "draw/draw_line.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 #include "gfx_utils/style.h"
 #include "imgdecode/cache_manager.h"
@@ -206,18 +205,18 @@ void UIAnalogClock::UpdateClock(bool clockInit)
     }
 }
 
-void UIAnalogClock::OnDraw(const Rect& invalidatedArea)
+void UIAnalogClock::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    DrawRect::Draw(GetRect(), invalidatedArea, *style_, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opaScale_);
 }
 
-void UIAnalogClock::OnPostDraw(const Rect& invalidatedArea)
+void UIAnalogClock::OnPostDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Rect current = GetOrigRect();
-    DrawHand(current, invalidatedArea, hourHand_);
-    DrawHand(current, invalidatedArea, minuteHand_);
+    DrawHand(gfxDstBuffer, current, invalidatedArea, hourHand_);
+    DrawHand(gfxDstBuffer, current, invalidatedArea, minuteHand_);
     if (GetWorkMode() == WorkMode::NORMAL) {
-        DrawHand(current, invalidatedArea, secondHand_);
+        DrawHand(gfxDstBuffer, current, invalidatedArea, secondHand_);
     }
 }
 
@@ -265,27 +264,30 @@ void UIAnalogClock::CalculateRedrawArea(const Rect& current, Hand& hand, bool cl
     }
 }
 
-void UIAnalogClock::DrawHand(const Rect& current, const Rect& invalidatedArea, Hand& hand)
+void UIAnalogClock::DrawHand(BufferInfo& gfxDstBuffer, const Rect& current, const Rect& invalidatedArea, Hand& hand)
 {
     if (hand.drawtype_ == DrawType::DRAW_IMAGE) {
-        DrawHandImage(current, invalidatedArea, hand);
+        DrawHandImage(gfxDstBuffer, current, invalidatedArea, hand);
     } else {
-        DrawHandLine(invalidatedArea, hand);
+        DrawHandLine(gfxDstBuffer, invalidatedArea, hand);
     }
 }
 
-void UIAnalogClock::DrawHandImage(const Rect& current, const Rect& invalidatedArea, Hand& hand)
+void UIAnalogClock::DrawHandImage(BufferInfo& gfxDstBuffer,
+                                  const Rect& current,
+                                  const Rect& invalidatedArea,
+                                  Hand& hand)
 {
     uint8_t pxSize = DrawUtils::GetPxSizeByColorMode(hand.imageInfo_.header.colorMode);
     TransformDataInfo imageTranDataInfo = {
         hand.imageInfo_.header, hand.imageInfo_.data, pxSize,
         BlurLevel::LEVEL0, TransformAlgorithm::BILINEAR
     };
-    DrawUtils::GetInstance()->DrawTransform(invalidatedArea, { 0, 0 },
+    BaseGfxEngine::GetInstance()->DrawTransform(gfxDstBuffer, invalidatedArea, { 0, 0 },
         Color::Black(), opaScale_, hand.trans_, imageTranDataInfo);
 }
 
-void UIAnalogClock::DrawHandLine(const Rect& invalidatedArea, Hand& hand)
+void UIAnalogClock::DrawHandLine(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, Hand& hand)
 {
     float sinma = Sin(hand.nextAngle_);
     float cosma = Sin(hand.nextAngle_ + THREE_QUARTER_IN_DEGREE);
@@ -316,7 +318,8 @@ void UIAnalogClock::DrawHandLine(const Rect& invalidatedArea, Hand& hand)
     end.x = xlength + curCenter.x;
     end.y = ylength + curCenter.y;
 
-    DrawLine::Draw(start, end, invalidatedArea, hand.width_, hand.color_, hand.opacity_);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+                                           hand.width_, hand.color_, hand.opacity_);
 }
 
 void UIAnalogClock::SetWorkMode(WorkMode newMode)

frameworks/components/ui_arc_label.cpp

@@ -16,7 +16,7 @@
 #include "components/ui_arc_label.h"
 #include "common/typed_text.h"
 #include "draw/draw_label.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "font/ui_font.h"
 #include "themes/theme_manager.h"
 
@@ -115,7 +115,7 @@ void UIArcLabel::SetFont(const char* name, uint8_t size)
     }
 }
 
-void UIArcLabel::OnDraw(const Rect& invalidatedArea)
+void UIArcLabel::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     InitArcLabelText();
     const char* text = arcLabelText_->GetText();
@@ -124,19 +124,19 @@ void UIArcLabel::OnDraw(const Rect& invalidatedArea)
     }
     Rect trunc = invalidatedArea;
     OpacityType opa = GetMixOpaScale();
-    UIView::OnDraw(invalidatedArea);
-    DrawArcText(trunc, opa);
+    UIView::OnDraw(gfxDstBuffer, invalidatedArea);
+    DrawArcText(gfxDstBuffer, trunc, opa);
 }
 
-void UIArcLabel::DrawArcText(const Rect& mask, OpacityType opaScale)
+void UIArcLabel::DrawArcText(BufferInfo& gfxDstBuffer, const Rect& mask, OpacityType opaScale)
 {
     Point center;
     center.x = arcTextInfo_.arcCenter.x + GetRect().GetX();
     center.y = arcTextInfo_.arcCenter.y + GetRect().GetY();
     InitArcLabelText();
     UIFont::GetInstance()->SetCurrentFontId(arcLabelText_->GetFontId(), arcLabelText_->GetFontSize());
-    DrawLabel::DrawArcText(mask, arcLabelText_->GetText(), center, arcLabelText_->GetFontId(), arcTextInfo_,
-                           orientation_, *style_, opaScale);
+    DrawLabel::DrawArcText(gfxDstBuffer, mask, arcLabelText_->GetText(), center, arcLabelText_->GetFontId(),
+        arcTextInfo_, orientation_, *style_, opaScale);
 }
 
 void UIArcLabel::RefreshArcLabel()

frameworks/components/ui_axis.cpp

@@ -15,7 +15,7 @@
 
 #include "components/ui_axis.h"
 #include "common/screen.h"
-#include "draw/draw_line.h"
+#include "engines/gfx/gfx_engine_manager.h"
 
 namespace OHOS {
 UIAxis::UIAxis()
@@ -91,13 +91,14 @@ void UIXAxis::TranslateToPixel(int16_t& value)
     value = start_.x + static_cast<int16_t>((value - minRange_) * minXStep);
 }
 
-void UIAxis::OnDraw(const Rect& invalidatedArea)
+void UIAxis::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    DrawLine::Draw(start_, end_, invalidatedArea, style_->lineWidth_, style_->lineColor_, style_->lineOpa_);
-    DrawAxisMark(invalidatedArea);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start_, end_, invalidatedArea, style_->lineWidth_,
+                                           style_->lineColor_, style_->lineOpa_);
+    DrawAxisMark(gfxDstBuffer, invalidatedArea);
 }
 
-void UIXAxis::DrawAxisMark(const Rect& invalidatedArea)
+void UIXAxis::DrawAxisMark(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Point start;
     Point end;
@@ -108,7 +109,8 @@ void UIXAxis::DrawAxisMark(const Rect& invalidatedArea)
         end.y = enableReverse_ ? (start.y + AXIS_DEFAULT_MARK_LENGTH) : (start.y - AXIS_DEFAULT_MARK_LENGTH);
         end.x = start.x;
 
-        DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, style_->lineColor_, style_->lineOpa_);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+                                               style_->lineWidth_, style_->lineColor_, style_->lineOpa_);
         index++;
     }
 }
@@ -178,7 +180,7 @@ bool UIYAxis::UpdateAxis()
     return true;
 }
 
-void UIYAxis::DrawAxisMark(const Rect& invalidatedArea)
+void UIYAxis::DrawAxisMark(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     uint16_t index = 1;
     while (index <= markDataCount_) {
@@ -190,7 +192,8 @@ void UIYAxis::DrawAxisMark(const Rect& invalidatedArea)
         end.x = start.x + AXIS_DEFAULT_MARK_LENGTH;
         end.y = start.y;
 
-        DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, style_->lineColor_, style_->lineOpa_);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+                                               style_->lineWidth_, style_->lineColor_, style_->lineOpa_);
         index++;
     }
 }

frameworks/components/ui_box_progress.cpp

@@ -14,8 +14,8 @@
  */
 
 #include "components/ui_box_progress.h"
-#include "draw/draw_arc.h"
-#include "draw/draw_rect.h"
+#include "draw/draw_utils.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 
 namespace OHOS {
@@ -25,7 +25,8 @@ UIBoxProgress::UIBoxProgress()
     SetDirection(Direction::DIR_LEFT_TO_RIGHT);
 }
 
-void UIBoxProgress::DrawValidRect(const Image* image,
+void UIBoxProgress::DrawValidRect(BufferInfo& gfxDstBuffer,
+                                  const Image* image,
                                   const Rect& rect,
                                   const Rect& invalidatedArea,
                                   const Style& style,
@@ -57,18 +58,19 @@ void UIBoxProgress::DrawValidRect(const Image* image,
         cordsTmp.SetHeight(header.height);
         cordsTmp.SetWidth(header.width);
         if (area.Intersect(area, invalidatedArea)) {
-            image->DrawImage(cordsTmp, area, style, opaScale_);
+            image->DrawImage(gfxDstBuffer, cordsTmp, area, style, opaScale_);
         }
     } else {
-        DrawRect::Draw(rect, invalidatedArea, style, opaScale_);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rect, invalidatedArea, style, opaScale_);
     }
 
     if (style.lineCap_ == CapType::CAP_ROUND) {
-        DrawRoundCap(image, {cordsTmp.GetX(), cordsTmp.GetY()}, rect, invalidatedArea, radius, style);
+        DrawRoundCap(gfxDstBuffer, image, {cordsTmp.GetX(), cordsTmp.GetY()}, rect, invalidatedArea, radius, style);
     }
 }
 
-void UIBoxProgress::DrawRoundCap(const Image* image,
+void UIBoxProgress::DrawRoundCap(BufferInfo& gfxDstBuffer,
+                                 const Image* image,
                                  const Point& imgPos,
                                  const Rect& rect,
                                  const Rect& invalidatedArea,
@@ -129,22 +131,26 @@ void UIBoxProgress::DrawRoundCap(const Image* image,
         arcInfo.center = leftTop;
         arcInfo.startAngle = THREE_QUARTER_IN_DEGREE;
         arcInfo.endAngle = 0;
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                              CapType::CAP_NONE);
 
         arcInfo.center = leftBottom;
         arcInfo.startAngle = SEMICIRCLE_IN_DEGREE;
         arcInfo.endAngle = THREE_QUARTER_IN_DEGREE;
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                              CapType::CAP_NONE);
 
         arcInfo.center = rightTop;
         arcInfo.startAngle = 0;
         arcInfo.endAngle = QUARTER_IN_DEGREE;
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                              CapType::CAP_NONE);
 
         arcInfo.center = rightBottom;
         arcInfo.startAngle = QUARTER_IN_DEGREE;
         arcInfo.endAngle = SEMICIRCLE_IN_DEGREE;
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                              CapType::CAP_NONE);
     } else {
         switch (direction_) {
             case Direction::DIR_LEFT_TO_RIGHT:
@@ -152,12 +158,14 @@ void UIBoxProgress::DrawRoundCap(const Image* image,
                 arcInfo.center = leftTop;
                 arcInfo.startAngle = SEMICIRCLE_IN_DEGREE;
                 arcInfo.endAngle = 0;
-                DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+                BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                                      CapType::CAP_NONE);
 
                 arcInfo.center = leftBottom;
                 arcInfo.startAngle = 0;
                 arcInfo.endAngle = SEMICIRCLE_IN_DEGREE;
-                DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+                BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                                      CapType::CAP_NONE);
                 break;
             }
 
@@ -166,12 +174,14 @@ void UIBoxProgress::DrawRoundCap(const Image* image,
                 arcInfo.center = leftTop;
                 arcInfo.startAngle = THREE_QUARTER_IN_DEGREE;
                 arcInfo.endAngle = QUARTER_IN_DEGREE;
-                DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+                BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                                      CapType::CAP_NONE);
 
                 arcInfo.center = leftBottom;
                 arcInfo.startAngle = QUARTER_IN_DEGREE;
                 arcInfo.endAngle = THREE_QUARTER_IN_DEGREE;
-                DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, capStyle, opaScale_, CapType::CAP_NONE);
+                BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, capStyle, opaScale_,
+                                                      CapType::CAP_NONE);
                 break;
             }
             default:
@@ -217,7 +227,7 @@ void UIBoxProgress::GetBackgroundParam(Point& startPoint,
     }
 }
 
-void UIBoxProgress::DrawBackground(const Rect& invalidatedArea)
+void UIBoxProgress::DrawBackground(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Point startPoint;
     int16_t progressWidth;
@@ -227,10 +237,10 @@ void UIBoxProgress::DrawBackground(const Rect& invalidatedArea)
 
     Rect coords(startPoint.x, startPoint.y, startPoint.x + progressWidth - 1, startPoint.y + progressHeight - 1);
 
-    DrawValidRect(backgroundImage_, coords, invalidatedArea, *backgroundStyle_, radius);
+    DrawValidRect(gfxDstBuffer, backgroundImage_, coords, invalidatedArea, *backgroundStyle_, radius);
 }
 
-void UIBoxProgress::DrawForeground(const Rect& invalidatedArea, Rect& coords)
+void UIBoxProgress::DrawForeground(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, Rect& coords)
 {
     Point startPoint;
     int16_t progressWidth;
@@ -268,19 +278,19 @@ void UIBoxProgress::DrawForeground(const Rect& invalidatedArea, Rect& coords)
         }
     }
 
-    DrawValidRect(foregroundImage_, coords, invalidatedArea, *foregroundStyle_, radius);
+    DrawValidRect(gfxDstBuffer, foregroundImage_, coords, invalidatedArea, *foregroundStyle_, radius);
 }
 
-void UIBoxProgress::OnDraw(const Rect& invalidatedArea)
+void UIBoxProgress::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    UIView::OnDraw(invalidatedArea);
+    UIView::OnDraw(gfxDstBuffer, invalidatedArea);
     if (enableBackground_) {
-        DrawBackground(invalidatedArea);
+        DrawBackground(gfxDstBuffer, invalidatedArea);
     }
 
     if ((lastValue_ - rangeMin_ != 0) || (foregroundStyle_->lineCap_ == CapType::CAP_ROUND)) {
         Rect coords;
-        DrawForeground(invalidatedArea, coords);
+        DrawForeground(gfxDstBuffer, invalidatedArea, coords);
     }
 }
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file

frameworks/components/ui_button.cpp

@@ -14,11 +14,10 @@
  */
 
 #include "components/ui_button.h"
-
 #include "animator/interpolation.h"
 #include "common/image.h"
 #include "draw/draw_image.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 #include "gfx_utils/style.h"
 #include "imgdecode/cache_manager.h"
@@ -66,7 +65,7 @@ UIButton::~UIButton()
     }
 }
 
-void UIButton::DrawImg(const Rect& invalidatedArea, OpacityType opaScale)
+void UIButton::DrawImg(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, OpacityType opaScale)
 {
     const Image* image = GetCurImageSrc();
     if (image == nullptr) {
@@ -84,15 +83,15 @@ void UIButton::DrawImg(const Rect& invalidatedArea, OpacityType opaScale)
 
     Rect trunc(invalidatedArea);
     if (trunc.Intersect(trunc, viewRect)) {
-        image->DrawImage(coords, trunc, *buttonStyles_[state_], opaScale);
+        image->DrawImage(gfxDstBuffer, coords, trunc, *buttonStyles_[state_], opaScale);
     }
 }
 
-void UIButton::OnDraw(const Rect& invalidatedArea)
+void UIButton::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     OpacityType opa = GetMixOpaScale();
-    DrawRect::Draw(GetOrigRect(), invalidatedArea, *buttonStyles_[state_], opa);
-    DrawImg(invalidatedArea, opa);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetOrigRect(), invalidatedArea, *buttonStyles_[state_], opa);
+    DrawImg(gfxDstBuffer, invalidatedArea, opa);
 }
 
 void UIButton::SetupThemeStyles()
@@ -295,10 +294,10 @@ bool UIButton::OnPreDraw(Rect& invalidatedArea) const
 }
 
 #if DEFAULT_ANIMATION
-void UIButton::OnPostDraw(const Rect& invalidatedArea)
+void UIButton::OnPostDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     if (state_ == ButtonState::PRESSED) {
-        animator_.DrawMask(invalidatedArea);
+        animator_.DrawMask(gfxDstBuffer, invalidatedArea);
     }
 }
 
@@ -333,14 +332,14 @@ void UIButton::ButtonAnimator::Start()
     isReverseAnimation_ = isReverse;
 }
 
-void UIButton::ButtonAnimator::DrawMask(const Rect& invalidatedArea)
+void UIButton::ButtonAnimator::DrawMask(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Style maskStyle;
     maskStyle.SetStyle(STYLE_BACKGROUND_COLOR, Color::White().full);
     maskStyle.SetStyle(STYLE_BACKGROUND_OPA, MASK_OPA);
     maskStyle.SetStyle(STYLE_BORDER_RADIUS, button_.GetStyle(STYLE_BORDER_RADIUS));
     OpacityType opa = button_.GetMixOpaScale();
-    DrawRect::Draw(button_.GetRect(), invalidatedArea, maskStyle, opa);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, button_.GetRect(), invalidatedArea, maskStyle, opa);
 }
 
 static inline void ScaleButton(UIButton& button, float scale)

frameworks/components/ui_canvas.cpp

@@ -16,10 +16,8 @@
 #include "components/ui_canvas.h"
 #include "common/image.h"
 #include "draw/draw_arc.h"
-#include "draw/draw_curve.h"
 #include "draw/draw_image.h"
-#include "draw/draw_line.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 
 namespace OHOS {
@@ -450,10 +448,10 @@ void UICanvas::DrawPath(const Paint& paint)
     Invalidate();
 }
 
-void UICanvas::OnDraw(const Rect& invalidatedArea)
+void UICanvas::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Rect rect = GetOrigRect();
-    DrawRect::Draw(rect, invalidatedArea, *style_, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rect, invalidatedArea, *style_, opaScale_);
 
     void* param = nullptr;
     ListNode<DrawCmd>* curDraw = drawCmdList_.Begin();
@@ -462,7 +460,7 @@ void UICanvas::OnDraw(const Rect& invalidatedArea)
     if (trunc.Intersect(trunc, coords)) {
         for (; curDraw != drawCmdList_.End(); curDraw = curDraw->next_) {
             param = curDraw->data_.param;
-            curDraw->data_.DrawGraphics(param, curDraw->data_.paint, rect, trunc, *style_);
+            curDraw->data_.DrawGraphics(gfxDstBuffer, param, curDraw->data_.paint, rect, trunc, *style_);
         }
     }
 }
@@ -473,7 +471,8 @@ void UICanvas::GetAbsolutePosition(const Point& prePoint, const Rect& rect, cons
     point.y = prePoint.y + rect.GetTop() + style.paddingTop_ + style.borderWidth_;
 }
 
-void UICanvas::DoDrawLine(void* param,
+void UICanvas::DoDrawLine(BufferInfo& gfxDstBuffer,
+                          void* param,
                           const Paint& paint,
                           const Rect& rect,
                           const Rect& invalidatedArea,
@@ -488,10 +487,12 @@ void UICanvas::DoDrawLine(void* param,
     GetAbsolutePosition(lineParam->start, rect, style, start);
     GetAbsolutePosition(lineParam->end, rect, style, end);
 
-    DrawLine::Draw(start, end, invalidatedArea, paint.GetStrokeWidth(), paint.GetStrokeColor(), paint.GetOpacity());
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea, paint.GetStrokeWidth(),
+                                           paint.GetStrokeColor(), paint.GetOpacity());
 }
 
-void UICanvas::DoDrawCurve(void* param,
+void UICanvas::DoDrawCurve(BufferInfo& gfxDstBuffer,
+                           void* param,
                            const Paint& paint,
                            const Rect& rect,
                            const Rect& invalidatedArea,
@@ -510,11 +511,12 @@ void UICanvas::DoDrawCurve(void* param,
     GetAbsolutePosition(curveParam->control1, rect, style, control1);
     GetAbsolutePosition(curveParam->control2, rect, style, control2);
 
-    DrawCurve::DrawCubicBezier(start, control1, control2, end, invalidatedArea, paint.GetStrokeWidth(),
-                               paint.GetStrokeColor(), paint.GetOpacity());
+    BaseGfxEngine::GetInstance()->DrawCubicBezier(gfxDstBuffer, start, control1, control2, end, invalidatedArea,
+                                                  paint.GetStrokeWidth(), paint.GetStrokeColor(), paint.GetOpacity());
 }
 
-void UICanvas::DoDrawRect(void* param,
+void UICanvas::DoDrawRect(BufferInfo& gfxDstBuffer,
+                          void* param,
                           const Paint& paint,
                           const Rect& rect,
                           const Rect& invalidatedArea,
@@ -540,32 +542,33 @@ void UICanvas::DoDrawRect(void* param,
         coords.SetPosition(x, y);
         coords.SetHeight(rectParam->height + lineWidth);
         coords.SetWidth(rectParam->width + lineWidth);
-        DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
         return;
     }
 
     coords.SetPosition(x, y);
     coords.SetHeight(lineWidth);
     coords.SetWidth(rectParam->width);
-    DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
 
     coords.SetPosition(x + rectParam->width, y);
     coords.SetHeight(rectParam->height);
     coords.SetWidth(lineWidth);
-    DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
 
     coords.SetPosition(x, y + lineWidth);
     coords.SetHeight(rectParam->height);
     coords.SetWidth(lineWidth);
-    DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
 
     coords.SetPosition(x + lineWidth, y + rectParam->height);
     coords.SetHeight(lineWidth);
     coords.SetWidth(rectParam->width);
-    DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
 }
 
-void UICanvas::DoFillRect(void* param,
+void UICanvas::DoFillRect(BufferInfo& gfxDstBuffer,
+                          void* param,
                           const Paint& paint,
                           const Rect& rect,
                           const Rect& invalidatedArea,
@@ -592,10 +595,11 @@ void UICanvas::DoFillRect(void* param,
     drawStyle.bgColor_ = paint.GetFillColor();
     drawStyle.bgOpa_ = paint.GetOpacity();
     drawStyle.borderRadius_ = 0;
-    DrawRect::Draw(coords, invalidatedArea, drawStyle, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, coords, invalidatedArea, drawStyle, OPA_OPAQUE);
 }
 
-void UICanvas::DoDrawCircle(void* param,
+void UICanvas::DoDrawCircle(BufferInfo& gfxDstBuffer,
+                            void* param,
                             const Paint& paint,
                             const Rect& rect,
                             const Rect& invalidatedArea,
@@ -620,18 +624,21 @@ void UICanvas::DoDrawCircle(void* param,
         arcInfo.radius = circleParam->radius - halfLineWidth;
         drawStyle.lineWidth_ = arcInfo.radius;
         drawStyle.lineColor_ = paint.GetFillColor();
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE,
+                                              CapType::CAP_NONE);
     }
 
     if (enableStroke) {
         arcInfo.radius = circleParam->radius + halfLineWidth - 1;
         drawStyle.lineWidth_ = static_cast<int16_t>(paint.GetStrokeWidth());
         drawStyle.lineColor_ = paint.GetStrokeColor();
-        DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE,
+                                              CapType::CAP_NONE);
     }
 }
 
-void UICanvas::DoDrawArc(void* param,
+void UICanvas::DoDrawArc(BufferInfo& gfxDstBuffer,
+                         void* param,
                          const Paint& paint,
                          const Rect& rect,
                          const Rect& invalidatedArea,
@@ -653,10 +660,12 @@ void UICanvas::DoDrawArc(void* param,
     arcInfo.radius = arcParam->radius + ((paint.GetStrokeWidth() + 1) >> 1);
 
     GetAbsolutePosition(arcParam->center, rect, style, arcInfo.center);
-    DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE,
+                                          CapType::CAP_NONE);
 }
 
-void UICanvas::DoDrawImage(void* param,
+void UICanvas::DoDrawImage(BufferInfo& gfxDstBuffer,
+                           void* param,
                            const Paint& paint,
                            const Rect& rect,
                            const Rect& invalidatedArea,
@@ -678,10 +687,12 @@ void UICanvas::DoDrawImage(void* param,
     cordsTmp.SetPosition(start.x, start.y);
     cordsTmp.SetHeight(imageParam->height);
     cordsTmp.SetWidth(imageParam->width);
-    DrawImage::DrawCommon(cordsTmp, invalidatedArea, imageParam->image->GetPath(), style, paint.GetOpacity());
+    DrawImage::DrawCommon(gfxDstBuffer,cordsTmp, invalidatedArea,
+                          imageParam->image->GetPath(), style, paint.GetOpacity());
 }
 
-void UICanvas::DoDrawLabel(void* param,
+void UICanvas::DoDrawLabel(BufferInfo& gfxDstBuffer,
+                           void* param,
                            const Paint& paint,
                            const Rect& rect,
                            const Rect& invalidatedArea,
@@ -695,11 +706,14 @@ void UICanvas::DoDrawLabel(void* param,
     Point start;
     GetAbsolutePosition({startPos.x, startPos.y}, rect, style, start);
     label->SetPosition(start.x, start.y);
-    label->OnDraw(invalidatedArea);
+    label->OnDraw(gfxDstBuffer, invalidatedArea);
     label->SetPosition(startPos.x, startPos.y);
 }
 
-void UICanvas::DoDrawLineJoin(const Point& center, const Rect& invalidatedArea, const Paint& paint)
+void UICanvas::DoDrawLineJoin(BufferInfo& gfxDstBuffer,
+                              const Point& center,
+                              const Rect& invalidatedArea,
+                              const Paint& paint)
 {
     ArcInfo arcinfo = {{0}};
     arcinfo.center = center;
@@ -712,10 +726,12 @@ void UICanvas::DoDrawLineJoin(const Point& center, const Rect& invalidatedArea,
     style.lineColor_ = paint.GetStrokeColor();
     style.lineWidth_ = static_cast<int16_t>(paint.GetStrokeWidth());
     style.lineOpa_ = OPA_OPAQUE;
-    DrawArc::GetInstance()->Draw(arcinfo, invalidatedArea, style, OPA_OPAQUE, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea, style, OPA_OPAQUE,
+                                          CapType::CAP_NONE);
 }
 
-void UICanvas::DoDrawPath(void* param,
+void UICanvas::DoDrawPath(BufferInfo& gfxDstBuffer,
+                          void* param,
                           const Paint& paint,
                           const Rect& rect,
                           const Rect& invalidatedArea,
@@ -750,9 +766,10 @@ void UICanvas::DoDrawPath(void* param,
 
                 GetAbsolutePosition(start, rect, style, start);
                 GetAbsolutePosition(end, rect, style, end);
-                DrawLine::Draw(start, end, invalidatedArea, paint.GetStrokeWidth(), paint.GetStrokeColor(), OPA_OPAQUE);
+                BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+                                                       paint.GetStrokeWidth(), paint.GetStrokeColor(), OPA_OPAQUE);
                 if ((pathEnd.x == start.x) && (pathEnd.y == start.y)) {
-                    DoDrawLineJoin(start, invalidatedArea, paint);
+                    DoDrawLineJoin(gfxDstBuffer, start, invalidatedArea, paint);
                 }
                 pathEnd = end;
                 break;
@@ -769,9 +786,10 @@ void UICanvas::DoDrawPath(void* param,
                 arcInfo.radius = arcIter->data_.radius + ((paint.GetStrokeWidth() + 1) >> 1);
 
                 GetAbsolutePosition(arcIter->data_.center, rect, style, arcInfo.center);
-                DrawArc::GetInstance()->Draw(arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+                BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfo, invalidatedArea, drawStyle, OPA_OPAQUE,
+                                                      CapType::CAP_NONE);
                 if (pointIter != path->points_.Begin()) {
-                    DoDrawLineJoin(pathEnd, invalidatedArea, paint);
+                    DoDrawLineJoin(gfxDstBuffer, pathEnd, invalidatedArea, paint);
                 }
 
                 GetAbsolutePosition(pointIter->data_, rect, style, pathEnd);
@@ -785,16 +803,16 @@ void UICanvas::DoDrawPath(void* param,
                 GetAbsolutePosition(start, rect, style, start);
                 GetAbsolutePosition(end, rect, style, end);
                 if ((start.x != end.x) || (start.y != end.y)) {
-                    DrawLine::Draw(start, end, invalidatedArea, paint.GetStrokeWidth(), paint.GetStrokeColor(),
-                        OPA_OPAQUE);
+                    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+                                                           paint.GetStrokeWidth(), paint.GetStrokeColor(), OPA_OPAQUE);
                     if ((pathEnd.x == start.x) && (pathEnd.y == start.y)) {
-                        DoDrawLineJoin(start, invalidatedArea, paint);
+                        DoDrawLineJoin(gfxDstBuffer, start, invalidatedArea, paint);
                     }
                     pathEnd = end;
                 }
 
                 if ((pathEnd.x == end.x) && (pathEnd.y == end.y)) {
-                    DoDrawLineJoin(end, invalidatedArea, paint);
+                    DoDrawLineJoin(gfxDstBuffer, end, invalidatedArea, paint);
                 }
                 pointIter = pointIter->next_;
                 break;

frameworks/components/ui_chart.cpp

@@ -14,8 +14,7 @@
  */
 
 #include "components/ui_chart.h"
-#include "draw/draw_arc.h"
-#include "draw/draw_line.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "securec.h"
 
 namespace OHOS {
@@ -56,10 +55,10 @@ void UIChart::SetWidth(int16_t width)
     yAxis_.UpdateAxis();
 }
 
-void UIChart::OnDraw(const Rect& invalidatedArea)
+void UIChart::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    UIViewGroup::OnDraw(invalidatedArea);
-    DrawDataSerials(invalidatedArea);
+    UIViewGroup::OnDraw(gfxDstBuffer, invalidatedArea);
+    DrawDataSerials(gfxDstBuffer, invalidatedArea);
 }
 
 bool UIChart::AddDataSerial(UIChartDataSerial* dataSerial)
@@ -328,7 +327,8 @@ void UIChartDataSerial::ClearData()
     latestIndex_ = 0;
 }
 
-void UIChartDataSerial::DoDrawPoint(const Point& center, const PointStyle& style, const Rect& mask)
+void UIChartDataSerial::DoDrawPoint(BufferInfo& gfxDstBuffer, const Point& center,
+                                    const PointStyle& style, const Rect& mask)
 {
     Style drawStyle = StyleDefault::GetDefaultStyle();
     drawStyle.lineOpa_ = OPA_OPAQUE;
@@ -343,37 +343,37 @@ void UIChartDataSerial::DoDrawPoint(const Point& center, const PointStyle& style
 
     if (style.fillColor.full == style.strokeColor.full) {
         drawStyle.lineWidth_ = style.radius + style.strokeWidth;
-        DrawArc::GetInstance()->Draw(arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
         return;
     }
     drawStyle.lineWidth_ = style.radius;
     arcinfo.radius = style.radius;
-    DrawArc::GetInstance()->Draw(arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
 
     drawStyle.lineWidth_ = style.strokeWidth;
     drawStyle.lineColor_ = style.strokeColor;
     arcinfo.radius = style.radius + style.strokeWidth;
-    DrawArc::GetInstance()->Draw(arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, mask, drawStyle, OPA_OPAQUE, CapType::CAP_NONE);
 }
 
-void UIChartDataSerial::DrawPoint(const Rect& mask)
+void UIChartDataSerial::DrawPoint(BufferInfo& gfxDstBuffer, const Rect& mask)
 {
     Point center;
     if (enableTopPoint_) {
         if (GetPoint(peakPointIndex_, center)) {
-            DoDrawPoint(center, topPointStyle_, mask);
+            DoDrawPoint(gfxDstBuffer, center, topPointStyle_, mask);
         }
     }
 
     if (enableBottomPoint_) {
         if (GetPoint(valleyPointIndex_, center)) {
-            DoDrawPoint(center, bottomPointStyle_, mask);
+            DoDrawPoint(gfxDstBuffer, center, bottomPointStyle_, mask);
         }
     }
 
     if (enableHeadPoint_) {
         if (GetPoint(latestIndex_, center)) {
-            DoDrawPoint(center, headPointStyle_, mask);
+            DoDrawPoint(gfxDstBuffer, center, headPointStyle_, mask);
             lastPointIndex_ = latestIndex_;
         }
     }
@@ -427,7 +427,7 @@ void UIChartPillar::RefreshChart()
     }
 }
 
-void UIChartPillar::DrawDataSerials(const Rect& invalidatedArea)
+void UIChartPillar::DrawDataSerials(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     xAxis_.UpdateAxisPoints();
     yAxis_.UpdateAxisPoints();
@@ -453,7 +453,8 @@ void UIChartPillar::DrawDataSerials(const Rect& invalidatedArea)
             }
             current.x += x;
             xStart.x = current.x;
-            DrawLine::Draw(current, xStart, invalidatedArea, barWidth, data->GetFillColor(), style_->lineOpa_);
+            BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, current, xStart, invalidatedArea, barWidth,
+                                                   data->GetFillColor(), style_->lineOpa_);
         }
         dataSerialIndex++;
     }
@@ -499,7 +500,7 @@ void UIChartPolyline::ReMeasure()
     }
 }
 
-void UIChartPolyline::DrawDataSerials(const Rect& invalidatedArea)
+void UIChartPolyline::DrawDataSerials(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     xAxis_.UpdateAxisPoints();
     yAxis_.UpdateAxisPoints();
@@ -511,21 +512,22 @@ void UIChartPolyline::DrawDataSerials(const Rect& invalidatedArea)
             continue;
         }
         if (data->IsGradient()) {
-            GradientColor(invalidatedArea, data);
+            GradientColor(gfxDstBuffer, invalidatedArea, data);
         }
         if (data->GetHideCount() != 0) {
             uint16_t hideIndex = data->GetHideIndex();
-            DrawPolyLine(0, hideIndex, invalidatedArea, data);
-            DrawPolyLine(hideIndex + data->GetHideCount(), dataCount - 1, invalidatedArea, data);
+            DrawPolyLine(gfxDstBuffer, 0, hideIndex, invalidatedArea, data);
+            DrawPolyLine(gfxDstBuffer, hideIndex + data->GetHideCount(), dataCount - 1, invalidatedArea, data);
         } else {
-            DrawPolyLine(0, dataCount - 1, invalidatedArea, data);
+            DrawPolyLine(gfxDstBuffer, 0, dataCount - 1, invalidatedArea, data);
         }
 
-        data->DrawPoint(invalidatedArea);
+        data->DrawPoint(gfxDstBuffer, invalidatedArea);
     }
 }
 
-void UIChartPolyline::DrawSmoothPolyLine(uint16_t startIndex,
+void UIChartPolyline::DrawSmoothPolyLine(BufferInfo& gfxDstBuffer,
+                                         uint16_t startIndex,
                                          uint16_t endIndex,
                                          const Rect& invalidatedArea,
                                          UIChartDataSerial* data)
@@ -567,7 +569,8 @@ void UIChartPolyline::DrawSmoothPolyLine(uint16_t startIndex,
             continue;
         }
 
-        DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, color, OPA_OPAQUE);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+            style_->lineWidth_, color, OPA_OPAQUE);
         ArcInfo arcinfo = {{0}};
         arcinfo.center = end;
         arcinfo.imgPos = Point{0, 0};
@@ -575,15 +578,18 @@ void UIChartPolyline::DrawSmoothPolyLine(uint16_t startIndex,
         arcinfo.startAngle = 0;
         arcinfo.endAngle = CIRCLE_IN_DEGREE;
 
-        DrawArc::GetInstance()->Draw(arcinfo, invalidatedArea, style, OPA_OPAQUE, CapType::CAP_NONE);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea,
+            style, OPA_OPAQUE, CapType::CAP_NONE);
 
         start = end;
         end = current;
     }
-    DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, color, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+        style_->lineWidth_, color, OPA_OPAQUE);
 }
 
-void UIChartPolyline::DrawPolyLine(uint16_t startIndex,
+void UIChartPolyline::DrawPolyLine(BufferInfo& gfxDstBuffer,
+                                   uint16_t startIndex,
                                    uint16_t endIndex,
                                    const Rect& invalidatedArea,
                                    UIChartDataSerial* data)
@@ -593,7 +599,7 @@ void UIChartPolyline::DrawPolyLine(uint16_t startIndex,
     }
 
     if (data->IsSmooth()) {
-        DrawSmoothPolyLine(startIndex, endIndex, invalidatedArea, data);
+        DrawSmoothPolyLine(gfxDstBuffer, startIndex, endIndex, invalidatedArea, data);
         return;
     }
     Point start;
@@ -619,15 +625,18 @@ void UIChartPolyline::DrawPolyLine(uint16_t startIndex,
             continue;
         }
 
-        DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, color, OPA_OPAQUE);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+            style_->lineWidth_, color, OPA_OPAQUE);
         if (style_->lineWidth_ >= LINE_JOIN_WIDTH) {
             arcinfo.center = end;
-            DrawArc::GetInstance()->Draw(arcinfo, invalidatedArea, style, OPA_OPAQUE, CapType::CAP_NONE);
+            BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea,
+                style, OPA_OPAQUE, CapType::CAP_NONE);
         }
     }
     data->GetPoint(endIndex - 1, start);
     data->GetPoint(endIndex, end);
-    DrawLine::Draw(start, end, invalidatedArea, style_->lineWidth_, color, OPA_OPAQUE);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea,
+        style_->lineWidth_, color, OPA_OPAQUE);
 }
 
 bool UIChartPolyline::GetLineCrossPoint(const Point& p1,
@@ -696,7 +705,8 @@ void UIChartPolyline::FindCrossPoints(const ChartLine& line, const ChartLine& po
     }
 }
 
-void UIChartPolyline::DrawGradientColor(const Rect& invalidatedArea,
+void UIChartPolyline::DrawGradientColor(BufferInfo& gfxDstBuffer,
+                                        const Rect& invalidatedArea,
                                         UIChartDataSerial* data,
                                         const ChartLine& linePoints,
                                         const ChartLine& limitPoints,
@@ -742,7 +752,8 @@ void UIChartPolyline::DrawGradientColor(const Rect& invalidatedArea,
         if (cross.firstFind && cross.secondFind) {
             cross.first.y = enableReverse_ ? (cross.first.y + startY) : (startY - cross.first.y);
             cross.second.y = enableReverse_ ? (cross.second.y + startY) : (startY - cross.second.y);
-            DrawLine::Draw(cross.first, cross.second, invalidatedArea, 1, data->GetFillColor(), mixData_[mixScale]);
+            BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, cross.first, cross.second,
+                invalidatedArea, 1, data->GetFillColor(), mixData_[mixScale]);
             cross.firstFind = false;
             cross.secondFind = false;
         }
@@ -752,7 +763,8 @@ void UIChartPolyline::DrawGradientColor(const Rect& invalidatedArea,
         cross.second.x = limitPoints.end.x;
         cross.second.y = y;
         cross.first.y = y;
-        DrawLine::Draw(cross.first, cross.second, invalidatedArea, 1, data->GetFillColor(), mixData_[mixScale]);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, cross.first, cross.second,
+            invalidatedArea, 1, data->GetFillColor(), mixData_[mixScale]);
     }
 }
 
@@ -775,7 +787,7 @@ void UIChartPolyline::CalcVerticalInfo(int16_t top,
     }
 }
 
-void UIChartPolyline::GradientColor(const Rect& invalidatedArea, UIChartDataSerial* data)
+void UIChartPolyline::GradientColor(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, UIChartDataSerial* data)
 {
     if (data == nullptr) {
         return;
@@ -811,7 +823,7 @@ void UIChartPolyline::GradientColor(const Rect& invalidatedArea, UIChartDataSeri
         linePoints.end.y = linePoints.start.y;
         if (y <= valleyY) {
             int16_t baseY = enableReverse_ ? endY : startY;
-            DrawGradientColor(invalidatedArea, data, linePoints, limitPoints, baseY);
+            DrawGradientColor(gfxDstBuffer, invalidatedArea, data, linePoints, limitPoints, baseY);
         } else {
             int16_t mixScale = enableReverse_ ? (linePoints.start.y + endY - currentRect.GetTop()) :
                                                 (currentRect.GetBottom() - (startY - linePoints.start.y));
@@ -821,9 +833,10 @@ void UIChartPolyline::GradientColor(const Rect& invalidatedArea, UIChartDataSeri
             }
             Point start = {limitPoints.start.x, y};
             Point end = {limitPoints.end.x, y};
-            DrawLine::Draw(start, end, invalidatedArea, 1, data->GetFillColor(), mixData_[mixScale]);
+            BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, end, invalidatedArea, 1,
+                                                   data->GetFillColor(), mixData_[mixScale]);
         }
         y--;
     }
 }
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file

frameworks/components/ui_checkbox.cpp

@@ -15,10 +15,8 @@
 
 #include "components/ui_checkbox.h"
 #include "default_resource/check_box_res.h"
-#include "draw/draw_arc.h"
 #include "draw/draw_image.h"
-#include "draw/draw_line.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "imgdecode/cache_manager.h"
 
 namespace OHOS {
@@ -120,7 +118,11 @@ void UICheckBox::CalculateSize()
     borderWidth_ =  DEFAULT_BORDER_WIDTH * minValue / DEFAULT_HOT_WIDTH;
 }
 
-void UICheckBox::SelectedStateSoftwareDrawing(Rect rect, Rect trunc, int16_t borderRadius, int16_t rectLineWidth)
+void UICheckBox::SelectedStateSoftwareDrawing(BufferInfo& gfxDstBuffer,
+                                              Rect rect,
+                                              Rect trunc,
+                                              int16_t borderRadius,
+                                              int16_t rectLineWidth)
 {
     if (backgroundOpacity_ == 0) {
         return;
@@ -129,7 +131,7 @@ void UICheckBox::SelectedStateSoftwareDrawing(Rect rect, Rect trunc, int16_t bor
     styleSelect.borderRadius_ = borderRadius;
     styleSelect.bgColor_ = Color::GetColorFromRGB(DEFAULT_BG_RED, DEFAULT_BG_GREEN, DEFAULT_BG_BLUE);
     styleSelect.bgOpa_ = backgroundOpacity_;
-    DrawRect::Draw(rect, trunc, styleSelect, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rect, trunc, styleSelect, opaScale_);
     int16_t dx = borderWidth_ * DEFAULT_COEFFICIENT_START_DX;
     int16_t dy = borderWidth_ * DEFAULT_COEFFICIENT_START_DY;
     Point start = { static_cast<int16_t>(rect.GetX() + dx), static_cast<int16_t>(rect.GetY() + dy) };
@@ -153,14 +155,16 @@ void UICheckBox::SelectedStateSoftwareDrawing(Rect rect, Rect trunc, int16_t bor
     styleSelect.lineColor_ = Color::White();
     styleSelect.lineOpa_ = backgroundOpacity_;
     uint8_t opa = DrawUtils::GetMixOpacity(opaScale_, backgroundOpacity_);
-    DrawArc::GetInstance()->Draw(arcInfoLeft, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
-    DrawLine::Draw(start, mid, trunc, rectLineWidth * 2, Color::White(), opa); // 2 : double
-    DrawArc::GetInstance()->Draw(arcInfoMid, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
-    DrawLine::Draw(mid, end, trunc, rectLineWidth * 2, Color::White(), opa); // 2 : double
-    DrawArc::GetInstance()->Draw(arcInfoRight, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoLeft, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, start, mid, trunc, rectLineWidth * 2, Color::White(),
+                                           opa); // 2 : double
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoMid, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
+    BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, mid, end, trunc, rectLineWidth * 2, Color::White(),
+                                           opa); // 2 : double
+    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoRight, trunc, styleSelect, opaScale_, CapType::CAP_NONE);
 }
 
-void UICheckBox::UnSelectedStateSoftwareDrawing(Rect rect, Rect trunc, int16_t borderRadius, int16_t rectLineWidth)
+void UICheckBox::UnSelectedStateSoftwareDrawing(BufferInfo& gfxDstBuffer, Rect rect, Rect trunc, int16_t borderRadius, int16_t rectLineWidth)
 {
     Rect contentRect  = GetContentRect();
     Style styleUnSelect  = StyleDefault::GetBackgroundTransparentStyle();
@@ -168,7 +172,7 @@ void UICheckBox::UnSelectedStateSoftwareDrawing(Rect rect, Rect trunc, int16_t b
     styleUnSelect.borderRadius_ = borderRadius;
     styleUnSelect.borderColor_ = Color::White();
     styleUnSelect.borderOpa_ = DEFAULT_UNSELECT_BG_OPA;
-    DrawRect::Draw(rect, trunc, styleUnSelect, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rect, trunc, styleUnSelect, opaScale_);
 }
 
 #if DEFAULT_ANIMATION
@@ -196,7 +200,7 @@ void UICheckBox::OnStop(UIView& view)
 }
 #endif
 
-void UICheckBox::OnDraw(const Rect& invalidatedArea)
+void UICheckBox::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     Rect trunc = invalidatedArea;
     if ((image_[SELECTED].GetSrcType() != IMG_SRC_UNKNOWN) && (image_[UNSELECTED].GetSrcType() != IMG_SRC_UNKNOWN)) {
@@ -207,13 +211,13 @@ void UICheckBox::OnDraw(const Rect& invalidatedArea)
         Rect coords = GetContentRect();
         coords.SetWidth(imgWidth);
         coords.SetHeight(imgHeight);
-        DrawRect::Draw(GetRect(), invalidatedArea, *style_, opaScale_);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opaScale_);
         int16_t offsetLeft = (GetWidth() - imgWidth) / 2; // 2 : half
         int16_t offsetTop = (GetHeight() - imgHeight) / 2; // 2 : half
         coords.SetX(coords.GetX() + offsetLeft);
         coords.SetY(coords.GetY() + offsetTop);
         if (trunc.Intersect(trunc, coords)) {
-            image_[state_].DrawImage(coords, trunc, *style_, opaScale_);
+            image_[state_].DrawImage(gfxDstBuffer, coords, trunc, *style_, opaScale_);
         }
     } else {
         Rect contentRect = GetContentRect();
@@ -224,18 +228,18 @@ void UICheckBox::OnDraw(const Rect& invalidatedArea)
         CalculateSize();
         int16_t rectLineWidth = borderWidth_ / DEFAULT_BORDER_WIDTH;
         int16_t borderRadius  = rectLineWidth * DEFAULT_RATIO_BORDER_RADIUS_LINE_WIDTH;
-        DrawRect::Draw(GetRect(), invalidatedArea, *style_, opaScale_);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opaScale_);
         int16_t x = contentRect.GetX() + (width_ - borderWidth_) / 2; // 2: half
         int16_t y = contentRect.GetY() + (height_ - borderWidth_) / 2; // 2: half
         Rect rect(x, y, x + borderWidth_,  y + borderWidth_);
 #if DEFAULT_ANIMATION
-        UnSelectedStateSoftwareDrawing(rect, trunc, borderRadius, rectLineWidth);
-        SelectedStateSoftwareDrawing(rect, trunc, borderRadius, rectLineWidth);
+        UnSelectedStateSoftwareDrawing(gfxDstBuffer, rect, trunc, borderRadius, rectLineWidth);
+        SelectedStateSoftwareDrawing(gfxDstBuffer, rect, trunc, borderRadius, rectLineWidth);
 #else
         if (state_ == SELECTED) {
-            SelectedStateSoftwareDrawing(rect, trunc, borderRadius, rectLineWidth);
+            SelectedStateSoftwareDrawing(gfxDstBuffer, rect, trunc, borderRadius, rectLineWidth);
         } else {
-            UnSelectedStateSoftwareDrawing(rect, trunc, borderRadius, rectLineWidth);
+            UnSelectedStateSoftwareDrawing(gfxDstBuffer, rect, trunc, borderRadius, rectLineWidth);
         }
 #endif
     }

frameworks/components/ui_circle_progress.cpp

@@ -16,7 +16,7 @@
 #include "components/ui_circle_progress.h"
 #include "draw/draw_arc.h"
 #include "draw/draw_line.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 
 namespace OHOS {
 UICircleProgress::UICircleProgress()
@@ -82,7 +82,7 @@ void UICircleProgress::GetRedrawAngle(int16_t& start, int16_t& end) const
     DrawArc::GetInstance()->GetDrawRange(start, end);
 }
 
-void UICircleProgress::DrawCommonCircle(const Rect& invalidatedArea)
+void UICircleProgress::DrawCommonCircle(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     ArcInfo arcinfo = {{0}};
     arcinfo.radius = radius_;
@@ -103,8 +103,8 @@ void UICircleProgress::DrawCommonCircle(const Rect& invalidatedArea)
         arcinfo.startAngle = start;
         arcinfo.endAngle = end;
         arcinfo.imgSrc = backgroundImage_;
-        DrawArc::GetInstance()->Draw(arcinfo, invalidatedArea, *backgroundStyle_, opaScale_,
-                                     backgroundStyle_->lineCap_);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea, *backgroundStyle_, opaScale_,
+                                              backgroundStyle_->lineCap_);
     }
 
     if ((startAngle != endAngle) || (foregroundStyle_->lineCap_ == CapType::CAP_ROUND)) {
@@ -113,22 +113,22 @@ void UICircleProgress::DrawCommonCircle(const Rect& invalidatedArea)
         arcinfo.startAngle = startAngle;
         arcinfo.endAngle = endAngle;
         arcinfo.imgSrc = foregroundImage_;
-        DrawArc::GetInstance()->Draw(arcinfo, invalidatedArea, *foregroundStyle_, opaScale_,
-                                     foregroundStyle_->lineCap_);
+        BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea, *foregroundStyle_, opaScale_,
+                                              foregroundStyle_->lineCap_);
     }
 }
 
-void UICircleProgress::OnDraw(const Rect& invalidatedArea)
+void UICircleProgress::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     if (GetRangeSize() == 0) {
         return;
     }
 
-    DrawRect::Draw(GetOrigRect(), invalidatedArea, *style_, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetOrigRect(), invalidatedArea, *style_, opaScale_);
 
     Rect trunc(invalidatedArea);
     if (trunc.Intersect(trunc, GetOrigRect())) {
-        DrawCommonCircle(trunc);
+        DrawCommonCircle(gfxDstBuffer, trunc);
     }
 }
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file

frameworks/components/ui_image_view.cpp

@@ -14,12 +14,11 @@
  */
 
 #include "components/ui_image_view.h"
-
 #include "common/image.h"
 #include "common/typed_text.h"
 #include "draw/draw_image.h"
 #include "draw/draw_label.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/file.h"
 #include "gfx_utils/image_info.h"
 #include "gfx_utils/mem_api.h"
@@ -261,10 +260,10 @@ bool UIImageView::OnPreDraw(Rect& invalidatedArea) const
     return false;
 }
 
-void UIImageView::OnDraw(const Rect& invalidatedArea)
+void UIImageView::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     OpacityType opa = GetMixOpaScale();
-    DrawRect::Draw(GetRect(), invalidatedArea, *style_, opa);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opa);
     if ((imageHeight_ == 0) || (imageWidth_ == 0)) {
         return;
     }
@@ -283,7 +282,7 @@ void UIImageView::OnDraw(const Rect& invalidatedArea)
                     cordsTmp.SetLeft(viewRect.GetX());
                     cordsTmp.SetRight(viewRect.GetX() + imageWidth_ - 1);
                     while (cordsTmp.GetLeft() <= viewRect.GetRight()) {
-                        image_.DrawImage(cordsTmp, trunc, *style_, opa);
+                        image_.DrawImage(gfxDstBuffer, cordsTmp, trunc, *style_, opa);
                         cordsTmp.SetLeft(cordsTmp.GetLeft() + imageWidth_);
                         cordsTmp.SetRight(cordsTmp.GetRight() + imageWidth_);
                     }
@@ -310,8 +309,8 @@ void UIImageView::OnDraw(const Rect& invalidatedArea)
                 Rect origRect = GetOrigRect();
                 transMap_->SetTransMapRect(origRect);
                 OpacityType opaScale = DrawUtils::GetMixOpacity(opa, style_->imageOpa_);
-                DrawUtils::GetInstance()->DrawTransform(invalidatedArea, {0, 0}, Color::Black(), opaScale, *transMap_,
-                                                        imageTranDataInfo);
+                BaseGfxEngine::GetInstance()->DrawTransform(gfxDstBuffer, invalidatedArea, {0, 0}, Color::Black(),
+                                                            opaScale, *transMap_, imageTranDataInfo);
             }
         }
     }

frameworks/components/ui_label.cpp

@@ -369,13 +369,14 @@ void UILabel::SetRollSpeed(uint16_t speed)
     }
 }
 
-void UILabel::OnDraw(const Rect& invalidatedArea)
+void UILabel::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     InitLabelText();
-    UIView::OnDraw(invalidatedArea);
+    UIView::OnDraw(gfxDstBuffer, invalidatedArea);
     Style style = GetStyleConst();
     style.textColor_ = GetTextColor();
     OpacityType opa = GetMixOpaScale();
-    labelText_->OnDraw(invalidatedArea, GetOrigRect(), GetContentRect(), offsetX_, style, ellipsisIndex_, opa);
+    labelText_->OnDraw(gfxDstBuffer, invalidatedArea, GetOrigRect(),
+                       GetContentRect(), offsetX_, style, ellipsisIndex_, opa);
 }
 } // namespace OHOS
\ No newline at end of file

frameworks/components/ui_label_button.cpp

@@ -24,9 +24,9 @@ UILabelButton::UILabelButton() : labelButtonText_(nullptr), offset_({ 0, 0 })
     labelStyle_ = StyleDefault::GetDefaultStyle();
 }
 
-void UILabelButton::OnDraw(const Rect& invalidatedArea)
+void UILabelButton::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    UIButton::OnDraw(invalidatedArea);
+    UIButton::OnDraw(gfxDstBuffer, invalidatedArea);
 
     Rect textRect = GetContentRect();
     textRect.SetLeft(textRect.GetLeft() + offset_.x);
@@ -35,7 +35,8 @@ void UILabelButton::OnDraw(const Rect& invalidatedArea)
     labelButtonText_->ReMeasureTextSize(textRect, labelStyle_);
     OpacityType opa = GetMixOpaScale();
     uint16_t ellipsisIndex = labelButtonText_->GetEllipsisIndex(textRect, labelStyle_);
-    labelButtonText_->OnDraw(invalidatedArea, GetOrigRect(), textRect, 0, labelStyle_, ellipsisIndex, opa);
+    labelButtonText_->OnDraw(gfxDstBuffer, invalidatedArea, GetOrigRect(), textRect, 0,
+                             labelStyle_, ellipsisIndex, opa);
 }
 
 UILabelButton::~UILabelButton()

frameworks/components/ui_radio_button.cpp

@@ -17,9 +17,8 @@
 #include "common/image.h"
 #include "components/root_view.h"
 #include "components/ui_view_group.h"
-#include "draw/draw_arc.h"
 #include "draw/draw_image.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 #include "imgdecode/cache_manager.h"
 #include "securec.h"
@@ -71,13 +70,13 @@ void UIRadioButton::CalculateSize()
     }
 }
 
-void UIRadioButton::OnDraw(const Rect& invalidatedArea)
+void UIRadioButton::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     if ((image_[SELECTED].GetSrcType() != IMG_SRC_UNKNOWN) && (image_[UNSELECTED].GetSrcType() != IMG_SRC_UNKNOWN)) {
-        UICheckBox::OnDraw(invalidatedArea);
+        UICheckBox::OnDraw(gfxDstBuffer, invalidatedArea);
     } else {
         CalculateSize();
-        DrawRect::Draw(GetRect(), invalidatedArea, *style_, opaScale_);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opaScale_);
         Rect contentRect = GetContentRect();
         int16_t dx = width_ >> 1;
         int16_t dy = height_ >> 1;
@@ -93,12 +92,14 @@ void UIRadioButton::OnDraw(const Rect& invalidatedArea)
                 styleSelect.lineWidth_ = arcInfoBig.radius;
                 styleSelect.lineColor_ = Color::GetColorFromRGB(0x1F, 0x71, 0xFF);
                 if (isIntersect) {
-                    DrawArc::GetInstance()->Draw(arcInfoBig, trunc, styleSelect, OPA_OPAQUE, CapType::CAP_NONE);
+                    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoBig, trunc, styleSelect,
+                                                          OPA_OPAQUE, CapType::CAP_NONE);
                 }
                 styleSelect.lineWidth_ = arcInfoSmall.radius;
                 styleSelect.lineColor_ = Color::White();
                 if (isIntersect) {
-                    DrawArc::GetInstance()->Draw(arcInfoSmall, trunc, styleSelect, OPA_OPAQUE, CapType::CAP_NONE);
+                    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoSmall, trunc, styleSelect,
+                                                          OPA_OPAQUE, CapType::CAP_NONE);
                 }
                 break;
             }
@@ -108,7 +109,8 @@ void UIRadioButton::OnDraw(const Rect& invalidatedArea)
                 styleUnSelect.lineWidth_ = lineWidth_;
                 if (isIntersect) {
                     // 0xa8 : opacity of drawing unselected button arc edge.
-                    DrawArc::GetInstance()->Draw(arcInfoBig, trunc, styleUnSelect, 0xa8, CapType::CAP_NONE);
+                    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoBig, trunc, styleUnSelect,
+                                                          0xa8, CapType::CAP_NONE);
                 }
                 break;
             }

frameworks/components/ui_repeat_button.cpp

@@ -25,9 +25,9 @@ UIRepeatButton::UIRepeatButton() : ticksInterval_(200), event_({ 0, 0 }),
 
 UIRepeatButton::~UIRepeatButton() {}
 
-void UIRepeatButton::OnDraw(const Rect& invalidatedArea)
+void UIRepeatButton::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    UIButton::OnDraw(invalidatedArea);
+    UIButton::OnDraw(gfxDstBuffer, invalidatedArea);
 }
 
 bool UIRepeatButton::OnReleaseEvent(const ReleaseEvent& event)

frameworks/components/ui_scroll_view.cpp

@@ -42,7 +42,7 @@ UIScrollView::UIScrollView()
     ySlider_.SetStyle(StyleDefault::GetBrightStyle());
 }
 
-void UIScrollView::OnPostDraw(const Rect& invalidatedArea)
+void UIScrollView::OnPostDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     if (!xSlider_.IsVisible() && !ySlider_.IsVisible()) {
         return;
@@ -50,11 +50,11 @@ void UIScrollView::OnPostDraw(const Rect& invalidatedArea)
     Rect scrollRect = GetRect();
     if (xSlider_.IsVisible()) {
         xSlider_.SetPosition(scrollRect.GetX() + xSliderPos_.x, scrollRect.GetY() + xSliderPos_.y);
-        xSlider_.OnDraw(invalidatedArea);
+        xSlider_.OnDraw(gfxDstBuffer, invalidatedArea);
     }
     if (ySlider_.IsVisible()) {
         ySlider_.SetPosition(scrollRect.GetX() + ySliderPos_.x, scrollRect.GetY() + ySliderPos_.y);
-        ySlider_.OnDraw(invalidatedArea);
+        ySlider_.OnDraw(gfxDstBuffer, invalidatedArea);
     }
 }
 

frameworks/components/ui_slider.cpp

@@ -18,7 +18,7 @@
 #include "dock/focus_manager.h"
 #include "dock/vibrator_manager.h"
 #include "draw/draw_image.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 #include "imgdecode/cache_manager.h"
 #include "themes/theme_manager.h"
@@ -125,7 +125,7 @@ void UISlider::SetImage(const char* backgroundImage, const char* foregroundImage
 }
 
 #if ENABLE_SLIDER_KNOB
-void UISlider::DrawKnob(const Rect& invalidatedArea, const Rect& foregroundRect)
+void UISlider::DrawKnob(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, const Rect& foregroundRect)
 {
     int16_t halfKnobWidth = GetKnobWidth() >> 1;
     int16_t offset;
@@ -159,7 +159,7 @@ void UISlider::DrawKnob(const Rect& invalidatedArea, const Rect& foregroundRect)
             GRAPHIC_LOGW("UISlider::DrawKnob Direction error!\n");
         }
     }
-    DrawValidRect(knobImage_, knobBar, invalidatedArea, *knobStyle_, 0);
+    DrawValidRect(gfxDstBuffer, knobImage_, knobBar, invalidatedArea, *knobStyle_, 0);
 }
 
 bool UISlider::InitImage()
@@ -203,7 +203,7 @@ bool UISlider::InitImage()
     return true;
 }
 
-void UISlider::DrawForeground(const Rect& invalidatedArea, Rect& coords)
+void UISlider::DrawForeground(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, Rect& coords)
 {
     Point startPoint;
     int16_t progressWidth;
@@ -266,22 +266,22 @@ void UISlider::DrawForeground(const Rect& invalidatedArea, Rect& coords)
     }
 
     if (rect.Intersect(rect, invalidatedArea)) {
-        DrawValidRect(foregroundImage_, coords, rect, *foregroundStyle_, radius);
+        DrawValidRect(gfxDstBuffer, foregroundImage_, coords, rect, *foregroundStyle_, radius);
     }
 }
 #endif
 
-void UISlider::OnDraw(const Rect& invalidatedArea)
+void UISlider::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    DrawRect::Draw(GetOrigRect(), invalidatedArea, *style_, opaScale_);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetOrigRect(), invalidatedArea, *style_, opaScale_);
 
     Rect trunc(invalidatedArea);
     if (trunc.Intersect(trunc, GetOrigRect())) {
-        DrawBackground(trunc);
+        DrawBackground(gfxDstBuffer, trunc);
         Rect foregroundRect;
-        DrawForeground(trunc, foregroundRect);
+        DrawForeground(gfxDstBuffer, trunc, foregroundRect);
 #if ENABLE_SLIDER_KNOB
-        DrawKnob(trunc, foregroundRect);
+        DrawKnob(gfxDstBuffer, trunc, foregroundRect);
 #endif
     }
 }

frameworks/components/ui_surface_view.cpp

@@ -135,23 +135,23 @@ bool UISurfaceView::OnPreDraw(Rect& invalidatedArea) const
     return false;
 }
 
-void UISurfaceView::OnDraw(const Rect& invalidatedArea)
+void UISurfaceView::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
-    Draw(invalidatedArea);
+    Draw(gfxDstBuffer, invalidatedArea);
 }
 
-void UISurfaceView::Draw(const Rect& invalidatedArea)
+void UISurfaceView::Draw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     SurfaceBuffer* acquireBuffer = (surface_ != nullptr) ? surface_->AcquireBuffer() : nullptr;
     if (acquireBuffer != nullptr) {
         GRAPHIC_LOGE("UISurfaceView::Draw acquireBufferVirAddr=%p \n", acquireBuffer->GetVirAddr());
         // fill with buffer
-        DrawUtils::GetInstance()->DrawWithBuffer(GetRect(), invalidatedArea,
+        DrawUtils::GetInstance()->DrawWithBuffer(gfxDstBuffer, GetRect(), invalidatedArea,
                                                  reinterpret_cast<const ColorType*>(acquireBuffer->GetVirAddr()));
         surface_->ReleaseBuffer(acquireBuffer);
     } else {
         // fill with transpant color
-        DrawUtils::GetInstance()->DrawTranspantArea(GetRect(), invalidatedArea);
+        DrawUtils::GetInstance()->DrawTranspantArea(gfxDstBuffer, GetRect(), invalidatedArea);
     }
 }
 } // namespace OHOS

frameworks/components/ui_toggle_button.cpp

@@ -15,8 +15,7 @@
 
 #include "components/ui_toggle_button.h"
 #include "common/image.h"
-#include "draw/draw_arc.h"
-#include "draw/draw_rect.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "imgdecode/cache_manager.h"
 
 namespace OHOS {
@@ -54,13 +53,13 @@ void UIToggleButton::CalculateSize()
     rectWidth_ = DEFAULT_WIDTH * minValue / DEFAULT_HOT_WIDTH;
 }
 
-void UIToggleButton::OnDraw(const Rect& invalidatedArea)
+void UIToggleButton::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     if ((image_[SELECTED].GetSrcType() != IMG_SRC_UNKNOWN) && (image_[UNSELECTED].GetSrcType() != IMG_SRC_UNKNOWN)) {
-        UICheckBox::OnDraw(invalidatedArea);
+        UICheckBox::OnDraw(gfxDstBuffer, invalidatedArea);
     } else {
         CalculateSize();
-        DrawRect::Draw(GetRect(), invalidatedArea, *style_, opaScale_);
+        BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetRect(), invalidatedArea, *style_, opaScale_);
         Rect contentRect = GetContentRect();
         int16_t dx = (width_ - rectWidth_) >> 1;
         int16_t dy = (height_ >> 1) - corner_;
@@ -77,7 +76,7 @@ void UIToggleButton::OnDraw(const Rect& invalidatedArea)
                 styleSelect.bgColor_ = Color::GetColorFromRGB(DEFAULT_BG_RED, DEFAULT_BG_GREEN, DEFAULT_BG_BLUE);
                 styleSelect.bgOpa_ = OPA_OPAQUE;
                 if (isIntersect) {
-                    DrawRect::Draw(rectMid, trunc, styleSelect, opaScale_);
+                    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rectMid, trunc, styleSelect, opaScale_);
                 }
                 ArcInfo arcInfoRight = {
                     { static_cast<int16_t>(x + rectWidth_ - corner_), static_cast<int16_t>(y + corner_) }, { 0 },
@@ -87,7 +86,8 @@ void UIToggleButton::OnDraw(const Rect& invalidatedArea)
                 styleSelect.lineWidth_ = radius_;
                 styleSelect.lineColor_ = Color::White();
                 if (isIntersect) {
-                    DrawArc::GetInstance()->Draw(arcInfoRight, trunc, styleSelect, OPA_OPAQUE, CapType::CAP_NONE);
+                    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoRight, trunc,
+                                                        styleSelect, OPA_OPAQUE, CapType::CAP_NONE);
                 }
                 break;
             }
@@ -97,7 +97,7 @@ void UIToggleButton::OnDraw(const Rect& invalidatedArea)
                 styleUnSelect.bgOpa_ = DEFAULT_UNSELECTED_OPA;
                 styleUnSelect.borderRadius_ = corner_;
                 if (isIntersect) {
-                    DrawRect::Draw(rectMid, trunc, styleUnSelect, opaScale_);
+                    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, rectMid, trunc, styleUnSelect, opaScale_);
                 }
                 ArcInfo arcInfoLeft = {
                     { static_cast<int16_t>(x + corner_), static_cast<int16_t>(y + corner_) }, { 0 }, radius_, 0,
@@ -106,7 +106,8 @@ void UIToggleButton::OnDraw(const Rect& invalidatedArea)
                 styleUnSelect.lineColor_ = Color::White();
                 styleUnSelect.lineWidth_ = radius_;
                 if (isIntersect) {
-                    DrawArc::GetInstance()->Draw(arcInfoLeft, trunc, styleUnSelect, OPA_OPAQUE, CapType::CAP_NONE);
+                    BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcInfoLeft, trunc,
+                                                          styleUnSelect, OPA_OPAQUE, CapType::CAP_NONE);
                 }
                 break;
             }

frameworks/components/ui_view.cpp

@@ -17,9 +17,8 @@
 #include "components/root_view.h"
 #include "core/render_manager.h"
 #include "dock/focus_manager.h"
-#include "dock/screen_device_proxy.h"
-#include "draw/draw_rect.h"
 #include "draw/draw_utils.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "gfx_utils/graphic_log.h"
 #include "gfx_utils/mem_api.h"
 #include "securec.h"
@@ -100,10 +99,10 @@ bool UIView::OnPreDraw(Rect& invalidatedArea) const
     return false;
 }
 
-void UIView::OnDraw(const Rect& invalidatedArea)
+void UIView::OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea)
 {
     uint8_t opa = GetMixOpaScale();
-    DrawRect::Draw(GetOrigRect(), invalidatedArea, *style_, opa);
+    BaseGfxEngine::GetInstance()->DrawRect(gfxDstBuffer, GetOrigRect(), invalidatedArea, *style_, opa);
 }
 
 void UIView::SetupThemeStyles()
@@ -820,15 +819,19 @@ bool UIView::GetBitmap(ImageInfo& bitmap)
     nextSibling_ = nullptr;
     parent_ = nullptr;
 
-    int16_t screenWidth = ScreenDeviceProxy::GetInstance()->GetScreenWidth();
-    int16_t screenHeight = ScreenDeviceProxy::GetInstance()->GetScreenHeight();
+    BufferInfo* bufferInfo = BaseGfxEngine::GetInstance()->GetBufferInfo();
+    if (bufferInfo == nullptr) {
+        return false;
+    }
+    int16_t screenWidth = bufferInfo->width;
+    int16_t screenHeight = bufferInfo->height;
     Rect screenRect(0, 0, screenWidth, screenHeight);
     rect_.SetPosition(0, 0);
     Rect mask = GetRect();
     mask.Intersect(mask, screenRect);
     uint16_t bufferWidth = static_cast<uint16_t>(mask.GetWidth());
     uint16_t bufferHeight = static_cast<uint16_t>(mask.GetHeight());
-    bitmap.header.colorMode = ScreenDeviceProxy::GetInstance()->GetBufferMode();
+    bitmap.header.colorMode = bufferInfo->mode;
     bitmap.dataSize = bufferWidth * bufferHeight * DrawUtils::GetByteSizeByColorMode(bitmap.header.colorMode);
     bitmap.header.width = bufferWidth;
     bitmap.header.height = bufferHeight;
@@ -841,18 +844,23 @@ bool UIView::GetBitmap(ImageInfo& bitmap)
         rect_.SetPosition(tempX, tempY);
         return false;
     }
-    if (memset_s(viewBitmapBuffer, bitmap.dataSize, 0, bitmap.dataSize) != EOK) {
-        ImageCacheFree(bitmap);
-        return false;
-    }
-    ScreenDeviceProxy::GetInstance()->EnableBitmapBuffer(viewBitmapBuffer);
-    ScreenDeviceProxy::GetInstance()->SetViewBitmapBufferWidth(bufferWidth);
+
+    BufferInfo newBufferInfo;
+    newBufferInfo.virAddr = static_cast<void*>(viewBitmapBuffer);
+    newBufferInfo.phyAddr = newBufferInfo.virAddr;
+    newBufferInfo.rect = mask;
+    newBufferInfo.width = bufferWidth;
+    newBufferInfo.height = bufferHeight;
+    newBufferInfo.mode = bufferInfo->mode;
+
+    RootView::GetInstance()->SaveDrawContext();
+    RootView::GetInstance()->UpdateBufferInfo(&newBufferInfo);
     RootView::GetInstance()->DrawTop(this, mask);
     bitmap.data = viewBitmapBuffer;
-    ScreenDeviceProxy::GetInstance()->DisableBitmapBuffer();
+    RootView::GetInstance()->RestoreDrawContext();
     nextSibling_ = tempSibling;
     parent_ = tempParent;
     rect_.SetPosition(tempX, tempY);
     return true;
 }
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file

frameworks/core/render_manager.cpp

@@ -16,7 +16,6 @@
 #include "core/render_manager.h"
 
 #include "components/root_view.h"
-#include "dock/screen_device_proxy.h"
 #include "gfx_utils/graphic_log.h"
 #include "hal_tick.h"
 #include "securec.h"

frameworks/dock/screen_device.h

@@ -36,9 +36,12 @@ struct AllocationInfo {
 };
 #endif
 
+#ifndef TRANSFORMOPTION
+#define TRANSFORMOPTION
 struct TransformOption {
     TransformAlgorithm algorithm;
 };
+#endif
 
 /** @brief A semaphore for display buffer flushing. */
 class FlushSem : public HeapBase {

frameworks/dock/screen_device_proxy.cpp

@@ -49,8 +49,10 @@ void ScreenDeviceProxy::DrawAnimatorBuffer(const Rect& invalidatedArea)
         uint8_t pxSize = DrawUtils::GetPxSizeByColorMode(animatorImageInfo_.header.colorMode);
         TransformDataInfo imageTranDataInfo = {animatorImageInfo_.header, animatorImageInfo_.data, pxSize, LEVEL0,
                                                BILINEAR};
+#if 0 // to do delete
         DrawUtils::GetInstance()->DrawTransform(invalidRect, {0, 0}, Color::Black(), OPA_OPAQUE, transMap_,
-                                                imageTranDataInfo);
+                                               imageTranDataInfo);
+#endif
     }
 }
 

frameworks/draw/draw_arc.cpp

@@ -25,7 +25,8 @@ DrawArc* DrawArc::GetInstance()
     return &drawArc;
 }
 
-void DrawArc::DrawImg(const Point& imgPos,
+void DrawArc::DrawImg(BufferInfo& gfxDstBuffer,
+                      const Point& imgPos,
                       Rect& area,
                       const Rect& invalidatedArea,
                       const Style& style,
@@ -43,11 +44,12 @@ void DrawArc::DrawImg(const Point& imgPos,
     cordsTmp.SetHeight(header.height);
     cordsTmp.SetWidth(header.width);
     if (area.Intersect(area, invalidatedArea)) {
-        image->DrawImage(cordsTmp, area, style, opaScale);
+        image->DrawImage(gfxDstBuffer, cordsTmp, area, style, opaScale);
     }
 }
 
-void DrawArc::DrawVerLine(const Point& begin,
+void DrawArc::DrawVerLine(BufferInfo& gfxDstBuffer,
+                          const Point& begin,
                           const Point& imgPos,
                           const Rect& mask,
                           int16_t len,
@@ -57,13 +59,14 @@ void DrawArc::DrawVerLine(const Point& begin,
 {
     Rect rect(begin.x, begin.y, begin.x, begin.y + len);
     if ((image != nullptr) && (image->GetSrcType() != IMG_SRC_UNKNOWN)) {
-        DrawImg(imgPos, rect, mask, style, opaScale, image);
+        DrawImg(gfxDstBuffer, imgPos, rect, mask, style, opaScale, image);
     } else {
-        DrawUtils::GetInstance()->DrawColorArea(rect, mask, style.lineColor_, opaScale);
+        DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, style.lineColor_, opaScale);
     }
 }
 
-void DrawArc::DrawHorLine(const Point& begin,
+void DrawArc::DrawHorLine(BufferInfo& gfxDstBuffer,
+                          const Point& begin,
                           const Point& imgPos,
                           const Rect& mask,
                           int16_t len,
@@ -73,13 +76,13 @@ void DrawArc::DrawHorLine(const Point& begin,
 {
     if ((image != nullptr) && (image->GetSrcType() != IMG_SRC_UNKNOWN)) {
         Rect rect(begin.x, begin.y, begin.x + len, begin.y);
-        DrawImg(imgPos, rect, mask, style, opaScale, image);
+        DrawImg(gfxDstBuffer, imgPos, rect, mask, style, opaScale, image);
     } else {
         if (len == 0) {
-            DrawUtils::GetInstance()->DrawPixel(begin.x, begin.y, mask, style.lineColor_, opaScale);
+            DrawUtils::GetInstance()->DrawPixel(gfxDstBuffer, begin.x, begin.y, mask, style.lineColor_, opaScale);
         } else {
             Rect rect(begin.x, begin.y, begin.x + len, begin.y);
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, style.lineColor_, opaScale);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, style.lineColor_, opaScale);
         }
     }
 }
@@ -122,9 +125,14 @@ uint16_t DrawArc::CalculateTanDegree(uint16_t x, uint16_t y)
     return degree;
 }
 
-void DrawArc::DrawCircleNoEndpoint(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa, bool anti)
+void DrawArc::DrawCircleNoEndpoint(BufferInfo& gfxDstBuffer,
+                                   ArcInfo& arcInfo,
+                                   const Rect& mask,
+                                   const Style& style,
+                                   uint8_t opa,
+                                   bool anti)
 {
-    DrawAxisLine(arcInfo, mask, style, opa);
+    DrawAxisLine(gfxDstBuffer, arcInfo, mask, style, opa);
 
     int16_t yStart = mask.GetTop() - arcInfo.center.y;
     int16_t yEnd = mask.GetBottom() - arcInfo.center.y;
@@ -176,52 +184,53 @@ void DrawArc::DrawCircleNoEndpoint(ArcInfo& arcInfo, const Rect& mask, const Sty
         }
 #if ENABLE_ANTIALIAS
         if (anti) {
-            DrawLineAnti(arcInfo, mask, style, opa);
+            DrawLineAnti(gfxDstBuffer, arcInfo, mask, style, opa);
         }
 #endif
-        DrawLineWithDegree(arcInfo, -lineEnd_, -lineStart_, y_, mask, style, opa, ARC_QUADRANT_ONE);
+        DrawLineWithDegree(gfxDstBuffer, arcInfo, -lineEnd_, -lineStart_, y_, mask, style, opa, ARC_QUADRANT_ONE);
 
-        DrawLineWithDegree(arcInfo, -lineEnd_, -lineStart_, -y_, mask, style, opa, ARC_QUADRANT_TWO);
+        DrawLineWithDegree(gfxDstBuffer, arcInfo, -lineEnd_, -lineStart_, -y_, mask, style, opa, ARC_QUADRANT_TWO);
 
-        DrawLineWithDegree(arcInfo, lineStart_, lineEnd_, -y_, mask, style, opa, ARC_QUADRANT_THREE);
+        DrawLineWithDegree(gfxDstBuffer, arcInfo, lineStart_, lineEnd_, -y_, mask, style, opa, ARC_QUADRANT_THREE);
 
-        DrawLineWithDegree(arcInfo, lineStart_, lineEnd_, y_, mask, style, opa, ARC_QUADRANT_FOUR);
+        DrawLineWithDegree(gfxDstBuffer, arcInfo, lineStart_, lineEnd_, y_, mask, style, opa, ARC_QUADRANT_FOUR);
     }
 }
 
-void DrawArc::DrawAxisLine(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa)
+void DrawArc::DrawAxisLine(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa)
 {
     int16_t lineWidth = 0;
     int16_t outRadius = outRadius_ - 1;
     int16_t inRadius = inRadius_;
     if (inRadius <= 0) {
         inRadius = 1;
-        DrawHorLine(arcInfo.center, arcInfo.imgPos, mask, 0, style, opa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, arcInfo.center, arcInfo.imgPos, mask, 0, style, opa, arcInfo.imgSrc);
     }
     lineWidth = outRadius - inRadius;
 
     if (isCircle_ || (IS_IN_DEGREERANE(THREE_QUARTER_IN_DEGREE, arcInfo.startAngle, arcInfo.endAngle))) {
-        DrawHorLine(Point{static_cast<int16_t>(arcInfo.center.x - outRadius), arcInfo.center.y}, arcInfo.imgPos, mask,
-                    lineWidth, style, opa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{static_cast<int16_t>(arcInfo.center.x - outRadius), arcInfo.center.y},
+                    arcInfo.imgPos, mask, lineWidth, style, opa, arcInfo.imgSrc);
     }
 
     if (isCircle_ || (IS_IN_DEGREERANE(QUARTER_IN_DEGREE, arcInfo.startAngle, arcInfo.endAngle))) {
-        DrawHorLine(Point{static_cast<int16_t>(arcInfo.center.x + inRadius), arcInfo.center.y}, arcInfo.imgPos, mask,
-                    lineWidth, style, opa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{static_cast<int16_t>(arcInfo.center.x + inRadius), arcInfo.center.y},
+                    arcInfo.imgPos, mask, lineWidth, style, opa, arcInfo.imgSrc);
     }
 
     if (isCircle_ || (IS_IN_DEGREERANE(0, arcInfo.startAngle, arcInfo.endAngle))) {
-        DrawVerLine(Point{arcInfo.center.x, static_cast<int16_t>(arcInfo.center.y - outRadius)}, arcInfo.imgPos, mask,
-                    lineWidth, style, opa, arcInfo.imgSrc);
+        DrawVerLine(gfxDstBuffer, Point{arcInfo.center.x, static_cast<int16_t>(arcInfo.center.y - outRadius)},
+                    arcInfo.imgPos, mask, lineWidth, style, opa, arcInfo.imgSrc);
     }
 
     if (isCircle_ || (IS_IN_DEGREERANE(SEMICIRCLE_IN_DEGREE, arcInfo.startAngle, arcInfo.endAngle))) {
-        DrawVerLine(Point{arcInfo.center.x, static_cast<int16_t>(arcInfo.center.y + inRadius)}, arcInfo.imgPos, mask,
-                    lineWidth, style, opa, arcInfo.imgSrc);
+        DrawVerLine(gfxDstBuffer, Point{arcInfo.center.x, static_cast<int16_t>(arcInfo.center.y + inRadius)},
+                    arcInfo.imgPos, mask, lineWidth, style, opa, arcInfo.imgSrc);
     }
 }
 
-void DrawArc::DrawLineWithDegree(ArcInfo& arcInfo,
+void DrawArc::DrawLineWithDegree(BufferInfo& gfxDstBuffer,
+                                 ArcInfo& arcInfo,
                                  int16_t start,
                                  int16_t end,
                                  int16_t y,
@@ -231,8 +240,9 @@ void DrawArc::DrawLineWithDegree(ArcInfo& arcInfo,
                                  uint8_t quadrant)
 {
     if (isCircle_) {
-        DrawHorLine(Point{static_cast<int16_t>(arcInfo.center.x + start), static_cast<int16_t>(arcInfo.center.y + y)},
-                    arcInfo.imgPos, mask, end - start, style, opaScale, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{static_cast<int16_t>(arcInfo.center.x + start),
+                    static_cast<int16_t>(arcInfo.center.y + y)}, arcInfo.imgPos,
+                    mask, end - start, style, opaScale, arcInfo.imgSrc);
         return;
     }
     uint16_t degreeStart = GetDegreeInQuadrant(CalculateTanDegree(MATH_ABS(start), MATH_ABS(y)), quadrant);
@@ -249,23 +259,24 @@ void DrawArc::DrawLineWithDegree(ArcInfo& arcInfo,
         case OUT_DEGREE_RANG:
             return;
         case IN_DEGREE_RANG:
-            DrawHorLine(
+            DrawHorLine(gfxDstBuffer,
                 Point{static_cast<int16_t>(arcInfo.center.x + start), static_cast<int16_t>(arcInfo.center.y + y)},
                 arcInfo.imgPos, mask, end - start, style, opaScale, arcInfo.imgSrc);
             return;
         case INTERSECT:
-            DrawLineWithDegreeInner(arcInfo, start, end, y, mask, style, opaScale, quadrant);
+            DrawLineWithDegreeInner(gfxDstBuffer, arcInfo, start, end, y, mask, style, opaScale, quadrant);
             return;
         case DOUBLE_INTERSECT:
-            drawEnd = DrawLineWithDegreeInner(arcInfo, start, end, y, mask, style, opaScale, quadrant);
-            DrawLineWithDegreeInner(arcInfo, drawEnd + 1, end, y, mask, style, opaScale, quadrant);
+            drawEnd = DrawLineWithDegreeInner(gfxDstBuffer, arcInfo, start, end, y, mask, style, opaScale, quadrant);
+            DrawLineWithDegreeInner(gfxDstBuffer, arcInfo, drawEnd + 1, end, y, mask, style, opaScale, quadrant);
             return;
         default:
             return;
     }
 }
 
-int16_t DrawArc::DrawLineWithDegreeInner(ArcInfo& arcInfo,
+int16_t DrawArc::DrawLineWithDegreeInner(BufferInfo& gfxDstBuffer,
+                                         ArcInfo& arcInfo,
                                          int16_t start,
                                          int16_t end,
                                          int16_t y,
@@ -294,7 +305,7 @@ int16_t DrawArc::DrawLineWithDegreeInner(ArcInfo& arcInfo,
         drawEnd = end;
     }
     if ((drawStart != COORD_MIN) && (drawEnd != COORD_MIN)) {
-        DrawHorLine(
+        DrawHorLine(gfxDstBuffer,
             Point{static_cast<int16_t>(arcInfo.center.x + drawStart), static_cast<int16_t>(arcInfo.center.y + y)},
             arcInfo.imgPos, mask, drawEnd - drawStart, style, opaScale, arcInfo.imgSrc);
     }
@@ -302,7 +313,8 @@ int16_t DrawArc::DrawLineWithDegreeInner(ArcInfo& arcInfo,
 }
 
 #if ENABLE_ANTIALIAS
-void DrawArc::DrawLineAnti(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa)
+void DrawArc::DrawLineAnti(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask,
+                           const Style& style, uint8_t opa)
 {
     outAntiStart_ = lineStart_;
     outAntiEnd_ = lineStart_;
@@ -332,7 +344,7 @@ void DrawArc::DrawLineAnti(ArcInfo& arcInfo, const Rect& mask, const Style& styl
             (((static_cast<uint64_t>(outRadius_) << 1) - 1 - (currentSqr - antiOutRadiusSqr_)) * OPA_OPAQUE) /
             ((outRadius_ << 1) - 1);
         antiOpa = (opa == OPA_OPAQUE) ? antiOpa : (static_cast<uint16_t>(antiOpa) * opa) >> SHIFT_8;
-        DrawPointAnti(arcInfo, xAnti, mask, style, antiOpa);
+        DrawPointAnti(gfxDstBuffer, arcInfo, xAnti, mask, style, antiOpa);
     }
 
     for (int16_t xAnti = inAntiStart_; xAnti <= inAntiEnd_; xAnti++) {
@@ -342,11 +354,12 @@ void DrawArc::DrawLineAnti(ArcInfo& arcInfo, const Rect& mask, const Style& styl
         }
         uint8_t antiOpa = (static_cast<uint64_t>(currentSqr - antiInRadiusSqr_) * OPA_OPAQUE) / ((inRadius_ << 1) - 1);
         antiOpa = (opa == OPA_OPAQUE) ? antiOpa : (static_cast<uint16_t>(antiOpa) * opa) >> SHIFT_8;
-        DrawPointAnti(arcInfo, xAnti, mask, style, antiOpa);
+        DrawPointAnti(gfxDstBuffer, arcInfo, xAnti, mask, style, antiOpa);
     }
 }
 
-void DrawArc::DrawPointAnti(ArcInfo& arcInfo, int16_t x, const Rect& mask, const Style& style, uint8_t antiOpa)
+void DrawArc::DrawPointAnti(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, int16_t x, const Rect& mask,
+                            const Style& style, uint8_t antiOpa)
 {
     int16_t startX;
     int16_t starty;
@@ -354,22 +367,22 @@ void DrawArc::DrawPointAnti(ArcInfo& arcInfo, int16_t x, const Rect& mask, const
     if (isCircle_ || (IS_IN_DEGREERANE(CIRCLE_IN_DEGREE - degreeBase, arcInfo.startAngle, arcInfo.endAngle))) {
         startX = arcInfo.center.x + x;
         starty = arcInfo.center.y + y_;
-        DrawHorLine(Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
     }
     if (isCircle_ || (IS_IN_DEGREERANE(SEMICIRCLE_IN_DEGREE + degreeBase, arcInfo.startAngle, arcInfo.endAngle))) {
         startX = arcInfo.center.x + x;
         starty = arcInfo.center.y - y_;
-        DrawHorLine(Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
     }
     if (isCircle_ || (IS_IN_DEGREERANE(degreeBase, arcInfo.startAngle, arcInfo.endAngle))) {
         startX = arcInfo.center.x - x;
         starty = arcInfo.center.y + y_;
-        DrawHorLine(Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
     }
     if (isCircle_ || (IS_IN_DEGREERANE(SEMICIRCLE_IN_DEGREE - degreeBase, arcInfo.startAngle, arcInfo.endAngle))) {
         startX = arcInfo.center.x - x;
         starty = arcInfo.center.y - y_;
-        DrawHorLine(Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
+        DrawHorLine(gfxDstBuffer, Point{startX, starty}, arcInfo.imgPos, mask, 0, style, antiOpa, arcInfo.imgSrc);
     }
 }
 #endif
@@ -390,7 +403,8 @@ uint16_t DrawArc::GetDegreeInQuadrant(uint16_t degree, uint8_t quadrant)
     }
 }
 
-void DrawArc::Draw(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opaScale, uint8_t cap)
+void DrawArc::Draw(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask,
+                   const Style& style, uint8_t opaScale, uint8_t cap)
 {
     OpacityType opa = DrawUtils::GetMixOpacity(opaScale, style.lineOpa_);
     if ((opa == OPA_TRANSPARENT) || (style.lineWidth_ < 1)) {
@@ -400,9 +414,9 @@ void DrawArc::Draw(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8
     SetArcInfo(arcInfo, style);
     if (arcInfo.startAngle != arcInfo.endAngle) {
         if ((arcInfo.imgSrc != nullptr) && (arcInfo.imgSrc->GetSrcType() != IMG_SRC_UNKNOWN)) {
-            DrawCircleNoEndpoint(arcInfo, mask, style, opa, false);
+            DrawCircleNoEndpoint(gfxDstBuffer, arcInfo, mask, style, opa, false);
         } else {
-            DrawCircleNoEndpoint(arcInfo, mask, style, opa, true);
+            DrawCircleNoEndpoint(gfxDstBuffer, arcInfo, mask, style, opa, true);
         }
     }
 
@@ -431,7 +445,7 @@ void DrawArc::Draw(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8
         endArcInfo.center.x += startCapX;
         endArcInfo.center.y -= startCapY;
         SetArcInfo(endArcInfo, style);
-        DrawCircleNoEndpoint(endArcInfo, mask, style, opa, true);
+        DrawCircleNoEndpoint(gfxDstBuffer, endArcInfo, mask, style, opa, true);
 
         temp = (outRadius - endArcInfo.radius + 1) * Sin(arcInfo.endAngle);
         int16_t endCapX = static_cast<int16_t>((temp > 0) ? (temp + 0.5f) : (temp - 0.5f));
@@ -443,7 +457,7 @@ void DrawArc::Draw(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8
         endArcInfo.center.x += endCapX;
         endArcInfo.center.y -= endCapY;
         SetArcInfo(endArcInfo, style);
-        DrawCircleNoEndpoint(endArcInfo, mask, style, opa, true);
+        DrawCircleNoEndpoint(gfxDstBuffer, endArcInfo, mask, style, opa, true);
     }
 }
 

frameworks/draw/draw_arc.h

@@ -24,22 +24,14 @@
 #include "gfx_utils/style.h"
 
 namespace OHOS {
-struct ArcInfo {
-    Point center;
-    Point imgPos;
-    uint16_t radius;
-    int16_t startAngle;
-    int16_t endAngle;
-    const Image* imgSrc;
-};
-
 class DrawArc : public HeapBase {
 public:
     static DrawArc* GetInstance();
 
     void GetDrawRange(int16_t& start, int16_t& end);
 
-    void Draw(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opaScale, uint8_t cap);
+    void Draw(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask,
+              const Style& style, uint8_t opaScale, uint8_t cap);
 
 private:
     static constexpr uint8_t DRAW_ARC_QUADRANT_NUM = 4;
@@ -86,8 +78,11 @@ private:
           antiInRadiusSqr_(0)
     {
     }
+
     ~DrawArc() {}
-    void DrawVerLine(const Point& begin,
+
+    void DrawVerLine(BufferInfo& gfxDstBuffer,
+                     const Point& begin,
                      const Point& imgPos,
                      const Rect& mask,
                      int16_t len,
@@ -95,7 +90,8 @@ private:
                      uint8_t opaScale,
                      const Image* imgSrc);
 
-    void DrawHorLine(const Point& begin,
+    void DrawHorLine(BufferInfo& gfxDstBuffer,
+                     const Point& begin,
                      const Point& imgPos,
                      const Rect& mask,
                      int16_t len,
@@ -103,7 +99,8 @@ private:
                      uint8_t opaScale,
                      const Image* imgSrc);
 
-    void DrawImg(const Point& imgPos,
+    void DrawImg(BufferInfo& gfxDstBuffer,
+                 const Point& imgPos,
                  Rect& area,
                  const Rect& invalidatedArea,
                  const Style& style,
@@ -111,11 +108,17 @@ private:
                  const Image* imgSrc);
 
     int16_t GetDegreeRangeIntersectState(uint16_t degreeStart, uint16_t degreeEnd, uint16_t start, uint16_t end);
+
     uint16_t CalculateTanDegree(uint16_t x, uint16_t y);
+
     int16_t GetDrawAngle(int16_t angle);
-    void DrawCircleNoEndpoint(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa, bool anti);
-    void DrawAxisLine(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa);
-    void DrawLineWithDegree(ArcInfo& arcInfo,
+
+    void DrawCircleNoEndpoint(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa, bool anti);
+
+    void DrawAxisLine(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa);
+
+    void DrawLineWithDegree(BufferInfo& gfxDstBuffer,
+                            ArcInfo& arcInfo,
                             int16_t start,
                             int16_t end,
                             int16_t y,
@@ -123,7 +126,9 @@ private:
                             const Style& style,
                             uint8_t opaScale,
                             uint8_t quadrant);
-    int16_t DrawLineWithDegreeInner(ArcInfo& arcInfo,
+
+    int16_t DrawLineWithDegreeInner(BufferInfo& gfxDstBuffer,
+                                    ArcInfo& arcInfo,
                                     int16_t start,
                                     int16_t end,
                                     int16_t y,
@@ -132,8 +137,13 @@ private:
                                     uint8_t opaScale,
                                     uint8_t quadrant);
 #if ENABLE_ANTIALIAS
-    void DrawLineAnti(ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa);
-    void DrawPointAnti(ArcInfo& arcInfo, int16_t x, const Rect& mask, const Style& style, uint8_t antiOpa);
+    void DrawLineAnti(BufferInfo& gfxDstBuffer, ArcInfo& arcInfo, const Rect& mask, const Style& style, uint8_t opa);
+    void DrawPointAnti(BufferInfo& gfxDstBuffer,
+                       ArcInfo& arcInfo,
+                       int16_t x,
+                       const Rect& mask,
+                       const Style& style,
+                       uint8_t antiOpa);
 #endif
     uint16_t GetDegreeInQuadrant(uint16_t degree, uint8_t quadrant);
     void SetArcInfo(ArcInfo& arcInfo, const Style& style);

frameworks/draw/draw_curve.cpp

@@ -15,11 +15,12 @@
 
 #include "draw/draw_curve.h"
 #include "animator/interpolation.h"
-#include "draw/draw_line.h"
+#include "engines/gfx/gfx_engine_manager.h"
 
 namespace OHOS {
-void DrawCurve::DrawCubicBezier(const Point& start, const Point& control1, const Point& control2, const Point& end,
-    const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity)
+void DrawCurve::DrawCubicBezier(BufferInfo& gfxDstBuffer, const Point& start, const Point& control1,
+                                const Point& control2, const Point& end, const Rect& mask,
+                                int16_t width, const ColorType& color, OpacityType opacity)
 {
     if ((width == 0) || (opacity == OPA_TRANSPARENT)) {
         return;
@@ -33,7 +34,7 @@ void DrawCurve::DrawCubicBezier(const Point& start, const Point& control1, const
         if ((prePoint.x == point.x) && (prePoint.y == point.y)) {
             continue;
         }
-        DrawLine::Draw(prePoint, point, mask, width, color, opacity);
+        BaseGfxEngine::GetInstance()->DrawLine(gfxDstBuffer, prePoint, point, mask, width, color, opacity);
         prePoint = point;
     }
 }

frameworks/draw/draw_curve.h

@@ -18,12 +18,14 @@
 
 #include "gfx_utils/color.h"
 #include "gfx_utils/geometry2d.h"
+#include "gfx_utils/graphic_buffer.h"
 
 namespace OHOS {
 class DrawCurve : public HeapBase {
 public:
-    static void DrawCubicBezier(const Point& start, const Point& control1, const Point& control2, const Point& end,
-        const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity);
+    static void DrawCubicBezier(BufferInfo& gfxDstBuffer, const Point& start, const Point& control1,
+                                const Point& control2, const Point& end, const Rect& mask,
+                                int16_t width, const ColorType& color, OpacityType opacity);
 private:
     static constexpr uint16_t INTERPOLATION_RANGE = 1024;
 };

frameworks/draw/draw_image.cpp

@@ -20,7 +20,7 @@
 #include "imgdecode/cache_manager.h"
 
 namespace OHOS {
-void DrawImage::DrawCommon(const Rect& coords, const Rect& mask,
+void DrawImage::DrawCommon(BufferInfo& gfxDstBuffer, const Rect& coords, const Rect& mask,
     const ImageInfo* img, const Style& style, uint8_t opaScale)
 {
     if (img == nullptr) {
@@ -52,11 +52,11 @@ void DrawImage::DrawCommon(const Rect& coords, const Rect& mask,
             break;
     }
     lutColorMode = DrawUtils::GetLutColorModeBySize(size);
-    DrawUtils::GetInstance()->DrawImage(coords, mask, img->data, opa, pxBitSize,
+    DrawUtils::GetInstance()->DrawImage(gfxDstBuffer, coords, mask, img->data, opa, pxBitSize,
                                         static_cast<ColorMode>(img->header.colorMode), lutColorMode);
 }
 
-void DrawImage::DrawCommon(const Rect& coords, const Rect& mask,
+void DrawImage::DrawCommon(BufferInfo& gfxDstBuffer, const Rect& coords, const Rect& mask,
     const char* path, const Style& style, uint8_t opaScale)
 {
     if (path == nullptr) {
@@ -71,7 +71,7 @@ void DrawImage::DrawCommon(const Rect& coords, const Rect& mask,
 
     uint8_t pxBitSize = DrawUtils::GetPxSizeByColorMode(entry.GetImageInfo().header.colorMode);
     if (entry.InCache()) {
-        DrawUtils::GetInstance()->DrawImage(coords, mask, entry.GetImgData(), opa, pxBitSize,
+        DrawUtils::GetInstance()->DrawImage(gfxDstBuffer, coords, mask, entry.GetImgData(), opa, pxBitSize,
                                             static_cast<ColorMode>(entry.GetImageInfo().header.colorMode));
     } else {
         Rect valid = coords;
@@ -100,7 +100,7 @@ void DrawImage::DrawCommon(const Rect& coords, const Rect& mask,
                 UIFree(buf);
                 return;
             }
-            DrawUtils::GetInstance()->DrawImage(line, mask, buf, opa, pxBitSize,
+            DrawUtils::GetInstance()->DrawImage(gfxDstBuffer, line, mask, buf, opa, pxBitSize,
                                                 static_cast<ColorMode>(entry.GetImageInfo().header.colorMode));
             line.SetTop(line.GetTop() + 1);
             line.SetBottom(line.GetBottom() + 1);

frameworks/draw/draw_image.h

@@ -30,10 +30,10 @@ public:
     DrawImage() {}
     ~DrawImage() {}
 
-    static void DrawCommon(const Rect& coords, const Rect& mask,
+    static void DrawCommon(BufferInfo& gfxDstBuffer, const Rect& coords, const Rect& mask,
         const ImageInfo* img, const Style& style, uint8_t opaScale);
 
-    static void DrawCommon(const Rect& coords, const Rect& mask,
+    static void DrawCommon(BufferInfo& gfxDstBuffer, const Rect& coords, const Rect& mask,
         const char* path, const Style& style, uint8_t opaScale);
 };
 } // namespace OHOS

frameworks/draw/draw_label.cpp

@@ -17,12 +17,13 @@
 #include <cstdio>
 #include "common/typed_text.h"
 #include "draw/draw_utils.h"
+#include "engines/gfx/gfx_engine_manager.h"
 #include "font/ui_font.h"
 #include "font/ui_font_header.h"
 #include "gfx_utils/graphic_log.h"
 
 namespace OHOS {
-void DrawLabel::DrawTextOneLine(const LabelLineInfo& labelLine)
+void DrawLabel::DrawTextOneLine(BufferInfo& gfxDstBuffer, const LabelLineInfo& labelLine)
 {
     UIFont* fontEngine = UIFont::GetInstance();
     if (labelLine.direct == TEXT_DIRECT_RTL) {
@@ -48,7 +49,7 @@ void DrawLabel::DrawTextOneLine(const LabelLineInfo& labelLine)
                                    labelLine.fontId,
                                    0,
                                    labelLine.fontSize};
-        DrawUtils::GetInstance()->DrawLetter(letterInfo);
+        DrawUtils::GetInstance()->DrawLetter(gfxDstBuffer, letterInfo);
         letterWidth = fontEngine->GetWidth(letter, 0);
         if (labelLine.direct == TEXT_DIRECT_RTL) {
             labelLine.pos.x -= (letterWidth + labelLine.style.letterSpace_);
@@ -58,7 +59,8 @@ void DrawLabel::DrawTextOneLine(const LabelLineInfo& labelLine)
     }
 }
 
-void DrawLabel::DrawArcText(const Rect& mask,
+void DrawLabel::DrawArcText(BufferInfo& gfxDstBuffer,
+                            const Rect& mask,
                             const char* text,
                             const Point& arcCenter,
                             uint8_t fontId,
@@ -113,12 +115,13 @@ void DrawLabel::DrawArcText(const Rect& mask,
         TypedText::GetArcLetterPos(arcCenter, arcTextInfo.radius, angle, posX, posY);
         angle += incrementAngle;
 
-        DrawLetterWithRotate(mask, fontId, letter, Point{MATH_ROUND(posX), MATH_ROUND(posY)},
+        DrawLetterWithRotate(gfxDstBuffer, mask, fontId, letter, Point{MATH_ROUND(posX), MATH_ROUND(posY)},
                              static_cast<int16_t>(rotateAngle), style.textColor_, opaScale);
     }
 }
 
-void DrawLabel::DrawLetterWithRotate(const Rect& mask,
+void DrawLabel::DrawLetterWithRotate(BufferInfo& gfxDstBuffer,
+                                     const Rect& mask,
                                      uint8_t fontId,
                                      uint32_t letter,
                                      const Point& pos,
@@ -162,6 +165,7 @@ void DrawLabel::DrawLetterWithRotate(const Rect& mask,
     transMap.Rotate(rotateAngle, Vector2<float>(-node.left, node.top - head.ascender));
     TransformDataInfo letterTranDataInfo = {ImageHeader{colorMode, 0, 0, 0, node.cols, node.rows}, fontMap, fontWeight,
                                             BlurLevel::LEVEL0};
-    DrawUtils::GetInstance()->DrawTransform(mask, Point{0, 0}, color, opaScale, transMap, letterTranDataInfo);
+    BaseGfxEngine::GetInstance()->DrawTransform(gfxDstBuffer, mask, Point{0, 0}, color, opaScale, transMap,
+                                                letterTranDataInfo);
 }
 } // namespace OHOS

frameworks/draw/draw_label.h

@@ -25,14 +25,20 @@
 namespace OHOS {
 class DrawLabel : public HeapBase {
 public:
-    static void DrawTextOneLine(const LabelLineInfo& labelLine);
+    static void DrawTextOneLine(BufferInfo& gfxDstBuffer, const LabelLineInfo& labelLine);
 
-    static void DrawArcText(const Rect& mask, const char* text, const Point& arcCenter, uint8_t fontId,
-        const UIArcLabel::ArcTextInfo arcTextInfo, UIArcLabel::TextOrientation orientation, const Style& style,
-        uint8_t opaScale);
+    static void DrawArcText(BufferInfo& gfxDstBuffer, const Rect& mask, const char* text,
+                            const Point& arcCenter, uint8_t fontId, const UIArcLabel::ArcTextInfo arcTextInfo,
+                            UIArcLabel::TextOrientation orientation, const Style& style, uint8_t opaScale);
 
-    static void DrawLetterWithRotate(const Rect& mask, uint8_t fontId, uint32_t letter, const Point& pos,
-        int16_t rotateAngle, const ColorType& color, OpacityType opaScale);
+    static void DrawLetterWithRotate(BufferInfo& gfxDstBuffer,
+                                     const Rect& mask,
+                                     uint8_t fontId,
+                                     uint32_t letter,
+                                     const Point& pos,
+                                     int16_t rotateAngle,
+                                     const ColorType& color,
+                                     OpacityType opaScale);
 };
 } // namespace OHOS
 #endif // GRAPHIC_LITE_DRAW_LABEL_H

frameworks/draw/draw_line.cpp

@@ -56,7 +56,8 @@ namespace OHOS {
         SWAP_POINTS((x1), (x2), (y1), (y2));                 \
     }
 
-void DrawLine::Draw(const Point& start,
+void DrawLine::Draw(BufferInfo& gfxDstBuffer,
+                    const Point& start,
                     const Point& end,
                     const Rect& mask,
                     int16_t width,
@@ -83,15 +84,16 @@ void DrawLine::Draw(const Point& start,
     }
 
     if (start.y == end.y) {
-        DrawHorizontalLine(start, end, mask, width, color, opacity);
+        DrawHorizontalLine(gfxDstBuffer, start, end, mask, width, color, opacity);
     } else if (start.x == end.x) {
-        DrawVerticalLine(start, end, mask, width, color, opacity);
+        DrawVerticalLine(gfxDstBuffer, start, end, mask, width, color, opacity);
     } else {
-        DrawWuLine(start, end, mask, width, color, opacity);
+        DrawWuLine(gfxDstBuffer, start, end, mask, width, color, opacity);
     }
 }
 
-void DrawLine::DrawVerticalLine(const Point& start,
+void DrawLine::DrawVerticalLine(BufferInfo& gfxDstBuffer,
+                                const Point& start,
                                 const Point& end,
                                 const Rect& mask,
                                 int16_t width,
@@ -112,10 +114,10 @@ void DrawLine::DrawVerticalLine(const Point& start,
         rect.SetHeight(start.y - end.y + 1);
     }
 
-    DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+    DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
 }
 
-void DrawLine::DrawHorizontalLine(const Point& start,
+void DrawLine::DrawHorizontalLine(BufferInfo& gfxDstBuffer, const Point& start,
                                   const Point& end,
                                   const Rect& mask,
                                   int16_t width,
@@ -136,14 +138,14 @@ void DrawLine::DrawHorizontalLine(const Point& start,
         rect.SetHeight(width);
     }
 
-    DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+    DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
 }
 
-void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask,
-    int16_t width, const ColorType& color, OpacityType opacity)
+void DrawLine::DrawWuLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end,
+    const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity)
 {
     if (width <= 2) { // 2 : thin line width
-        DrawThinWuLine(start, end, mask, width, color, opacity);
+        DrawThinWuLine(gfxDstBuffer, start, end, mask, width, color, opacity);
         return;
     }
 
@@ -179,7 +181,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
     // width is longer than distance between start point and end point, need swap direction of line.
     if (dx * dx + dy * dy < width * width) {
         if ((dx == 1) && (dy == 1)) {
-            DrawThinWuLine({ x0Int, y0Int }, { x3Int, y3Int }, mask, 2, color, opacity); // 2 : width of line
+            DrawThinWuLine(gfxDstBuffer, { x0Int, y0Int }, { x3Int, y3Int }, mask, 2, color, opacity); // 2 : width of line
             return;
         }
         dx = MATH_ABS(x0Int - x1Int);
@@ -245,7 +247,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
             dx = MATH_ABS(x1Int - x0Int);
             sx = x0Int;
             sy = y0Int;
-            DrawUtils::GetInstance()->DrawPixel(x0Int, y0Int, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawPixel(gfxDstBuffer, x0Int, y0Int, mask, color, opacity);
             while (--dx) {
                 accTemp1 = acc1;
                 acc1 += adj1;
@@ -256,7 +258,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                     sy++;
                 }
                 sx -= dir;
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy, mask, color, opacity,
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy, mask, color, opacity,
                     (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
             }
             if (sy - y0Int < MAX_LINE_WIDTH) {
@@ -268,7 +270,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
             dx = MATH_ABS(x3Int - x2Int);
             sy = y3Int;
             sx = x3Int;
-            DrawUtils::GetInstance()->DrawPixel(x3Int, y3Int, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawPixel(gfxDstBuffer, x3Int, y3Int, mask, color, opacity);
             while (--dx) {
                 accTemp1 = acc1;
                 acc1 += adj1;
@@ -279,7 +281,8 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                     sy--;
                 }
                 sx += dir;
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy, mask, color, opacity, (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy, mask, color, opacity,
+                                                          (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
             }
             if (temp1 < MAX_LINE_WIDTH) {
                 endPoints1[temp1++] = sx + dir;
@@ -287,9 +290,9 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
         } else {
             /* If y0 is equal to y1, draw two horizontal lines as the top line and bottom line. */
             rect.SetRect(MATH_MIN(x0Int, x1Int), y0Int, MATH_MAX(x0Int, x1Int), y1Int);
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
             rect.SetRect(MATH_MIN(x2Int, x3Int), y3Int, MATH_MAX(x2Int, x3Int), y2Int);
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
         }
 
         sx = x0Int;
@@ -302,7 +305,8 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
         while (--dy) {
             if (sy <= y1Int) {
                 INCREASE_ACC(acc0, accTemp0, adj0, sx, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx + dir, sy, mask, color, opacity, acc0 >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx + dir, sy, mask,
+                                                          color, opacity, acc0 >> SHIFT_8);
                 if (temp0 < MAX_LINE_WIDTH) {
                     edge0 = endPoints0[temp0++];
                 }
@@ -310,15 +314,16 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
             } else if (sy < y2Int) {
                 INCREASE_ACC(acc0, accTemp0, adj0, sx, dir);
                 INCREASE_ACC(acc2, accTemp2, adj0, sxTemp, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx + dir, sy, mask, color, opacity, acc0 >> SHIFT_8);
-                DrawUtils::GetInstance()->DrawPixelInLine(sxTemp, sy, mask, color, opacity,
-                    (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx + dir, sy, mask,
+                                                          color, opacity, acc0 >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sxTemp, sy, mask, color, opacity,
+                                                          (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
                 edge0 = sxTemp + dir;
                 edge1 = sx;
             } else if (sy < y3Int) {
                 INCREASE_ACC(acc2, accTemp2, adj0, sxTemp, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sxTemp, sy, mask, color, opacity,
-                    (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sxTemp, sy, mask, color, opacity,
+                                                          (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
                 edge0 = sxTemp + dir;
                 if (temp1 > 0) {
                     edge1 = endPoints1[--temp1];
@@ -328,7 +333,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                 SWAP_INT16(edge0, edge1);
             }
             rect.SetRect(edge0, sy, edge1, sy);
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
             sy++;
         }
     } else {
@@ -340,7 +345,7 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
             dy = MATH_ABS(y1Int - y0Int);
             sx = x0Int;
             sy = y0Int;
-            DrawUtils::GetInstance()->DrawPixel(sx, sy, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawPixel(gfxDstBuffer, sx, sy, mask, color, opacity);
             while (--dy) {
                 accTemp1 = acc1;
                 acc1 += adj1;
@@ -351,8 +356,8 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                     sx--;
                 }
                 sy -= dir;
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy, mask, color, opacity,
-                    (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy, mask, color, opacity,
+                                                          (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
             }
             if (x0Int - sx < MAX_LINE_WIDTH) {
                 endPoints0[x0Int - sx] = sy - dir;
@@ -373,18 +378,19 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                     sx++;
                 }
                 sy += dir;
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy, mask, color, opacity, (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy, mask, color, opacity,
+                                                          (acc1 >> SHIFT_8) ^ OPA_OPAQUE);
             }
-            DrawUtils::GetInstance()->DrawPixel(x3Int, y3Int, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawPixel(gfxDstBuffer, x3Int, y3Int, mask, color, opacity);
             if (temp1 < MAX_LINE_WIDTH) {
                 endPoints1[temp1++] = sy + dir;
             }
         } else {
             /* If x0 is equal to x1, draw two vertical lines as the top line and bottom line. */
             rect.SetRect(x1Int, MATH_MIN(y0Int, y1Int), x0Int, MATH_MAX(y0Int, y1Int));
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
             rect.SetRect(x3Int, MATH_MIN(y2Int, y3Int), x2Int, MATH_MAX(y2Int, y3Int));
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
         }
 
         sx = x0Int - 1;
@@ -397,7 +403,8 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
         while (--dx) {
             if (sx >= x1Int) {
                 INCREASE_ACC(acc0, accTemp0, adj0, sy, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy + dir, mask, color, opacity, acc0 >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy + dir, mask,
+                                                          color, opacity, acc0 >> SHIFT_8);
                 if (temp0 < MAX_LINE_WIDTH) {
                     edge0 = endPoints0[temp0++];
                 }
@@ -405,15 +412,16 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
             } else if (sx > x2Int) {
                 INCREASE_ACC(acc0, accTemp0, adj0, sy, dir);
                 INCREASE_ACC(acc2, accTemp2, adj0, syTemp, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, sy + dir, mask, color, opacity, acc0 >> SHIFT_8);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, syTemp, mask, color, opacity,
-                    (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, sy + dir, mask,
+                                                          color, opacity, acc0 >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, syTemp, mask, color,
+                                                          opacity, (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
                 edge0 = syTemp + dir;
                 edge1 = sy;
             } else if (sx > x3Int) {
                 INCREASE_ACC(acc2, accTemp2, adj0, syTemp, dir);
-                DrawUtils::GetInstance()->DrawPixelInLine(sx, syTemp, mask, color, opacity,
-                    (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
+                DrawUtils::GetInstance()->DrawPixelInLine(gfxDstBuffer, sx, syTemp, mask, color, opacity,
+                                                          (acc2 >> SHIFT_8) ^ OPA_OPAQUE);
                 edge0 = syTemp + dir;
                 if (temp1 > 0) {
                     edge1 = endPoints1[--temp1];
@@ -423,14 +431,14 @@ void DrawLine::DrawWuLine(const Point& start, const Point& end, const Rect& mask
                 SWAP_INT16(edge0, edge1);
             }
             rect.SetRect(sx, edge0, sx, edge1);
-            DrawUtils::GetInstance()->DrawColorArea(rect, mask, color, opacity);
+            DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, rect, mask, color, opacity);
             sx--;
         }
     }
 }
 
-void DrawLine::DrawThinWuLine(const Point& start, const Point& end, const Rect& mask,
-    int16_t width, const ColorType& color, OpacityType opacity)
+void DrawLine::DrawThinWuLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end,
+    const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity)
 {
     int16_t sx = start.x;
     int16_t sy = start.y;
@@ -449,10 +457,11 @@ void DrawLine::DrawThinWuLine(const Point& start, const Point& end, const Rect&
             INCREASE_ACC(acc, accTemp, adj, sx, dir);
             sy++;
             if (width == 1) {
-                DrawUtils::GetInstance()->DrawAdjPixelInLine(sx, sy, sx + dir, sy, mask, color, opacity,
-                    acc >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawAdjPixelInLine(gfxDstBuffer, sx, sy, sx + dir, sy, mask,
+                                                             color, opacity, acc >> SHIFT_8);
             } else {
-                DrawUtils::GetInstance()->DrawVerPixelInLine(sx, sy, dir, mask, color, opacity, acc >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawVerPixelInLine(gfxDstBuffer, sx, sy, dir, mask,
+                                                             color, opacity, acc >> SHIFT_8);
             }
         }
     } else {
@@ -461,10 +470,11 @@ void DrawLine::DrawThinWuLine(const Point& start, const Point& end, const Rect&
             INCREASE_ACC(acc, accTemp, adj, sy, dir);
             sx--;
             if (width == 1) {
-                DrawUtils::GetInstance()->DrawAdjPixelInLine(sx, sy, sx, sy + dir, mask, color, opacity,
-                    acc >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawAdjPixelInLine(gfxDstBuffer, sx, sy, sx, sy + dir, mask,
+                                                             color, opacity, acc >> SHIFT_8);
             } else {
-                DrawUtils::GetInstance()->DrawHorPixelInLine(sx, sy, dir, mask, color, opacity, acc >> SHIFT_8);
+                DrawUtils::GetInstance()->DrawHorPixelInLine(gfxDstBuffer, sx, sy, dir, mask,
+                                                             color, opacity, acc >> SHIFT_8);
             }
         }
     }

frameworks/draw/draw_line.h

@@ -18,21 +18,25 @@
 
 #include "gfx_utils/color.h"
 #include "gfx_utils/geometry2d.h"
+#include "gfx_utils/graphic_buffer.h"
 
 namespace OHOS {
 class DrawLine : public HeapBase {
 public:
-    static void Draw(const Point& start, const Point& end, const Rect& mask,
+    static void Draw(BufferInfo& gfxDstBuffer, const Point& start, const Point& end, const Rect& mask,
         int16_t width, const ColorType& color, OpacityType opacity);
 
 private:
-    static void DrawVerticalLine(const Point& start, const Point& end, const Rect& mask,
-        int16_t width, const ColorType& color, OpacityType opacity);
-    static void DrawHorizontalLine(const Point& start, const Point& end, const Rect& mask,
-        int16_t width, const ColorType& color, OpacityType opacity);
-    static void DrawWuLine(const Point& start, const Point& end, const Rect& mask,
-        int16_t width, const ColorType& color, OpacityType opacity);
-    static void DrawThinWuLine(const Point& start, const Point& end, const Rect& mask,
+    static void DrawVerticalLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end,
+        const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity);
+
+    static void DrawHorizontalLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end,
+        const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity);
+
+    static void DrawWuLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end,
+        const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity);
+
+    static void DrawThinWuLine(BufferInfo& gfxDstBuffer, const Point& start, const Point& end, const Rect& mask,
         int16_t width, const ColorType& color, OpacityType opacity);
 };
 } // namespace OHOS

frameworks/draw/draw_rect.h

@@ -16,7 +16,11 @@
 #ifndef GRAPHIC_LITE_DRAW_RECT_H
 #define GRAPHIC_LITE_DRAW_RECT_H
 
-#include "components/ui_view.h"
+#include "gfx_utils/heap_base.h"
+#include "gfx_utils/rect.h"
+#include "gfx_utils/style.h"
+#include "gfx_utils/color.h"
+#include "gfx_utils/graphic_buffer.h"
 
 namespace OHOS {
 /** @brief Class for drawing rectangle. */
@@ -25,37 +29,48 @@ public:
     DrawRect() {};
     ~DrawRect() {};
 
-    static void Draw(const Rect& rect, const Rect& dirtyRect, const Style& style, OpacityType opaScale);
+    static void Draw(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                     const Style& style, OpacityType opaScale);
 
 private:
-    static void DrawRectRadiusWithoutBorder(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                            OpacityType opaScale);
-    static void DrawRectBorderWithoutRadius(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                            OpacityType opaScale);
-    static void DrawRectRadiusEqualBorder(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                          OpacityType opaScale);
-    static void DrawRectRadiusSmallThanBorder(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                              OpacityType opaScale);
-    static void DrawRectRadiusBiggerThanBorder(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                               OpacityType opaScale);
-
-    static void DrawRectRadiusWithoutBorderCon1(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                OpacityType opaScale);
-    static void DrawRectRadiusWithoutBorderCon2(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                OpacityType opaScale);
-    static void DrawRectRadiusWithoutBorderCon3(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                OpacityType opaScale);
-    static void DrawRectRadiusWithoutBorderCon4(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                OpacityType opaScale);
-
-    static void DrawRectRadiusBiggerThanBorderCon1(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                   OpacityType opaScale);
-    static void DrawRectRadiusBiggerThanBorderCon2(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                   OpacityType opaScale);
-    static void DrawRectRadiusBiggerThanBorderCon3(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                   OpacityType opaScale);
-    static void DrawRectRadiusBiggerThanBorderCon4(const Rect& rect, const Rect& dirtyRect, const Style& style,
-                                                   OpacityType opaScale);
+    static void DrawRectRadiusWithoutBorder(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                            const Style& style, OpacityType opaScale);
+
+    static void DrawRectBorderWithoutRadius(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                            const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusEqualBorder(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                          const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusSmallThanBorder(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                              const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusBiggerThanBorder(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                               const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusWithoutBorderCon1(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusWithoutBorderCon2(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusWithoutBorderCon3(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusWithoutBorderCon4(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusBiggerThanBorderCon1(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                   const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusBiggerThanBorderCon2(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                   const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusBiggerThanBorderCon3(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                   const Style& style, OpacityType opaScale);
+
+    static void DrawRectRadiusBiggerThanBorderCon4(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& dirtyRect,
+                                                   const Style& style, OpacityType opaScale);
 };
 } // namespace OHOS
 #endif // GRAPHIC_LITE_DRAW_RECT_H

frameworks/draw/draw_triangle.cpp

@@ -17,7 +17,12 @@
 #include "draw/draw_utils.h"
 
 namespace OHOS {
-void DrawTriangle::Draw(const Point* points, uint8_t count, const Rect& mask, const ColorType& color, OpacityType opa)
+void DrawTriangle::Draw(BufferInfo& gfxDstBuffer,
+                        const Point* points,
+                        uint8_t count,
+                        const Rect& mask,
+                        const ColorType& color,
+                        OpacityType opa)
 {
     if ((points == nullptr) || (count != VERTEX_NUM)) {
         return;
@@ -55,7 +60,7 @@ void DrawTriangle::Draw(const Point* points, uint8_t count, const Rect& mask, co
         area.SetRight(MATH_MAX(edge1.curPoint.x, edge2.curPoint.x));
         area.SetTop(MATH_MIN(edge1.curPoint.y, edge2.curPoint.y));
         area.SetBottom(MATH_MAX(edge1.curPoint.y, edge2.curPoint.y));
-        DrawUtils::GetInstance()->DrawColorArea(area, mask, color, opa);
+        DrawUtils::GetInstance()->DrawColorArea(gfxDstBuffer, area, mask, color, opa);
 
         while (edge1.curPoint.y == lastY) {
             // use Bresenham algorithm to get next point on edge1

frameworks/draw/draw_triangle.h

@@ -18,11 +18,13 @@
 
 #include "gfx_utils/color.h"
 #include "gfx_utils/geometry2d.h"
+#include "gfx_utils/graphic_buffer.h"
 
 namespace OHOS {
 class DrawTriangle : public HeapBase {
 public:
-    static void Draw(const Point* points, uint8_t count, const Rect& mask, const ColorType& color, OpacityType opa);
+    static void Draw(BufferInfo& gfxDstBuffer, const Point* points, uint8_t count,
+                     const Rect& mask, const ColorType& color, OpacityType opa);
 
     struct Edge {
         Point curPoint;

frameworks/draw/draw_utils.h

@@ -17,9 +17,9 @@
 #define GRAPHIC_LITE_DRAW_UTILS_H
 
 #include "gfx_utils/color.h"
-#include "dock/screen_device_proxy.h"
 #include "common/text.h"
 #include "gfx_utils/geometry2d.h"
+#include "gfx_utils/graphic_buffer.h"
 #include "gfx_utils/graphic_types.h"
 #include "gfx_utils/style.h"
 #include "gfx_utils/transform.h"
@@ -109,13 +109,6 @@ struct TriangleEdge {
     int32_t dv = 0;
     // parameters above are Q15 fixed-point number
 };
-struct TransformDataInfo {
-    ImageHeader header;
-    const uint8_t* data;
-    uint8_t pxSize;
-    BlurLevel blurLevel;
-    TransformAlgorithm algorithm;
-};
 
 struct TriangleTransformDataInfo {
     const TransformDataInfo& info;
@@ -170,16 +163,20 @@ class DrawUtils : public HeapBase {
 public:
     static DrawUtils* GetInstance();
 
-    void DrawColorArea(const Rect& area, const Rect& mask, const ColorType& color, OpacityType opa) const;
+    void DrawColorArea(BufferInfo& gfxDstBuffer, const Rect& area, const Rect& mask,
+                       const ColorType& color, OpacityType opa) const;
 
-    void DrawColorAreaBySides(const Rect& mask, const ColorType& color, OpacityType opa, const EdgeSides& sides) const;
+    void DrawColorAreaBySides(BufferInfo& gfxDstBuffer, const Rect& mask, const ColorType& color,
+                              OpacityType opa, const EdgeSides& sides) const;
 
-    void DrawPixel(int16_t x, int16_t y, const Rect& mask, const ColorType& color, OpacityType opa) const;
+    void DrawPixel(BufferInfo& gfxDstBuffer, int16_t x, int16_t y, const Rect& mask,
+                   const ColorType& color, OpacityType opa) const;
 
-    void DrawLetter(const LabelLetterInfo& letterInfo) const;
+    void DrawLetter(BufferInfo& gfxDstBuffer, const LabelLetterInfo& letterInfo) const;
 
-    void DrawImage(const Rect& area, const Rect& mask, const uint8_t* image, OpacityType opa, uint8_t pxBitSize,
-                    ColorMode colorMode, LutColorMode lutColorMode = LUT_UNKNOW) const;
+    void DrawImage(BufferInfo& gfxDstBuffer, const Rect& area, const Rect& mask,
+                   const uint8_t* image, OpacityType opa, uint8_t pxBitSize,
+                   ColorMode colorMode, LutColorMode lutColorMode = LUT_UNKNOW) const;
 
     static void
         GetXAxisErrForJunctionLine(bool ignoreJunctionPoint, bool isRightPart, int16_t& xMinErr, int16_t& xMaxErr);
@@ -189,23 +186,25 @@ public:
                                       const Rect& trans,
                                       TransformInitState& init);
 
-    static void DrawTriangleTransform(const Rect& mask,
+    static void DrawTriangleTransform(BufferInfo& gfxDstBuffer,
+                                      const Rect& mask,
                                       const Point& position,
                                       const ColorType& color,
                                       OpacityType opaScale,
                                       const TransformMap& transMap,
                                       const TriangleTransformDataInfo& dataInfo);
 
-    void DrawTransform(const Rect& mask,
+    void DrawTransform(BufferInfo& gfxDstBuffer,
+                       const Rect& mask,
                        const Point& position,
                        const ColorType& color,
                        OpacityType opaScale,
                        const TransformMap& transMap,
                        const TransformDataInfo& dataInfo) const;
 
-    void DrawTranspantArea(const Rect& rect, const Rect& mask);
+    void DrawTranspantArea(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& mask);
 
-    void DrawWithBuffer(const Rect& rect, const Rect& mask, const ColorType* colorBuf);
+    void DrawWithBuffer(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& mask, const ColorType* colorBuf);
 
     static uint8_t GetPxSizeByColorMode(uint8_t colorMode);
 
@@ -220,7 +219,8 @@ public:
         return opaMix;
     }
 
-    void DrawAdjPixelInLine(int16_t x1,
+    void DrawAdjPixelInLine(BufferInfo& gfxDstBuffer,
+                            int16_t x1,
                             int16_t y1,
                             int16_t x2,
                             int16_t y2,
@@ -229,10 +229,11 @@ public:
                             OpacityType opa,
                             uint16_t w) const;
 
-    void DrawPixelInLine(int16_t x, int16_t y, const Rect& mask, const ColorType& color, OpacityType opa, uint16_t w)
-        const;
+    void DrawPixelInLine(BufferInfo& gfxDstBuffer, int16_t x, int16_t y, const Rect& mask,
+                         const ColorType& color, OpacityType opa, uint16_t w) const;
 
-    void DrawVerPixelInLine(int16_t x,
+    void DrawVerPixelInLine(BufferInfo& gfxDstBuffer,
+                            int16_t x,
                             int16_t y,
                             int8_t dir,
                             const Rect& mask,
@@ -240,7 +241,8 @@ public:
                             OpacityType opa,
                             uint16_t weight) const;
 
-    void DrawHorPixelInLine(int16_t x,
+    void DrawHorPixelInLine(BufferInfo& gfxDstBuffer,
+                            int16_t x,
                             int16_t y,
                             int8_t dir,
                             const Rect& mask,
@@ -248,47 +250,44 @@ public:
                             OpacityType opa,
                             uint16_t weight) const;
 
-private:
-#if ENABLE_GFX_ENGINES
-    bool FillAreaWithHardware(const Rect& fillArea, const ColorType& color, const OpacityType& opa) const;
-#endif
-    void FillAreaWithSoftWare(const Rect& fillArea,
-                              uint8_t* mem,
-                              ColorMode mode,
-                              uint8_t destByteSize,
-                              int16_t bufWidth,
-                              const ColorType& color,
-                              const OpacityType& opa) const;
-
-    void BlendWithSoftWare(const uint8_t* src,
+    void BlendWithSoftWare(const uint8_t* src1,
+                           const Rect& srcRect,
                            uint32_t srcStride,
+                           uint32_t srcLineNumber,
                            ColorMode srcMode,
-                           uint8_t* dest,
+                           uint32_t color,
+                           OpacityType opa,
+                           uint8_t* dst,
                            uint32_t destStride,
                            ColorMode destMode,
-                           uint32_t width,
-                           uint32_t height,
-                           OpacityType opa) const;
+                           uint32_t x,
+                           uint32_t y) const;
 
-    using DrawTriangleTransformFuc = void (*)(const TriangleScanInfo& triangle);
+    void FillAreaWithSoftWare(BufferInfo& gfxDstBuffer,
+                              const Rect& fillArea,
+                              const ColorType& color,
+                              const OpacityType& opa) const;
+private:
+    using DrawTriangleTransformFuc = void (*)(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
-    static void DrawTriangleTrueColorNearest(const TriangleScanInfo& triangle);
+    static void DrawTriangleTrueColorNearest(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
-    static void DrawTriangleAlphaBilinear(const TriangleScanInfo& triangle);
+    static void DrawTriangleAlphaBilinear(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
-    static void DrawTriangleTrueColorBilinear565(const TriangleScanInfo& triangle);
+    static void DrawTriangleTrueColorBilinear565(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
-    static void DrawTriangleTrueColorBilinear888(const TriangleScanInfo& triangle);
+    static void DrawTriangleTrueColorBilinear888(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
-    static void DrawTriangleTrueColorBilinear8888(const TriangleScanInfo& triangle);
+    static void DrawTriangleTrueColorBilinear8888(const TriangleScanInfo& triangle, const ColorMode bufferMode);
 
     inline static void StepToNextLine(TriangleEdge& edg1, TriangleEdge& edg2);
 
-    static void DrawTriangleTransformPart(const TrianglePartInfo& part);
+    static void DrawTriangleTransformPart(BufferInfo& gfxDstBuffer, const TrianglePartInfo& part);
 
     static OpacityType GetPxAlphaForAlphaImg(const TransformDataInfo& dataInfo, const Point& point);
 
-    void FillArea(const Rect& rect, const Rect& mask, bool isTransparent, const ColorType* colorBuf);
+    void FillArea(BufferInfo& gfxDstBuffer, const Rect& rect, const Rect& mask,
+                  bool isTransparent, const ColorType* colorBuf);
 };
 } // namespace OHOS
 #endif // GRAPHIC_LITE_DRAW_UTILS_H

frameworks/engines/gfx/gfx_engine_manager.cpp

+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "engines/gfx/gfx_engine_manager.h"
+#include "draw/draw_arc.h"
+#include "draw/draw_curve.h"
+#include "draw/draw_line.h"
+#include "draw/draw_rect.h"
+
+namespace OHOS {
+BaseGfxEngine* BaseGfxEngine::baseEngine_ = nullptr;
+void BaseGfxEngine::DrawArc(BufferInfo& dst,
+                            ArcInfo& arcInfo,
+                            const Rect& mask,
+                            const Style& style,
+                            OpacityType opacity,
+                            uint8_t cap)
+{
+    DrawArc::GetInstance()->Draw(dst, arcInfo, mask, style, opacity, cap);
+}
+
+void BaseGfxEngine::DrawLine(BufferInfo& dst,
+                             const Point& start,
+                             const Point& end,
+                             const Rect& mask,
+                             int16_t width,
+                             ColorType color,
+                             OpacityType opacity)
+{
+    DrawLine::Draw(dst, start, end, mask, width, color, opacity);
+}
+
+void BaseGfxEngine::DrawCubicBezier(BufferInfo& dst,
+                                    const Point& start,
+                                    const Point& control1,
+                                    const Point& control2,
+                                    const Point& end,
+                                    const Rect& mask,
+                                    int16_t width,
+                                    ColorType color,
+                                    OpacityType opacity)
+{
+    DrawCurve::DrawCubicBezier(dst, start, control1, control2, end, mask, width, color, opacity);
+}
+
+void BaseGfxEngine::DrawRect(BufferInfo& dst,
+                             const Rect& rect,
+                             const Rect& dirtyRect,
+                             const Style& style,
+                             OpacityType opacity)
+{
+    DrawRect::Draw(dst, rect, dirtyRect, style, opacity);
+}
+
+void BaseGfxEngine::DrawTransform(BufferInfo& dst, 
+                                  const Rect& mask,
+                                  const Point& position,
+                                  ColorType color,
+                                  OpacityType opacity,
+                                  const TransformMap& transMap,
+                                  const TransformDataInfo& dataInfo)
+{
+    DrawUtils::GetInstance()->DrawTransform(dst, mask, position, color,
+        opacity, transMap, dataInfo);
+}
+
+void BaseGfxEngine::Blit(BufferInfo& dst,
+                         const Point& dstPos,
+                         const BufferInfo& src,
+                         const Rect& subRect,
+                         const BlendOption& blendOption)
+{
+    DrawUtils::GetInstance()->BlendWithSoftWare(static_cast<uint8_t*>(src.virAddr), src.rect, src.stride,
+        src.rect.GetHeight(), src.mode, src.color, blendOption.opacity, static_cast<uint8_t*>(dst.virAddr),
+        dst.stride, dst.mode, subRect.GetX(), subRect.GetY());
+}
+
+void BaseGfxEngine::Fill(BufferInfo& dst, const Rect& fillArea, const ColorType color, const OpacityType opacity)
+{
+    uint8_t bufferPxSize = DrawUtils::GetByteSizeByColorMode(dst.mode);
+    DrawUtils::GetInstance()->FillAreaWithSoftWare(dst, fillArea, color, opacity);
+}
+
+uint8_t* BaseGfxEngine::AllocBuffer(uint32_t size, uint32_t usage)
+{
+    return static_cast<uint8_t *>(malloc(size));
+}
+
+void BaseGfxEngine::FreeBuffer(uint8_t* buffer)
+{
+    free(buffer);
+}
+}

frameworks/engines/gfx/hi3516/hi3516_engine.cpp

+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "engines/gfx/hi3516/hi3516_engine.h"
+#include "draw/draw_utils.h"
+#include "hals/gfx_engines.h"
+#include "lite_wm_type.h"
+
+namespace OHOS {
+const int16_t HARDWARE_ACC_SIZE_LIMIT = 50 * 50;
+
+__attribute__((constructor)) void RegisterHi3516GfxEngine()
+{
+    BaseGfxEngine::InitGfxEngine(new Hi3516GfxEngine());
+}
+
+void Hi3516GfxEngine::Fill(BufferInfo& dst,
+                           const Rect& fillArea,
+                           const ColorType color,
+                           const OpacityType opacity)
+{
+#if ENABLE_GFX_ENGINES
+    if ((opacity != OPA_OPAQUE) && (fillArea.GetSize() >= HARDWARE_ACC_SIZE_LIMIT)) {
+        LiteSurfaceData data;
+        data.phyAddr = static_cast<uint8_t *>(dst.phyAddr);
+        data.width = dst.width;
+        data.height = dst.height;
+        data.stride = dst.stride;
+        data.pixelFormat = IMAGE_PIXEL_FORMAT_ARGB8888;
+        if (GfxEngines::GetInstance()->GfxFillArea(data, fillArea, color, opacity)) {
+            return;
+        }
+    }
+#endif
+    BaseGfxEngine::Fill(dst, fillArea, color, opacity);
+}
+}

frameworks/common/ui_font_header.cpp → frameworks/engines/gfx/hi3516/hi3516_engine.h

-/*
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at.
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "font/ui_font.h"
-#include "font/ui_font_header.h"
-
-namespace OHOS {
-UITextLanguageFontParam* GetTextLangFontsTable(uint8_t langFontId)
-{
-    // Need to be implemented
-    return nullptr;
-}
-
-uint8_t GetTotalLangId()
-{
-    // Need to be implemented
-    return 0;
-}
-
-uint8_t GetBitmapFontIdMax()
-{
-    // Need to be implemented
-    return 0;
-}
-
-uint8_t GetTotalFontId()
-{
-    // Need to be implemented
-    return 0xFF;
-}
-
-uint16_t GetTotalTextId()
-{
-    // Need to be implemented
-    return 0;
-}
-
-LangTextParam* GetLangTextDefaultParamTable()
-{
-    // Need to be implemented
-    return nullptr;
-}
-} // namespace OHOS
+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef GRAPHIC_LITE_HI3516_ENGINE_H
+#define GRAPHIC_LITE_HI3516_ENGINE_H
+
+#include "engines/gfx/gfx_engine_manager.h"
+
+namespace OHOS {
+class Hi3516GfxEngine : public BaseGfxEngine {
+public:
+    void Fill(BufferInfo& dst,
+              const Rect& fillArea,
+              const ColorType color,
+              const OpacityType opacity) override;
+};
+}
+
+#endif
\ No newline at end of file

frameworks/font/base_font.cpp

@@ -49,11 +49,11 @@ void BaseFont::SetPsramMemory(uintptr_t psramAddr, uint32_t psramLen)
 
 int8_t BaseFont::GetDefaultParamByLangId(uint8_t langId, LangTextParam** pParam) const
 {
-    if ((langId >= GetTotalLangId()) || (pParam == nullptr)) {
+    if ((langId >= UIFontBuilder::GetInstance()->GetTotalLangId()) || (pParam == nullptr)) {
         return INVALID_RET_VALUE;
     }
 
-    LangTextParam *pTable = GetLangTextDefaultParamTable();
+    LangTextParam *pTable = UIFontBuilder::GetInstance()->GetLangTextDefaultParamTable();
     if (pTable == nullptr) {
         return INVALID_RET_VALUE;
     }

frameworks/font/glyphs_manager.cpp

@@ -14,6 +14,7 @@
  */
 
 #include "font/glyphs_manager.h"
+#include "font/ui_font_builder.h"
 #include "gfx_utils/file.h"
 #include "securec.h"
 
@@ -43,7 +44,7 @@ GlyphsManager::GlyphsManager()
       isFileSet_(false),
       isFontIdSet_(false)
 {
-    fontId_ = GetBitmapFontIdMax();
+    fontId_ = UIFontBuilder::GetInstance()->GetBitmapFontIdMax();
 }
 GlyphsManager::~GlyphsManager() {}
 
@@ -179,7 +180,7 @@ int8_t GlyphsManager::SetFile(int32_t fp, uint32_t start)
     if (strncmp(binHeader_.fontMagic, FONT_MAGIC_NUMBER, FONT_MAGIC_NUM_LEN) != 0) {
         return INVALID_RET_VALUE;
     }
-    if (binHeader_.fontNum > GetBitmapFontIdMax()) {
+    if (binHeader_.fontNum > UIFontBuilder::GetInstance()->GetBitmapFontIdMax()) {
         return INVALID_RET_VALUE;
     }
 
@@ -211,7 +212,7 @@ int8_t GlyphsManager::SetFile(int32_t fp, uint32_t start)
         isFileSet_ = true;
     }
 
-    fontId_ = GetBitmapFontIdMax();
+    fontId_ = UIFontBuilder::GetInstance()->GetBitmapFontIdMax();
     return ret;
 }
 
@@ -221,7 +222,7 @@ int8_t GlyphsManager::SetCurrentFontId(uint8_t fontId)
     if (!isFileSet_) {
         return INVALID_RET_VALUE;
     }
-    if (fontId > GetBitmapFontIdMax()) {
+    if (fontId > UIFontBuilder::GetInstance()->GetBitmapFontIdMax()) {
         return INVALID_RET_VALUE;
     }
     if (fontId_ == fontId) {
@@ -247,7 +248,7 @@ int8_t GlyphsManager::SetCurrentFontId(uint8_t fontId)
     if (!found) {
         isFontIdSet_ = false;
         curFontHeader_ = nullptr;
-        fontId_ = GetBitmapFontIdMax();
+        fontId_ = UIFontBuilder::GetInstance()->GetBitmapFontIdMax();
         return INVALID_RET_VALUE;
     }
 

frameworks/font/ui_font.cpp

@@ -18,7 +18,9 @@
 #include "font/ui_font_cache.h"
 #if ENABLE_VECTOR_FONT
 #include "font/ui_font_vector.h"
-#endif // ENABLE_VECTOR_FONT
+#else
+#include "font/ui_font_bitmap.h"
+#endif
 #include "graphic_config.h"
 #if ENABLE_MULTI_FONT
 #include "font/ui_multi_font_manager.h"
@@ -37,6 +39,11 @@ UIFont* UIFont::GetInstance()
         instance.defaultInstance_ = new UIFontVector();
         instance.instance_ = instance.defaultInstance_;
     }
+#else
+    if (instance.instance_ == nullptr) {
+        instance.defaultInstance_ = new UIFontBitmap();
+        instance.instance_ = instance.defaultInstance_;
+    }
 #endif
     return &instance;
 }

frameworks/font/ui_font_bitmap.cpp

+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "font/ui_font_bitmap.h"
+
+#include "font/ui_font_adaptor.h"
+#include "font/ui_font_builder.h"
+#include "gfx_utils/file.h"
+#include "graphic_config.h"
+#if ENABLE_MULTI_FONT
+#include "font/ui_multi_font_manager.h"
+#endif
+#if ENABLE_SHAPING
+#include "font/ui_text_shaping.h"
+#endif
+
+namespace OHOS {
+UIFontBitmap::UIFontBitmap() : dynamicFont_(), dynamicFontRamUsed_(0), dynamicFontFd_(-1)
+{
+    SetBaseFontId(UIFontBuilder::GetInstance()->GetBitmapFontIdMax());
+    bitmapCache_ = nullptr;
+    bitmapRamUsed_ = FONT_BITMAP_CACHE_SIZE;
+}
+
+UIFontBitmap:: ~UIFontBitmap()
+{
+    if (dynamicFontFd_ >= 0) {
+        close(dynamicFontFd_);
+    }
+    if (bitmapCache_ != nullptr) {
+        delete bitmapCache_;
+        bitmapCache_ = nullptr;
+    }
+}
+
+bool UIFontBitmap::IsVectorFont() const
+{
+    return false;
+}
+
+uint8_t UIFontBitmap::GetShapingFontId(char* text, uint8_t& ttfId, uint32_t& script, uint8_t fontId, uint8_t size) const
+{
+#if ENABLE_MULTI_FONT
+    return UIMultiFontManager::GetInstance()->GetShapingFontId(text, fontId, ttfId, script);
+#else
+    UITextLanguageFontParam* fontParam = UIFontBuilder::GetInstance()->GetTextLangFontsTable(fontId);
+    if (fontParam == nullptr) {
+        return 0;
+    }
+    ttfId = fontParam->ttfId;
+    return fontParam->shaping;
+#endif
+}
+
+uint8_t UIFontBitmap::GetFontWeight(uint8_t fontId)
+{
+    UITextLanguageFontParam* fontParam = UIFontBuilder::GetInstance()->GetTextLangFontsTable(fontId);
+    if (fontParam == nullptr) {
+        return 0;
+    }
+    return fontParam->fontWeight;
+}
+
+int8_t UIFontBitmap::SetFontPath(const char* dpath, const char* spath)
+{
+    if (dpath == nullptr) {
+        return INVALID_RET_VALUE;
+    }
+#ifdef _WIN32
+    dynamicFontFd_ = open(dpath, O_RDONLY | O_BINARY);
+#else 
+    dynamicFontFd_ = open(dpath, O_RDONLY);
+#endif
+    if (dynamicFontFd_ < 0) {
+        return INVALID_RET_VALUE;
+    }
+    dynamicFont_.SetRamBuffer(GetRamAddr());
+    uint32_t start = 0;
+    int32_t ret = dynamicFont_.SetFile(dynamicFontFd_, start);
+    if (ret == INVALID_RET_VALUE) {
+        close(dynamicFontFd_);
+        dynamicFontFd_ = -1;
+        return ret;
+    }
+    dynamicFontRamUsed_ = dynamicFont_.GetRamUsedLen();
+    return RET_VALUE_OK;
+}
+
+int8_t UIFontBitmap::SetCurrentFontId(uint8_t fontId, uint8_t size)
+{
+    int8_t ret = SetDynamicFontId(fontId);
+    if (ret == RET_VALUE_OK) {
+        SetBaseFontId(fontId);
+    }
+    return ret;
+}
+
+uint16_t UIFontBitmap::GetHeight()
+{
+    int16_t ret = dynamicFont_.SetCurrentFontId(GetBaseFontId());
+    if (ret == INVALID_RET_VALUE) {
+        return ret;
+    }
+    return dynamicFont_.GetFontHeight();
+}
+
+uint8_t UIFontBitmap::GetFontId(const char* ttfName, uint8_t size) const
+{
+    if (ttfName == nullptr) {
+        return UIFontBuilder::GetInstance()->GetBitmapFontIdMax();
+    }
+    uint8_t id;
+    for (id = 0; id < UIFontBuilder::GetInstance()->GetBitmapFontIdMax(); ++id) {
+        UITextLanguageFontParam* fontParam = UIFontBuilder::GetInstance()->GetTextLangFontsTable(id);
+        if (fontParam != nullptr) {
+            if ((fontParam->size == size) && (strncmp(fontParam->ttfName, ttfName, TTF_NAME_LEN_MAX) == 0)) {
+                break;
+            }
+        }
+    }
+    return id;
+}
+
+int16_t UIFontBitmap::GetWidth(uint32_t unicode, uint8_t fontId)
+{
+    return GetWidthInFontId(unicode, fontId);
+}
+
+uint8_t* UIFontBitmap::GetBitmap(uint32_t unicode, GlyphNode& glyphNode, uint8_t fontId)
+{
+    return SearchInFont(unicode, glyphNode, fontId);
+}
+
+int8_t UIFontBitmap::GetCurrentFontHeader(FontHeader& fontHeader)
+{
+    int8_t ret = dynamicFont_.SetCurrentFontId(GetBaseFontId());
+    if (ret == INVALID_RET_VALUE) {
+        return ret;
+    }
+    const FontHeader* header = dynamicFont_.GetCurrentFontHeader();
+    if (header != nullptr) {
+        fontHeader = *header;
+        return RET_VALUE_OK;
+    }
+    return INVALID_RET_VALUE;
+}
+
+int8_t UIFontBitmap::GetGlyphNode(uint32_t unicode, GlyphNode& glyphNode)
+{
+    int8_t ret = dynamicFont_.SetCurrentFontId(GetBaseFontId());
+    if (ret == INVALID_RET_VALUE) {
+        return ret;
+    }
+    const GlyphNode* node = dynamicFont_.GetGlyphNode(unicode);
+    if (node != nullptr) {
+        glyphNode = *node;
+        return RET_VALUE_OK;
+    }
+    return INVALID_RET_VALUE;
+}
+
+int8_t UIFontBitmap::GetFontVersion(char* dVersion, uint8_t dLen, char* sVersion, uint8_t sLen) const
+{
+    return dynamicFont_.GetFontVersion(dVersion, dLen);
+}
+
+int8_t UIFontBitmap::SetCurrentLangId(uint8_t langId)
+{
+    if (bitmapCache_ == nullptr) {
+        uint8_t* bitmapCacheAddr = reinterpret_cast<uint8_t*>(GetRamAddr() + dynamicFontRamUsed_);
+        bitmapCache_ = new UIFontCache(bitmapCacheAddr, bitmapRamUsed_);
+    }
+    uint32_t total = dynamicFontRamUsed_ + bitmapRamUsed_;
+    return (total <= GetRamLen()) ? RET_VALUE_OK : INVALID_RET_VALUE;
+}
+
+UITextLanguageFontParam* UIFontBitmap::GetFontInfo(uint8_t fontId) const
+{
+    return UIFontBuilder::GetInstance()->GetTextLangFontsTable(fontId);
+}
+
+
+uint32_t UIFontBitmap::GetBitmapRamUsed()
+{
+    return bitmapRamUsed_;
+}
+
+uint32_t UIFontBitmap::GetDynamicFontRamUsed()
+{
+    return dynamicFontRamUsed_;
+}
+
+uint32_t UIFontBitmap::GetRamUsedLen(uint32_t textManagerRamUsed, uint32_t langFontRamUsed)
+{
+    if (bitmapCache_ == nullptr) {
+        uint8_t* bitmapCacheAddr = reinterpret_cast<uint8_t*>(GetRamAddr() + dynamicFontRamUsed_ + textManagerRamUsed);
+        bitmapCache_ = new UIFontCache(bitmapCacheAddr, bitmapRamUsed_);
+    }
+    return dynamicFontRamUsed_ + textManagerRamUsed + bitmapRamUsed_ + langFontRamUsed;
+}
+
+int8_t UIFontBitmap::GetDynamicFotBitmap(uint32_t unicode, uint8_t* bitmap)
+{
+    return dynamicFont_.GetBitmap(unicode, bitmap);
+}
+
+uint8_t* UIFontBitmap::GetCacheBitmap(uint8_t fontId, uint32_t unicode)
+{
+    if (bitmapCache_ != nullptr) {
+        return bitmapCache_->GetBitmap(fontId, unicode);
+    }
+    return nullptr;
+}
+
+uint8_t* UIFontBitmap::GetCacheSpace(uint8_t fontId, uint32_t unicode, uint32_t size)
+{
+    if (bitmapCache_ != nullptr) {
+        return bitmapCache_->GetSpace(fontId, unicode, size);
+    }
+    return nullptr;
+}
+
+void UIFontBitmap::PutCacheSpace(uint8_t* addr)
+{
+    if (bitmapCache_ != nullptr) {
+        bitmapCache_->PutSpace(addr);
+    }
+}
+
+int8_t UIFontBitmap::SetDynamicFontId(uint8_t fontId)
+{
+    return dynamicFont_.SetCurrentFontId(fontId);
+}
+
+int16_t UIFontBitmap::GetDynamicFontWidth(uint32_t unicode, uint8_t fontId)
+{
+    int16_t ret = dynamicFont_.SetCurrentFontId(fontId);
+    if (ret == INVALID_RET_VALUE) {
+        return ret;
+    }
+    return dynamicFont_.GetFontWidth(unicode);
+}
+
+uint8_t* UIFontBitmap::SearchInFont(uint32_t unicode, GlyphNode& glyphNode, uint8_t fontId)
+{
+    if (!UIFontAdaptor::IsSameTTFId(fontId, unicode)) {
+        return nullptr;
+    }
+    if (fontId != GetBaseFontId()) {
+        SetCurrentFontId(fontId);
+    }
+    if (bitmapCache_ == nullptr) {
+        return nullptr;
+    }
+    uint8_t* bitmap = bitmapCache_->GetBitmap(GetBaseFontId(), unicode);
+    if (bitmap != nullptr) {
+        GetGlyphNode(unicode, glyphNode);
+        return bitmap;
+    }
+
+    int8_t ret = GetGlyphNode(unicode, glyphNode);
+    if (ret != RET_VALUE_OK) {
+        return nullptr;
+    }
+
+    if (glyphNode.kernOff <= glyphNode.dataOff) {
+        return nullptr;
+    }
+    uint32_t bitmapSize = glyphNode.kernOff - glyphNode.dataOff;
+    bitmap = bitmapCache_->GetSpace(GetBaseFontId(), unicode, bitmapSize);
+    ret = dynamicFont_.GetBitmap(unicode, bitmap);
+    if (ret == RET_VALUE_OK) {
+        return bitmap;
+    }
+    bitmapCache_->PutSpace(bitmap);
+    return nullptr;
+}
+
+int16_t UIFontBitmap::GetWidthInFontId(uint32_t unicode, uint8_t fontId)
+{
+    if (!UIFontAdaptor::IsSameTTFId(fontId, unicode)) {
+        return INVALID_RET_VALUE;
+    }
+    if (fontId != GetBaseFontId()) {
+        SetCurrentFontId(fontId);
+    }
+    return GetDynamicFontWidth(unicode, GetBaseFontId());
+}
+} // namespace

frameworks/font/ui_line_break.cpp

@@ -65,7 +65,7 @@ uint16_t UILineBreakEngine::GetNextBreakPos(UILineBreakProxy& record)
             category &= ~0x4000;
         }
         state = row->fNextState[category];
-        row = reinterpret_cast<const RBBIStateTableRow*>( rbbStateTable->fTableData + rbbStateTable->fRowLen * state);
+        row = reinterpret_cast<const RBBIStateTableRow*>(rbbStateTable->fTableData + rbbStateTable->fRowLen * state);
         int16_t completedRule = row->fAccepting;
         if ((completedRule > 0) || (state == LINE_BREAK_STATE_STOP)) {
             return index;

frameworks/font/ui_multi_font_manager.cpp

@@ -30,7 +30,7 @@ UIMultiFontManager::UIMultiFontManager()
       bengaliTtfId_(0), topIndex_(0)
 {
     const UITextLanguageFontParam* fontParam = nullptr;
-    uint8_t totalFontId = GetTotalFontId();
+    uint8_t totalFontId = UIFontBuilder::GetInstance()->GetTotalFontId();
     for (uint8_t i = 0; i < totalFontId; i++) {
         fontParam = UIFont::GetInstance()->GetFontInfo(i);
         if (fontParam == nullptr) {
@@ -127,7 +127,7 @@ UIMultiFontManager* UIMultiFontManager::GetInstance()
 
 void UIMultiFontManager::ClearSearchFontList()
 {
-    uint8_t totalFontId = GetTotalFontId();
+    uint8_t totalFontId = UIFontBuilder::GetInstance()->GetTotalFontId();
     for (uint8_t index = 0; index < totalFontId; index++) {
         fontIdIndex_[index] = MAX_LIST_NUM;
     }
@@ -142,7 +142,7 @@ void UIMultiFontManager::ClearSearchFontList()
 
 int8_t UIMultiFontManager::SetSearchFontList(uint8_t fontListId, uint8_t *fontIds, uint8_t size)
 {
-    if ((fontListId >= GetTotalFontId()) || (fontIds == nullptr) || (size == 0) ||
+    if ((fontListId >= UIFontBuilder::GetInstance()->GetTotalFontId()) || (fontIds == nullptr) || (size == 0) ||
         (fontIdIndex_ == nullptr) || (topIndex_ >= MAX_LIST_NUM)) {
         return INVALID_RET_VALUE;
     }
@@ -152,7 +152,7 @@ int8_t UIMultiFontManager::SetSearchFontList(uint8_t fontListId, uint8_t *fontId
 
 int8_t UIMultiFontManager::GetSearchFontList(uint8_t fontListId, uint8_t **fontIds)
 {
-    if ((fontListId >= GetTotalFontId()) || (fontIds == nullptr) ||
+    if ((fontListId >= UIFontBuilder::GetInstance()->GetTotalFontId()) || (fontIds == nullptr) ||
         (fontIdIndex_ == nullptr) || (fontIdIndex_[fontListId] >= MAX_LIST_NUM)) {
         return INVALID_RET_VALUE;
     }

frameworks/window/window_impl.h

@@ -16,10 +16,10 @@
 #ifndef GRAPHIC_LITE_WINDOW_IMPL_H
 #define GRAPHIC_LITE_WINDOW_IMPL_H
 
-#include "iwindow.h"
 #include "components/root_view.h"
+#include "engines/gfx/gfx_engine_manager.h"
+#include "iwindow.h"
 #include "window/window.h"
-#include "dock/screen_device.h"
 
 namespace OHOS {
 class WindowImpl : public Window {
@@ -49,9 +49,18 @@ public:
     void AddToDisplay();
     void RemoveFromDisplay();
 
+    BufferInfo* GetBufferInfo();
 private:
     void UpdateHalDisplayBuffer();
 
+    struct AllocationInfo {
+        uint8_t* virAddr;
+        uint8_t* phyAddr;
+        uint16_t width;
+        uint16_t height;
+        uint32_t stride;
+        ImagePixelFormat pixelFormat;
+    };
     RootView* rootView_;
     IWindow* iWindow_;
     WindowConfig config_;