diff --git a/frameworks/core/components_ng/pattern/BUILD.gn b/frameworks/core/components_ng/pattern/BUILD.gn
index 6abe246273c5f3961edee3463ccca1356a1ed8d6..fc6b38a55b39369796e88734a3817c45cc4aa4ef 100644
--- a/frameworks/core/components_ng/pattern/BUILD.gn
+++ b/frameworks/core/components_ng/pattern/BUILD.gn
@@ -231,6 +231,7 @@ build_component_ng("pattern_ng") {
     "list/list_position_map.cpp",
     "loading_progress/loading_progress_layout_algorithm.cpp",
     "loading_progress/loading_progress_model_ng.cpp",
+    "loading_progress/loading_progress_model_static.cpp",
     "loading_progress/loading_progress_modifier.cpp",
     "loading_progress/loading_progress_pattern.cpp",
     "marquee/marquee_accessibility_property.cpp",
@@ -349,6 +350,7 @@ build_component_ng("pattern_ng") {
     "progress/progress_accessibility_property.cpp",
     "progress/progress_layout_algorithm.cpp",
     "progress/progress_model_ng.cpp",
+    "progress/progress_model_static.cpp",
     "progress/progress_modifier.cpp",
     "progress/progress_paint_method.cpp",
     "progress/progress_paint_property.cpp",
diff --git a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.cpp b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.cpp
index 85a59f455494f2665d7342ea10f005bbdc6c31d3..941c68a8dbf0ac70812e5d434da8d696807b1792 100644
--- a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.cpp
+++ b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.cpp
@@ -99,16 +99,11 @@ uint32_t LoadingProgressModelNG::GetColor(FrameNode* frameNode)
     return value.GetValue();
 }
 
-void LoadingProgressModelNG::SetColor(FrameNode* frameNode, const std::optional<Color>& valueOpt)
-{
-    if (valueOpt) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, Color, valueOpt.value(), frameNode);
-        ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColor, valueOpt.value(), frameNode);
-        ACE_UPDATE_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, ColorSetByUser, true, frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, Color, frameNode);
-        ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColor, frameNode);
-    }
+void LoadingProgressModelNG::SetColor(FrameNode* frameNode, const Color& value)
+{
+    ACE_UPDATE_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, Color, value, frameNode);
+    ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColor, value, frameNode);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, ColorSetByUser, true, frameNode);
     ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColorStrategy, frameNode);
     ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColorFlag, true, frameNode);
 }
@@ -121,8 +116,8 @@ void LoadingProgressModelNG::SetColorByUser(FrameNode* frameNode, bool isSetByUs
 bool LoadingProgressModelNG::GetEnableLoading(FrameNode* frameNode)
 {
     bool enable = true;
-    ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(LoadingProgressPaintProperty,
-        EnableLoading, enable, frameNode, enable);
+    ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
+        LoadingProgressPaintProperty, EnableLoading, enable, frameNode, enable);
     return enable;
 }
 
diff --git a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.h b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.h
index 6b6adf1d30bbaea1a827e93db2b406b8ae4e626a..b4d31a860c6010d11497dd7f104972c077dd9faf 100644
--- a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.h
+++ b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.h
@@ -17,8 +17,8 @@
 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_LOADING_PROGRESS_LOADING_PROGRESS_MODEL_NG_H
 
 #include "core/components_ng/base/common_configuration.h"
-#include "core/components_ng/base/view_abstract.h"
 #include "core/components_ng/base/frame_node.h"
+#include "core/components_ng/base/view_abstract.h"
 #include "core/components_ng/pattern/loading_progress/loading_progress_model.h"
 
 namespace OHOS::Ace::NG {
@@ -44,7 +44,7 @@ public:
 
     static RefPtr<FrameNode> CreateFrameNode(int32_t nodeId);
     static uint32_t GetColor(FrameNode* frameNode);
-    static void SetColor(FrameNode* frameNode, const std::optional<Color>& valueOpt);
+    static void SetColor(FrameNode* frameNode, const Color& value);
     static void SetColorByUser(FrameNode* frameNode, bool isSetByUser);
     static bool GetEnableLoading(FrameNode* frameNode);
     static void SetEnableLoading(FrameNode* frameNode, bool enable);
diff --git a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.cpp b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23841882b20cfe4e8caf7185bbc8bdd801df3891
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 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 "core/components_ng/pattern/loading_progress/loading_progress_model_static.h"
+
+#include "core/components_ng/pattern/loading_progress/loading_progress_pattern.h"
+
+namespace OHOS::Ace::NG {
+void LoadingProgressModelStatic::SetColor(FrameNode* frameNode, const std::optional<Color>& valueOpt)
+{
+    if (valueOpt) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, Color, valueOpt.value(), frameNode);
+        ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColor, valueOpt.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(LoadingProgressPaintProperty, Color, frameNode);
+        ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColor, frameNode);
+    }
+    ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColorStrategy, frameNode);
+    ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColorFlag, true, frameNode);
+}
+} // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.h b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.h
new file mode 100644
index 0000000000000000000000000000000000000000..9000eadd094082ca0815792dd582d273e5d633cf
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025 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 FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_LOADING_PROGRESS_LOADING_PROGRESS_MODEL_STATIC_H
+#define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_LOADING_PROGRESS_LOADING_PROGRESS_MODEL_STATIC_H
+
+#include "core/components_ng/base/common_configuration.h"
+#include "core/components_ng/base/frame_node.h"
+#include "core/components_ng/base/view_abstract.h"
+#include "core/components_ng/pattern/loading_progress/loading_progress_model.h"
+
+namespace OHOS::Ace::NG {
+class ACE_EXPORT LoadingProgressModelStatic {
+public:
+    static void SetColor(FrameNode* frameNode, const std::optional<Color>& valueOpt);
+};
+
+} // namespace OHOS::Ace::NG
+#endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_LOADING_PROGRESS_LOADING_PROGRESS_MODEL_STATIC_H
diff --git a/frameworks/core/components_ng/pattern/progress/progress_model_ng.cpp b/frameworks/core/components_ng/pattern/progress/progress_model_ng.cpp
index 203a2814bb2524eadb09e0f2b08269223bd15970..be216514e93190a2b93585e4404e3f8ba401fc8a 100644
--- a/frameworks/core/components_ng/pattern/progress/progress_model_ng.cpp
+++ b/frameworks/core/components_ng/pattern/progress/progress_model_ng.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2025 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
@@ -28,8 +28,6 @@
 #include "core/components_ng/pattern/text/text_pattern.h"
 #include "core/components_v2/inspector/inspector_constants.h"
 namespace OHOS::Ace::NG {
-constexpr double DEFAULT_MAX_VALUE = 100.0;
-
 void ProgressModelNG::Create(double min, double value, double cachedValue, double max, NG::ProgressType type)
 {
     auto* stack = ViewStackProcessor::GetInstance();
@@ -40,11 +38,10 @@ void ProgressModelNG::Create(double min, double value, double cachedValue, doubl
     stack->Push(frameNode);
 
     ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, Value, value);
-    frameNode->OnAccessibilityEvent(AccessibilityEventType::COMPONENT_CHANGE);
     ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, MaxValue, max);
     ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, ProgressType, type);
     ACE_UPDATE_LAYOUT_PROPERTY(ProgressLayoutProperty, Type, type);
-    auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck();
+    auto pipeline = PipelineBase::GetCurrentContext();
     CHECK_NULL_VOID(pipeline);
     if (Container::LessThanAPIVersion(PlatformVersion::VERSION_TEN)) {
         return;
@@ -57,6 +54,8 @@ void ProgressModelNG::Create(double min, double value, double cachedValue, doubl
         progressFocusNode->SetFocusable(false);
     }
 
+    RefPtr<ProgressTheme> theme = pipeline->GetTheme<ProgressTheme>(frameNode->GetThemeScopeId());
+    CHECK_NULL_VOID(theme);
     auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeInputEventHub();
     CHECK_NULL_VOID(eventHub);
     auto pattern = frameNode->GetPattern<ProgressPattern>();
@@ -93,9 +92,11 @@ RefPtr<FrameNode> ProgressModelNG::CreateFrameNode(int32_t nodeId, double value,
     auto frameNode = FrameNode::CreateFrameNode(V2::PROGRESS_ETS_TAG, nodeId, AceType::MakeRefPtr<ProgressPattern>());
     CHECK_NULL_RETURN(frameNode, nullptr);
     auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
-    ProgressModelNG::SetTotal(frameNode.GetRawPtr(), max);
-    ProgressModelNG::SetValue(frameNode.GetRawPtr(), value);
-    ProgressModelNG::SetType(frameNode.GetRawPtr(), type);
+    progressPaintProperty->UpdateValue(value);
+    progressPaintProperty->UpdateMaxValue(max);
+    progressPaintProperty->UpdateProgressType(type);
+    auto progressLayoutProperty = frameNode->GetLayoutProperty<NG::ProgressLayoutProperty>();
+    progressLayoutProperty->UpdateType(type);
     return frameNode;
 }
 
@@ -184,12 +185,7 @@ void ProgressModelNG::SetScaleWidth(const Dimension& value)
 
 void ProgressModelNG::SetBorderColor(const Color& value)
 {
-    auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
-    CHECK_NULL_VOID(frameNode);
-    auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
-    CHECK_NULL_VOID(progressPaintProperty);
-    auto progressType = progressPaintProperty->GetProgressTypeValue(ProgressType::LINEAR);
-    if (progressType == ProgressType::CAPSULE) {
+    if (isCapsule()) {
         ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, value);
     }
 }
@@ -325,7 +321,7 @@ void ProgressModelNG::SetItalicFontStyle(const Ace::FontStyle& value)
 
 void ProgressModelNG::SetTextDefaultStyle(const RefPtr<FrameNode>& textNode, double value, double maxValue)
 {
-    auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck();
+    auto pipeline = PipelineBase::GetCurrentContext();
     CHECK_NULL_VOID(pipeline);
     auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
     CHECK_NULL_VOID(frameNode);
@@ -334,7 +330,7 @@ void ProgressModelNG::SetTextDefaultStyle(const RefPtr<FrameNode>& textNode, dou
     auto renderContext = textNode->GetRenderContext();
     CHECK_NULL_VOID(renderContext);
     renderContext->UpdateClipEdge(false);
-    RefPtr<ProgressTheme> progressTheme = pipeline->GetTheme<ProgressTheme>();
+    RefPtr<ProgressTheme> progressTheme = pipeline->GetTheme<ProgressTheme>(frameNode->GetThemeScopeId());
     CHECK_NULL_VOID(progressTheme);
     auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
     CHECK_NULL_VOID(progressPaintProperty);
@@ -406,9 +402,6 @@ void ProgressModelNG::ResetStrokeRadius()
 
 void ProgressModelNG::SetValue(FrameNode* frameNode, double value)
 {
-    if (value < 0) {
-        value = 0;
-    }
     auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
     CHECK_NULL_VOID(progressPaintProperty);
     auto maxValue = progressPaintProperty->GetMaxValue();
@@ -432,174 +425,82 @@ void ProgressModelNG::SetTotal(FrameNode* frameNode, double max)
 
 void ProgressModelNG::SetType(FrameNode* frameNode, NG::ProgressType type)
 {
-    CHECK_NULL_VOID(frameNode);
     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressType, type, frameNode);
     ACE_UPDATE_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, Type, type, frameNode);
-
-    auto progressFocusNode = frameNode->GetFocusHub();
-    CHECK_NULL_VOID(progressFocusNode);
-    if (type == ProgressType::CAPSULE) {
-        progressFocusNode->SetFocusable(true);
-    } else {
-        progressFocusNode->SetFocusable(false);
-    }
-
-    auto eventHub = frameNode->GetOrCreateInputEventHub();
-    CHECK_NULL_VOID(eventHub);
-    auto pattern = frameNode->GetPattern<ProgressPattern>();
-    CHECK_NULL_VOID(pattern);
-    if (type == ProgressType::CAPSULE) {
-        if (frameNode->GetChildren().empty()) {
-            auto textNode = FrameNode::CreateFrameNode(
-                V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
-            textNode->SetInternal();
-            textNode->MountToParent(Referenced::Claim(frameNode));
-        }
-        auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
-        CHECK_NULL_VOID(textHost);
-        auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
-        CHECK_NULL_VOID(progressPaintProperty);
-        auto max = progressPaintProperty->GetMaxValue();
-        auto value = progressPaintProperty->GetValue();
-        SetTextDefaultStyle(textHost, value.value_or(0), max.value_or(DEFAULT_MAX_VALUE));
-        textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
-        eventHub->SetHoverEffect(HoverEffectType::SCALE);
-    } else {
-        if (!frameNode->GetChildren().empty()) {
-            frameNode->RemoveChildAtIndex(0);
-        }
-        eventHub->SetHoverEffect(HoverEffectType::NONE);
-    }
 }
 
-void ProgressModelNG::SetColor(FrameNode* frameNode, const std::optional<Color>& value)
+void ProgressModelNG::SetColor(FrameNode* frameNode, const Color& value)
 {
     CHECK_NULL_VOID(frameNode);
     auto pattern = frameNode->GetPattern<ProgressPattern>();
     CHECK_NULL_VOID(pattern);
     pattern->SetUserInitiatedColor(true);
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Color, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, Color, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Color, value, frameNode);
 }
 
-void ProgressModelNG::SetGradientColor(FrameNode* frameNode, const std::optional<Gradient>& value)
+void ProgressModelNG::SetGradientColor(FrameNode* frameNode, const Gradient& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, GradientColor, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, GradientColor, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, GradientColor, value, frameNode);
 }
 
-void ProgressModelNG::SetSmoothEffect(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetSmoothEffect(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableSmoothEffect, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableSmoothEffect, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableSmoothEffect, value, frameNode);
 }
 
-void ProgressModelNG::SetStrokeWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+void ProgressModelNG::SetStrokeWidth(FrameNode* frameNode, const Dimension& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, StrokeWidth, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, StrokeWidth, frameNode);
-    }
+    ACE_UPDATE_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, StrokeWidth, value, frameNode);
 }
 
-void ProgressModelNG::SetLinearSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetLinearSweepingEffect(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableLinearScanEffect, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableLinearScanEffect, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableLinearScanEffect, value, frameNode);
 }
 
-void ProgressModelNG::SetRingSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetRingSweepingEffect(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableRingScanEffect, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableRingScanEffect, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableRingScanEffect, value, frameNode);
 }
 
-void ProgressModelNG::SetPaintShadow(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetPaintShadow(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, PaintShadow, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, PaintShadow, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, PaintShadow, value, frameNode);
 }
 
-void ProgressModelNG::SetProgressStatus(FrameNode* frameNode, const std::optional<ProgressStatus>& status)
+void ProgressModelNG::SetProgressStatus(FrameNode* frameNode, ProgressStatus status)
 {
-    if (status) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressStatus, status.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressStatus, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressStatus, status, frameNode);
 }
 
-void ProgressModelNG::SetScaleCount(FrameNode* frameNode, const std::optional<int32_t>& value)
+void ProgressModelNG::SetScaleCount(FrameNode* frameNode, int32_t value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleCount, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleCount, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleCount, value, frameNode);
 }
 
-void ProgressModelNG::SetScaleWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+void ProgressModelNG::SetScaleWidth(FrameNode* frameNode, const Dimension& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleWidth, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleWidth, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleWidth, value, frameNode);
 }
 
-void ProgressModelNG::SetBorderWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+void ProgressModelNG::SetBorderWidth(FrameNode* frameNode, const Dimension& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderWidth, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderWidth, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderWidth, value, frameNode);
 }
 
-void ProgressModelNG::SetBorderColor(FrameNode* frameNode, const std::optional<Color>& value)
+void ProgressModelNG::SetBorderColor(FrameNode* frameNode, const Color& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, value, frameNode);
 }
 
-void ProgressModelNG::SetSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetSweepingEffect(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableScanEffect, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableScanEffect, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableScanEffect, value, frameNode);
 }
 
-void ProgressModelNG::SetShowText(FrameNode* frameNode, const std::optional<bool>& value)
+void ProgressModelNG::SetShowText(FrameNode* frameNode, bool value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableShowText, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableShowText, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableShowText, value, frameNode);
 }
 
 void ProgressModelNG::SetText(FrameNode* frameNode, const std::optional<std::string>& value)
@@ -636,93 +537,64 @@ void ProgressModelNG::SetText(FrameNode* frameNode, const std::optional<std::str
     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Text, context, frameNode);
 }
 
-void ProgressModelNG::SetFontColor(FrameNode* frameNode, const std::optional<Color>& value)
+void ProgressModelNG::SetFontColor(FrameNode* frameNode, const Color& value)
 {
     auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
     CHECK_NULL_VOID(textHost);
     auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
     CHECK_NULL_VOID(textLayoutProperty);
-    if (value) {
-        textLayoutProperty->UpdateTextColor(value.value());
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextColor, value.value(), frameNode);
-    } else {
-        textLayoutProperty->ResetTextColor();
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextColor, frameNode);
-    }
+    textLayoutProperty->UpdateTextColor(value);
     textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextColor, value, frameNode);
 }
 
-void ProgressModelNG::SetFontSize(FrameNode* frameNode, const std::optional<Dimension>& value)
+void ProgressModelNG::SetFontSize(FrameNode* frameNode, const Dimension& value)
 {
     auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
     CHECK_NULL_VOID(textHost);
     auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
     CHECK_NULL_VOID(textLayoutProperty);
-    if (value) {
-        textLayoutProperty->UpdateFontSize(value.value());
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextSize, value.value(), frameNode);
-    } else {
-        textLayoutProperty->ResetFontSize();
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextSize, frameNode);
-    }
+    textLayoutProperty->UpdateFontSize(value);
     textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextSize, value, frameNode);
 }
 
-void ProgressModelNG::SetFontWeight(FrameNode* frameNode, const std::optional<FontWeight>& value)
+void ProgressModelNG::SetFontWeight(FrameNode* frameNode, const FontWeight& value)
 {
     auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
     CHECK_NULL_VOID(textHost);
     auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
     CHECK_NULL_VOID(textLayoutProperty);
-    if (value) {
-        textLayoutProperty->UpdateFontWeight(value.value());
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontWeight, value.value(), frameNode);
-    } else {
-        textLayoutProperty->ResetFontWeight();
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontWeight, frameNode);
-    }
+    textLayoutProperty->UpdateFontWeight(value);
     textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontWeight, value, frameNode);
 }
 
-void ProgressModelNG::SetFontFamily(FrameNode* frameNode, const std::optional<std::vector<std::string>>& value)
+void ProgressModelNG::SetFontFamily(FrameNode* frameNode, const std::vector<std::string>& value)
 {
     auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
     CHECK_NULL_VOID(textHost);
     auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
     CHECK_NULL_VOID(textLayoutProperty);
-    if (value) {
-        textLayoutProperty->UpdateFontFamily(value.value());
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontFamily, value.value(), frameNode);
-    } else {
-        textLayoutProperty->ResetFontFamily();
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontFamily, frameNode);
-    }
+    textLayoutProperty->UpdateFontFamily(value);
     textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontFamily, value, frameNode);
 }
 
-void ProgressModelNG::SetItalicFontStyle(FrameNode* frameNode, const std::optional<Ace::FontStyle>& value)
+void ProgressModelNG::SetItalicFontStyle(FrameNode* frameNode, const Ace::FontStyle& value)
 {
     auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
     CHECK_NULL_VOID(textHost);
     auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
     CHECK_NULL_VOID(textLayoutProperty);
-    if (value) {
-        textLayoutProperty->UpdateItalicFontStyle(value.value());
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ItalicFontStyle, value.value(), frameNode);
-    } else {
-        textLayoutProperty->ResetItalicFontStyle();
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ItalicFontStyle, frameNode);
-    }
+    textLayoutProperty->UpdateItalicFontStyle(value);
     textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ItalicFontStyle, value, frameNode);
 }
 
-void ProgressModelNG::SetStrokeRadius(FrameNode* frameNode, const std::optional<Dimension>& value)
+void ProgressModelNG::SetStrokeRadius(FrameNode* frameNode, const Dimension& value)
 {
-    if (value) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, StrokeRadius, value.value(), frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, StrokeRadius, frameNode);
-    }
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, StrokeRadius, value, frameNode);
 }
 
 void ProgressModelNG::ResetStrokeRadius(FrameNode* frameNode)
@@ -781,16 +653,15 @@ void ProgressModelNG::ProgressInitialize(
     CHECK_NULL_VOID(pattern);
 
     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Value, value, frameNode);
-    frameNode->OnAccessibilityEvent(AccessibilityEventType::COMPONENT_CHANGE);
     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, MaxValue, max, frameNode);
     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressType, type, frameNode);
     ACE_UPDATE_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, Type, type, frameNode);
-    auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck();
+    auto pipeline = PipelineBase::GetCurrentContext();
     CHECK_NULL_VOID(pipeline);
     if (Container::LessThanAPIVersion(PlatformVersion::VERSION_TEN)) {
         return;
     }
-    RefPtr<ProgressTheme> theme = pipeline->GetTheme<ProgressTheme>();
+    RefPtr<ProgressTheme> theme = pipeline->GetTheme<ProgressTheme>(frameNode->GetThemeScopeId());
     auto progressFocusNode = frameNode->GetFocusHub();
     CHECK_NULL_VOID(progressFocusNode);
     if (type == ProgressType::CAPSULE) {
@@ -813,22 +684,23 @@ void ProgressModelNG::ProgressInitialize(
         SetTextDefaultStyle(textHost, value, max);
         textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
         eventHub->SetHoverEffect(HoverEffectType::SCALE);
+        eventHub->SetHoverEffect(static_cast<HoverEffectType>(theme->GetCapsuleHoverEffectType()));
     } else {
         if (!frameNode->GetChildren().empty()) {
             frameNode->RemoveChildAtIndex(0);
         }
         eventHub->SetHoverEffect(HoverEffectType::NONE);
     }
-}
-
-void ProgressModelNG::SetPrivacySensitive(FrameNode* frameNode, const std::optional<bool>& flag)
-{
-    if (flag) {
-        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, IsSensitive, *flag, frameNode);
-    } else {
-        ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(ProgressPaintProperty, IsSensitive, PROPERTY_UPDATE_RENDER, frameNode);
+    if (frameNode->GetThemeScopeId()) {
+        if (type == ProgressType::LINEAR || type == ProgressType::MOON) {
+            ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, Color, theme->GetTrackSelectedColor());
+        } else if (type == ProgressType::CAPSULE) {
+            ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, Color, theme->GetCapsuleSelectColor());
+        }
+        if (type != ProgressType::CAPSULE) {
+            ACE_UPDATE_PAINT_PROPERTY(ProgressPaintProperty, BackgroundColor, theme->GetTrackBgColor());
+        }
     }
-    // ViewAbstract::SetPrivacySensitive(frameNode, flag);
 }
 
 void ProgressModelNG::SetBorderRadius(const Dimension& value)
@@ -891,6 +763,7 @@ void ProgressModelNG::SetModifierInitiatedColor(FrameNode* frameNode, bool value
     CHECK_NULL_VOID(pattern);
     pattern->IsModifierInitiatedColor(value);
 }
+
 void ProgressModelNG::SetModifierInitiatedBgColor(FrameNode* frameNode, bool value)
 {
     CHECK_NULL_VOID(frameNode);
@@ -1107,8 +980,7 @@ void ProgressModelNG::SetRingStatus(FrameNode* frameNode, const RefPtr<ResourceO
         std::string statusStr;
         NG::ProgressStatus status = NG::ProgressStatus::PROGRESSING;
         if (ResourceParseUtils::ParseResString(obj, statusStr)) {
-            status = (statusStr == "LOADING" ? NG::ProgressStatus::LOADING
-                                            : NG::ProgressStatus::PROGRESSING);
+            status = (statusStr == "LOADING" ? NG::ProgressStatus::LOADING : NG::ProgressStatus::PROGRESSING);
         }
         SetProgressStatus(AceType::RawPtr(node), status);
     };
@@ -1277,9 +1149,8 @@ void ProgressModelNG::SetBackgroundColorResource(FrameNode* frameNode, const Ref
             auto paintProp = node->GetPaintProperty<ProgressPaintProperty>();
             auto type = paintProp->GetProgressType().value_or(ProgressType::LINEAR);
             Color bg = (type == ProgressType::CAPSULE)
-                ? theme->GetCapsuleBgColor()
-                : (type == ProgressType::RING ? theme->GetRingProgressBgColor()
-                                                : theme->GetTrackBgColor());
+                           ? theme->GetCapsuleBgColor()
+                           : (type == ProgressType::RING ? theme->GetRingProgressBgColor() : theme->GetTrackBgColor());
             SetBackgroundColor(AceType::RawPtr(node), bg);
         }
     };
diff --git a/frameworks/core/components_ng/pattern/progress/progress_model_ng.h b/frameworks/core/components_ng/pattern/progress/progress_model_ng.h
index 6542ac022131ce086dd4a098deea01ee4866681c..e5ea5c665ee307526123a369ae60e8f9c2dae8e6 100644
--- a/frameworks/core/components_ng/pattern/progress/progress_model_ng.h
+++ b/frameworks/core/components_ng/pattern/progress/progress_model_ng.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2025 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
@@ -81,27 +81,27 @@ public:
 
     static RefPtr<FrameNode> CreateFrameNode(int32_t nodeId, double value, double max, NG::ProgressType type);
     static void SetValue(FrameNode* frameNode, double value);
-    static void SetColor(FrameNode* frameNode, const std::optional<Color>& value);
-    static void SetGradientColor(FrameNode* frameNode, const std::optional<Gradient>& value);
-    static void SetSmoothEffect(FrameNode* frameNode, const std::optional<bool>& value);
-    static void SetStrokeWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
-    static void SetLinearSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
-    static void SetRingSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
-    static void SetPaintShadow(FrameNode* frameNode, const std::optional<bool>& value);
-    static void SetProgressStatus(FrameNode* frameNode, const std::optional<ProgressStatus>& status);
-    static void SetScaleCount(FrameNode* frameNode, const std::optional<int32_t>& value);
-    static void SetScaleWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
-    static void SetBorderWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
-    static void SetBorderColor(FrameNode* frameNode, const std::optional<Color>& value);
-    static void SetSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
-    static void SetShowText(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetColor(FrameNode* frameNode, const Color& value);
+    static void SetGradientColor(FrameNode* frameNode, const Gradient& value);
+    static void SetSmoothEffect(FrameNode* frameNode, bool value);
+    static void SetStrokeWidth(FrameNode* frameNode, const Dimension& value);
+    static void SetLinearSweepingEffect(FrameNode* frameNode, bool value);
+    static void SetRingSweepingEffect(FrameNode* frameNode, bool value);
+    static void SetPaintShadow(FrameNode* frameNode, bool value);
+    static void SetProgressStatus(FrameNode* frameNode, ProgressStatus status);
+    static void SetScaleCount(FrameNode* frameNode, int32_t value);
+    static void SetScaleWidth(FrameNode* frameNode, const Dimension& value);
+    static void SetBorderWidth(FrameNode* frameNode, const Dimension& value);
+    static void SetBorderColor(FrameNode* frameNode, const Color& value);
+    static void SetSweepingEffect(FrameNode* frameNode, bool value);
+    static void SetShowText(FrameNode* frameNode, bool value);
     static void SetText(FrameNode* frameNode, const std::optional<std::string>& value);
-    static void SetFontColor(FrameNode* frameNode, const std::optional<Color>& value);
-    static void SetFontSize(FrameNode* frameNode, const std::optional<Dimension>& value);
-    static void SetFontWeight(FrameNode* frameNode, const std::optional<FontWeight>& value);
-    static void SetFontFamily(FrameNode* frameNode, const std::optional<std::vector<std::string>>& value);
-    static void SetItalicFontStyle(FrameNode* frameNode, const std::optional<Ace::FontStyle>& value);
-    static void SetStrokeRadius(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetFontColor(FrameNode* frameNode, const Color& value);
+    static void SetFontSize(FrameNode* frameNode, const Dimension& value);
+    static void SetFontWeight(FrameNode* frameNode, const FontWeight& value);
+    static void SetFontFamily(FrameNode* frameNode, const std::vector<std::string>& value);
+    static void SetItalicFontStyle(FrameNode* frameNode, const Ace::FontStyle& value);
+    static void SetStrokeRadius(FrameNode* frameNode, const Dimension& value);
     static void ResetStrokeRadius(FrameNode* frameNode);
     static void SetBackgroundColor(FrameNode* frameNode, const Color& value);
     static void SetTotal(FrameNode* frameNode, double max);
@@ -114,7 +114,6 @@ public:
     static void ProgressInitialize(
         FrameNode* frameNode, double min, double value, double cachedValue, double max, NG::ProgressType type);
     static void SetBorderRadius(FrameNode* frameNode, const Dimension& value);
-    static void SetPrivacySensitive(FrameNode* frameNode, const std::optional<bool>& flag);
     static void ResetBorderRadius(FrameNode* frameNode);
     static void ResetColor(FrameNode* frameNode);
     static void ResetBackgroundColor(FrameNode* frameNode);
diff --git a/frameworks/core/components_ng/pattern/progress/progress_model_static.cpp b/frameworks/core/components_ng/pattern/progress/progress_model_static.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce77cbf571b8d3d487ad1bb50d73d81a464db387
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/progress/progress_model_static.cpp
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2025 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 "core/components_ng/pattern/progress/progress_model_static.h"
+
+#include "base/geometry/dimension.h"
+#include "core/components/progress/progress_component.h"
+#include "core/components_ng/base/frame_node.h"
+#include "core/components_ng/base/view_abstract_model_static.h"
+#include "core/components_ng/base/view_stack_processor.h"
+#include "core/components_ng/pattern/pattern.h"
+#include "core/components_ng/pattern/progress/progress_date.h"
+#include "core/components_ng/pattern/progress/progress_pattern.h"
+#include "core/components_ng/pattern/text/text_layout_property.h"
+#include "core/components_ng/pattern/text/text_pattern.h"
+#include "core/components_v2/inspector/inspector_constants.h"
+
+namespace OHOS::Ace::NG {
+void ProgressModelStatic::SetColor(FrameNode* frameNode, const std::optional<Color>& value)
+{
+    CHECK_NULL_VOID(frameNode);
+    auto pattern = frameNode->GetPattern<ProgressPattern>();
+    CHECK_NULL_VOID(pattern);
+    pattern->SetUserInitiatedColor(value.has_value());
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Color, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, Color, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetGradientColor(FrameNode* frameNode, const std::optional<Gradient>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, GradientColor, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, GradientColor, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetSmoothEffect(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableSmoothEffect, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableSmoothEffect, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetStrokeWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, StrokeWidth, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_LAYOUT_PROPERTY(ProgressLayoutProperty, StrokeWidth, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetLinearSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableLinearScanEffect, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableLinearScanEffect, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetRingSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableRingScanEffect, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableRingScanEffect, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetPaintShadow(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, PaintShadow, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, PaintShadow, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetProgressStatus(FrameNode* frameNode, const std::optional<ProgressStatus>& status)
+{
+    if (status) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressStatus, status.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ProgressStatus, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetScaleCount(FrameNode* frameNode, const std::optional<int32_t>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleCount, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleCount, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetScaleWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleWidth, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ScaleWidth, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetBorderWidth(FrameNode* frameNode, const std::optional<Dimension>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderWidth, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderWidth, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetBorderColor(FrameNode* frameNode, const std::optional<Color>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, BorderColor, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableScanEffect, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableScanEffect, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetShowText(FrameNode* frameNode, const std::optional<bool>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableShowText, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, EnableShowText, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetText(FrameNode* frameNode, const std::optional<std::string>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto pattern = frameNode->GetPattern<ProgressPattern>();
+    CHECK_NULL_VOID(pattern);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    auto progressPaintProperty = frameNode->GetPaintProperty<NG::ProgressPaintProperty>();
+    CHECK_NULL_VOID(progressPaintProperty);
+    std::string context = "";
+    if (!value.has_value()) {
+        auto maxValue = progressPaintProperty->GetMaxValue();
+        auto curValue = progressPaintProperty->GetValue();
+        int32_t curPercent = curValue.value() * 100 / maxValue.value();
+        std::string number = std::to_string(curPercent) + "%";
+        bool isShowText = progressPaintProperty->GetEnableShowText().value_or(false);
+        if (!isShowText) {
+            number = "";
+        }
+        textLayoutProperty->UpdateContent(number);
+        context = number;
+        pattern->SetTextFromUser(false);
+    } else {
+        textLayoutProperty->UpdateContent(value.value());
+        context = value.value();
+        pattern->SetTextFromUser(true);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, Text, context, frameNode);
+}
+
+void ProgressModelStatic::SetFontColor(FrameNode* frameNode, const std::optional<Color>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    if (value) {
+        textLayoutProperty->UpdateTextColor(value.value());
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextColor, value.value(), frameNode);
+    } else {
+        textLayoutProperty->ResetTextColor();
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextColor, frameNode);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+}
+
+void ProgressModelStatic::SetFontSize(FrameNode* frameNode, const std::optional<Dimension>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    if (value) {
+        textLayoutProperty->UpdateFontSize(value.value());
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextSize, value.value(), frameNode);
+    } else {
+        textLayoutProperty->ResetFontSize();
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, TextSize, frameNode);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+}
+
+void ProgressModelStatic::SetFontWeight(FrameNode* frameNode, const std::optional<FontWeight>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    if (value) {
+        textLayoutProperty->UpdateFontWeight(value.value());
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontWeight, value.value(), frameNode);
+    } else {
+        textLayoutProperty->ResetFontWeight();
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontWeight, frameNode);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+}
+
+void ProgressModelStatic::SetFontFamily(FrameNode* frameNode, const std::optional<std::vector<std::string>>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    if (value) {
+        textLayoutProperty->UpdateFontFamily(value.value());
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontFamily, value.value(), frameNode);
+    } else {
+        textLayoutProperty->ResetFontFamily();
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, FontFamily, frameNode);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+}
+
+void ProgressModelStatic::SetItalicFontStyle(FrameNode* frameNode, const std::optional<Ace::FontStyle>& value)
+{
+    auto textHost = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
+    CHECK_NULL_VOID(textHost);
+    auto textLayoutProperty = textHost->GetLayoutProperty<TextLayoutProperty>();
+    CHECK_NULL_VOID(textLayoutProperty);
+    if (value) {
+        textLayoutProperty->UpdateItalicFontStyle(value.value());
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, ItalicFontStyle, value.value(), frameNode);
+    } else {
+        textLayoutProperty->ResetItalicFontStyle();
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, ItalicFontStyle, frameNode);
+    }
+    textHost->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+}
+
+void ProgressModelStatic::SetStrokeRadius(FrameNode* frameNode, const std::optional<Dimension>& value)
+{
+    if (value) {
+        ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, StrokeRadius, value.value(), frameNode);
+    } else {
+        ACE_RESET_NODE_PAINT_PROPERTY(ProgressPaintProperty, StrokeRadius, frameNode);
+    }
+}
+
+void ProgressModelStatic::SetPrivacySensitive(FrameNode* frameNode, const std::optional<bool>& flag)
+{
+    // if (flag) {
+    //     ACE_UPDATE_NODE_PAINT_PROPERTY(ProgressPaintProperty, IsSensitive, *flag, frameNode);
+    // } else {
+    //     ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(ProgressPaintProperty, IsSensitive, PROPERTY_UPDATE_RENDER, frameNode);
+    // }
+    // ViewAbstractModelStatic::SetPrivacySensitive(frameNode, flag);
+}
+} // namespace OHOS::Ace::NG
\ No newline at end of file
diff --git a/frameworks/core/components_ng/pattern/progress/progress_model_static.h b/frameworks/core/components_ng/pattern/progress/progress_model_static.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ae15a34c19b0d2a47cd38cbde21c109f19c5ffe
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/progress/progress_model_static.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 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 FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_PROGRESS_PROGRESS_MODEL_STATIC_H
+#define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_PROGRESS_PROGRESS_MODEL_STATIC_H
+
+#include "core/components_ng/pattern/progress/progress_model.h"
+
+namespace OHOS::Ace::NG {
+class ACE_EXPORT ProgressModelStatic {
+public:
+    static void SetColor(FrameNode* frameNode, const std::optional<Color>& value);
+    static void SetGradientColor(FrameNode* frameNode, const std::optional<Gradient>& value);
+    static void SetSmoothEffect(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetStrokeWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetLinearSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetRingSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetPaintShadow(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetProgressStatus(FrameNode* frameNode, const std::optional<ProgressStatus>& status);
+    static void SetScaleCount(FrameNode* frameNode, const std::optional<int32_t>& value);
+    static void SetScaleWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetBorderWidth(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetBorderColor(FrameNode* frameNode, const std::optional<Color>& value);
+    static void SetSweepingEffect(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetShowText(FrameNode* frameNode, const std::optional<bool>& value);
+    static void SetText(FrameNode* frameNode, const std::optional<std::string>& value);
+    static void SetFontColor(FrameNode* frameNode, const std::optional<Color>& value);
+    static void SetFontSize(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetFontWeight(FrameNode* frameNode, const std::optional<FontWeight>& value);
+    static void SetFontFamily(FrameNode* frameNode, const std::optional<std::vector<std::string>>& value);
+    static void SetItalicFontStyle(FrameNode* frameNode, const std::optional<Ace::FontStyle>& value);
+    static void SetStrokeRadius(FrameNode* frameNode, const std::optional<Dimension>& value);
+    static void SetPrivacySensitive(FrameNode* frameNode, const std::optional<bool>& flag);
+};
+
+} // namespace OHOS::Ace::NG
+#endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_PROGRESS_PROGRESS_MODEL_STATIC_H
\ No newline at end of file
diff --git a/frameworks/core/interfaces/native/implementation/loading_progress_modifier.cpp b/frameworks/core/interfaces/native/implementation/loading_progress_modifier.cpp
index 293b81221e52c4342ddf8c0188feeb3c70e5a825..a21f6bfa7f8d1a8c89a520c94b6fab5b91850f20 100644
--- a/frameworks/core/interfaces/native/implementation/loading_progress_modifier.cpp
+++ b/frameworks/core/interfaces/native/implementation/loading_progress_modifier.cpp
@@ -14,59 +14,60 @@
  */
 
 #include "arkoala_api_generated.h"
+
 #include "core/components_ng/pattern/loading_progress/loading_progress_model_ng.h"
+#include "core/components_ng/pattern/loading_progress/loading_progress_model_static.h"
 #include "core/interfaces/native/generated/interface/node_api.h"
 #include "core/interfaces/native/utility/converter.h"
 
 namespace OHOS::Ace::NG::GeneratedModifier {
 namespace LoadingProgressModifier {
-Ark_NativePointer ConstructImpl(Ark_Int32 id,
-                                Ark_Int32 flags)
+Ark_NativePointer ConstructImpl(Ark_Int32 id, Ark_Int32 flags)
 {
     auto frameNode = LoadingProgressModelNG::CreateFrameNode(id);
     CHECK_NULL_RETURN(frameNode, nullptr);
     frameNode->IncRefCount();
     return AceType::RawPtr(frameNode);
 }
-} // LoadingProgressModifier
+} // namespace LoadingProgressModifier
 namespace LoadingProgressInterfaceModifier {
 void SetLoadingProgressOptionsImpl(Ark_NativePointer node)
 {
-    auto frameNode = reinterpret_cast<FrameNode *>(node);
+    auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    //auto convValue = Converter::Convert<type>(undefined);
-    //auto convValue = Converter::OptConvert<type>(undefined); // for enums
-    //LoadingProgressModelNG::SetSetLoadingProgressOptions(frameNode, convValue);
+    // auto convValue = Converter::Convert<type>(undefined);
+    // auto convValue = Converter::OptConvert<type>(undefined); // for enums
+    // LoadingProgressModelNG::SetSetLoadingProgressOptions(frameNode, convValue);
 }
-} // LoadingProgressInterfaceModifier
+} // namespace LoadingProgressInterfaceModifier
 namespace LoadingProgressAttributeModifier {
-void ColorImpl(Ark_NativePointer node,
-               const Ark_ResourceColor* value)
+void ColorImpl(Ark_NativePointer node, const Opt_ResourceColor* value)
 {
-    auto frameNode = reinterpret_cast<FrameNode *>(node);
+    auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
     auto color = Converter::OptConvert<Color>(*value);
-    LoadingProgressModelNG::SetColor(frameNode, color);
+    LoadingProgressModelStatic::SetColor(frameNode, color);
 }
-void EnableLoadingImpl(Ark_NativePointer node,
-                       Ark_Boolean value)
+void EnableLoadingImpl(Ark_NativePointer node, const Opt_Boolean* value)
 {
-    auto frameNode = reinterpret_cast<FrameNode *>(node);
+    auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    LoadingProgressModelNG::SetEnableLoading(frameNode, Converter::Convert<bool>(value));
+    auto convValue = Converter::OptConvert<bool>(*value);
+    if (!convValue) {
+        // TODO: Reset value
+        return;
+    }
+    LoadingProgressModelNG::SetEnableLoading(frameNode, *convValue);
 }
-void ContentModifierImpl(Ark_NativePointer node,
-                         const Ark_CustomObject* value)
+void ContentModifierImpl(Ark_NativePointer node, const Opt_ContentModifier* value)
 {
-    auto frameNode = reinterpret_cast<FrameNode *>(node);
+    auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
-    //auto convValue = Converter::OptConvert<type_name>(*value);
-    //LoadingProgressModelNG::SetContentModifier(frameNode, convValue);
+    // auto convValue = value ? Converter::OptConvert<type>(*value) : std::nullopt;
+    // LoadingProgressModelNG::SetContentModifier(frameNode, convValue);
     LOGE("ARKOALA LoadingProgressAttributeModifier::ContentModifierImpl -> Method is not implemented");
 }
-} // LoadingProgressAttributeModifier
+} // namespace LoadingProgressAttributeModifier
 const GENERATED_ArkUILoadingProgressModifier* GetLoadingProgressModifier()
 {
     static const GENERATED_ArkUILoadingProgressModifier ArkUILoadingProgressModifierImpl {
@@ -79,4 +80,4 @@ const GENERATED_ArkUILoadingProgressModifier* GetLoadingProgressModifier()
     return &ArkUILoadingProgressModifierImpl;
 }
 
-}
+} // namespace OHOS::Ace::NG::GeneratedModifier
diff --git a/frameworks/core/interfaces/native/implementation/progress_modifier.cpp b/frameworks/core/interfaces/native/implementation/progress_modifier.cpp
index a121122b8ca9ff348d6ac02b2553e5462b8a2851..04aeef0ded7adaca83dbde3ca42e4d9671bbbdf5 100644
--- a/frameworks/core/interfaces/native/implementation/progress_modifier.cpp
+++ b/frameworks/core/interfaces/native/implementation/progress_modifier.cpp
@@ -17,11 +17,13 @@
 
 #include "core/components_ng/base/frame_node.h"
 #include "core/components_ng/pattern/progress/progress_model_ng.h"
+#include "core/components_ng/pattern/progress/progress_model_static.h"
 #include "core/interfaces/native/utility/converter.h"
 #include "core/interfaces/native/utility/validators.h"
 
 namespace OHOS::Ace::NG {
 constexpr float PROGRESS_MAX_VALUE = 100.f;
+constexpr float PROGRESS_DEFAULT_STROKE_WIDTH = 4.0f;
 struct ProgressOptions {
     double value = 0;
     double total = PROGRESS_MAX_VALUE;
@@ -33,14 +35,14 @@ auto g_setLinearStyle = [](FrameNode* frameNode, const Ark_LinearStyleOptions& o
     auto strokeWidth = Converter::OptConvert<Dimension>(options.strokeWidth);
     Validator::ValidatePositive(strokeWidth);
     Validator::ValidateNonPercent(strokeWidth);
-    ProgressModelNG::SetStrokeWidth(frameNode, strokeWidth);
+    ProgressModelStatic::SetStrokeWidth(frameNode, strokeWidth);
     // enableScanEffect
-    ProgressModelNG::SetLinearSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
+    ProgressModelStatic::SetLinearSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
     // strokeRadius
     auto strokeRadius = Converter::OptConvert<Dimension>(options.strokeRadius);
     Validator::ValidatePositive(strokeRadius);
     Validator::ValidateNonPercent(strokeRadius);
-    ProgressModelNG::SetStrokeRadius(frameNode, strokeRadius);
+    ProgressModelStatic::SetStrokeRadius(frameNode, strokeRadius);
 };
 
 auto g_setRingStyle = [](FrameNode* frameNode, const Ark_RingStyleOptions& options) {
@@ -48,13 +50,13 @@ auto g_setRingStyle = [](FrameNode* frameNode, const Ark_RingStyleOptions& optio
     auto strokeWidth = Converter::OptConvert<Dimension>(options.strokeWidth);
     Validator::ValidatePositive(strokeWidth);
     Validator::ValidateNonPercent(strokeWidth);
-    ProgressModelNG::SetStrokeWidth(frameNode, strokeWidth);
+    ProgressModelStatic::SetStrokeWidth(frameNode, strokeWidth);
     // shadow
-    ProgressModelNG::SetPaintShadow(frameNode, Converter::OptConvert<bool>(options.shadow));
+    ProgressModelStatic::SetPaintShadow(frameNode, Converter::OptConvert<bool>(options.shadow));
     // enableScanEffect
-    ProgressModelNG::SetRingSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
+    ProgressModelStatic::SetRingSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
     // status
-    ProgressModelNG::SetProgressStatus(frameNode, Converter::OptConvert<ProgressStatus>(options.status));
+    ProgressModelStatic::SetProgressStatus(frameNode, Converter::OptConvert<ProgressStatus>(options.status));
 };
 
 auto g_setCapsuleStyle = [](FrameNode* frameNode, const Ark_CapsuleStyleOptions& options) {
@@ -62,29 +64,29 @@ auto g_setCapsuleStyle = [](FrameNode* frameNode, const Ark_CapsuleStyleOptions&
     auto borderWidth = Converter::OptConvert<Dimension>(options.borderWidth);
     Validator::ValidatePositive(borderWidth);
     Validator::ValidateNonPercent(borderWidth);
-    ProgressModelNG::SetBorderWidth(frameNode, borderWidth);
+    ProgressModelStatic::SetBorderWidth(frameNode, borderWidth);
     // borderColor
-    ProgressModelNG::SetBorderColor(frameNode, Converter::OptConvert<Color>(options.borderColor));
+    ProgressModelStatic::SetBorderColor(frameNode, Converter::OptConvert<Color>(options.borderColor));
     // enableScanEffect
-    ProgressModelNG::SetSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
+    ProgressModelStatic::SetSweepingEffect(frameNode, Converter::OptConvert<bool>(options.enableScanEffect));
     // showDefaultPercentage
-    ProgressModelNG::SetShowText(frameNode, Converter::OptConvert<bool>(options.showDefaultPercentage));
+    ProgressModelStatic::SetShowText(frameNode, Converter::OptConvert<bool>(options.showDefaultPercentage));
     // content
-    ProgressModelNG::SetText(frameNode, Converter::OptConvert<std::string>(options.content));
+    ProgressModelStatic::SetText(frameNode, Converter::OptConvert<std::string>(options.content));
     // fontColor
-    ProgressModelNG::SetFontColor(frameNode, Converter::OptConvert<Color>(options.fontColor));
+    ProgressModelStatic::SetFontColor(frameNode, Converter::OptConvert<Color>(options.fontColor));
     // font
     auto font = Converter::OptConvert<Font>(options.font);
     if (font.has_value()) {
-        ProgressModelNG::SetFontSize(frameNode, font.value().fontSize);
-        ProgressModelNG::SetFontWeight(frameNode, font.value().fontWeight);
-        ProgressModelNG::SetItalicFontStyle(frameNode, font.value().fontStyle);
-        ProgressModelNG::SetFontFamily(frameNode, font.value().fontFamilies);
+        ProgressModelStatic::SetFontSize(frameNode, font.value().fontSize);
+        ProgressModelStatic::SetFontWeight(frameNode, font.value().fontWeight);
+        ProgressModelStatic::SetItalicFontStyle(frameNode, font.value().fontStyle);
+        ProgressModelStatic::SetFontFamily(frameNode, font.value().fontFamilies);
     } else {
-        ProgressModelNG::SetFontSize(frameNode, std::nullopt);
-        ProgressModelNG::SetFontWeight(frameNode, std::nullopt);
-        ProgressModelNG::SetItalicFontStyle(frameNode, std::nullopt);
-        ProgressModelNG::SetFontFamily(frameNode, std::nullopt);
+        ProgressModelStatic::SetFontSize(frameNode, std::nullopt);
+        ProgressModelStatic::SetFontWeight(frameNode, std::nullopt);
+        ProgressModelStatic::SetItalicFontStyle(frameNode, std::nullopt);
+        ProgressModelStatic::SetFontFamily(frameNode, std::nullopt);
     }
 };
 
@@ -93,18 +95,28 @@ auto g_setProgressStyle = [](FrameNode* frameNode, const Ark_ProgressStyleOption
     auto strokeWidth = Converter::OptConvert<Dimension>(options.strokeWidth);
     Validator::ValidatePositive(strokeWidth);
     Validator::ValidateNonPercent(strokeWidth);
-    ProgressModelNG::SetStrokeWidth(frameNode, strokeWidth);
+    ProgressModelStatic::SetStrokeWidth(frameNode, strokeWidth);
     // scaleCount
     auto scaleCount = Converter::OptConvert<int32_t>(options.scaleCount);
     Validator::ValidateGreatOrEqual(scaleCount, 1);
-    ProgressModelNG::SetScaleCount(frameNode, scaleCount);
+    ProgressModelStatic::SetScaleCount(frameNode, scaleCount);
     // scaleWidth
     auto scaleWidth = Converter::OptConvert<Dimension>(options.scaleWidth);
     Validator::ValidatePositive(scaleWidth);
     Validator::ValidateNonPercent(scaleWidth);
-    ProgressModelNG::SetScaleWidth(frameNode, scaleWidth);
+    if (scaleWidth.has_value()) {
+        auto strokeWidthValue = PROGRESS_DEFAULT_STROKE_WIDTH;
+        auto scaleWidthValue = scaleWidth.value().Value();
+        if (strokeWidth.has_value()) {
+            strokeWidthValue = strokeWidth.value().Value();
+        }
+        if (GreatNotEqual(scaleWidthValue, strokeWidthValue)) {
+            scaleWidth.reset();
+        }
+    }
+    ProgressModelStatic::SetScaleWidth(frameNode, scaleWidth);
     // enableSmoothEffect
-    ProgressModelNG::SetSmoothEffect(frameNode, Converter::OptConvert<bool>(options.enableSmoothEffect));
+    ProgressModelStatic::SetSmoothEffect(frameNode, Converter::OptConvert<bool>(options.enableSmoothEffect));
 };
 } // namespace OHOS::Ace::NG
 
@@ -218,19 +230,21 @@ void SetProgressOptionsImpl(Ark_NativePointer node, const Ark_ProgressOptions* o
 }
 } // namespace ProgressInterfaceModifier
 namespace ProgressAttributeModifier {
-void ValueImpl(Ark_NativePointer node, const Ark_Number* value)
+void ValueImpl(Ark_NativePointer node, const Opt_Number* value)
 {
     auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
-    auto convValue = static_cast<double>(Converter::Convert<float>(*value));
-    ProgressModelNG::SetValue(frameNode, convValue);
+    auto convValue = Converter::OptConvert<double>(*value);
+    if (!convValue) {
+        // TODO: Reset value
+        return;
+    }
+    ProgressModelNG::SetValue(frameNode, *convValue);
 }
-void ColorImpl(Ark_NativePointer node, const Ark_Union_ResourceColor_LinearGradient* value)
+void ColorImpl(Ark_NativePointer node, const Opt_Union_ResourceColor_LinearGradient* value)
 {
     auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
     Converter::VisitUnion(
         *value,
         [frameNode](const Ark_ResourceColor& resourceColor) {
@@ -248,25 +262,27 @@ void ColorImpl(Ark_NativePointer node, const Ark_Union_ResourceColor_LinearGradi
                 gradient.AddColor(beginSideColor);
                 gradientOpt = gradient;
             }
-            ProgressModelNG::SetGradientColor(frameNode, gradientOpt);
-            ProgressModelNG::SetColor(frameNode, colorOpt);
+            ProgressModelStatic::SetGradientColor(frameNode, gradientOpt);
+            ProgressModelStatic::SetColor(frameNode, colorOpt);
         },
         [frameNode](const Ark_LinearGradient& linearGradient) {
-            ProgressModelNG::SetGradientColor(frameNode, Converter::Convert<Gradient>(linearGradient));
+            ProgressModelStatic::SetGradientColor(frameNode, Converter::OptConvert<Gradient>(linearGradient));
         },
+        // TODO: Reset value
         []() {});
 }
 void StyleImpl(Ark_NativePointer node,
-    const Ark_Union_LinearStyleOptions_RingStyleOptions_CapsuleStyleOptions_ProgressStyleOptions* value)
+    const Opt_Union_LinearStyleOptions_RingStyleOptions_CapsuleStyleOptions_ProgressStyleOptions* value)
 {
     auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
     Converter::VisitUnion(
         *value, [frameNode](const Ark_LinearStyleOptions& options) { g_setLinearStyle(frameNode, options); },
         [frameNode](const Ark_RingStyleOptions& options) { g_setRingStyle(frameNode, options); },
         [frameNode](const Ark_CapsuleStyleOptions& options) { g_setCapsuleStyle(frameNode, options); },
-        [frameNode](const Ark_ProgressStyleOptions& options) { g_setProgressStyle(frameNode, options); }, []() {});
+        [frameNode](const Ark_ProgressStyleOptions& options) { g_setProgressStyle(frameNode, options); },
+        // TODO: Reset value
+        []() {});
 }
 void PrivacySensitiveImpl(Ark_NativePointer node, const Opt_Boolean* value)
 {
@@ -274,14 +290,13 @@ void PrivacySensitiveImpl(Ark_NativePointer node, const Opt_Boolean* value)
     CHECK_NULL_VOID(frameNode);
     CHECK_NULL_VOID(value);
     auto convValue = Converter::OptConvert<bool>(*value);
-    ProgressModelNG::SetPrivacySensitive(frameNode, convValue);
+    ProgressModelStatic::SetPrivacySensitive(frameNode, convValue);
 }
-void ContentModifierImpl(Ark_NativePointer node, const Ark_CustomObject* value)
+void ContentModifierImpl(Ark_NativePointer node, const Opt_ContentModifier* value)
 {
     auto frameNode = reinterpret_cast<FrameNode*>(node);
     CHECK_NULL_VOID(frameNode);
-    CHECK_NULL_VOID(value);
-    // auto convValue = Converter::OptConvert<type_name>(*value);
+    // auto convValue = value ? Converter::OptConvert<type>(*value) : std::nullopt;
     // ProgressModelNG::SetContentModifier(frameNode, convValue);
     LOGE("ARKOALA ProgressInterfaceModifier::ContentModifierImpl -> Method is not implemented.");
 }
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 87c471d6134d463c2431f5e533fbe50b61b6a595..8eb5afbfac0a853e2373d230701b8751105dc292 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -1036,6 +1036,7 @@ ohos_source_set("ace_components_pattern") {
     "$ace_root/frameworks/core/components_ng/pattern/list/list_position_map.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/loading_progress/loading_progress_layout_algorithm.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_ng.cpp",
+    "$ace_root/frameworks/core/components_ng/pattern/loading_progress/loading_progress_model_static.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/loading_progress/loading_progress_modifier.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/loading_progress/loading_progress_pattern.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/marquee/marquee_accessibility_property.cpp",
@@ -1152,6 +1153,7 @@ ohos_source_set("ace_components_pattern") {
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_accessibility_property.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_layout_algorithm.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_model_ng.cpp",
+    "$ace_root/frameworks/core/components_ng/pattern/progress/progress_model_static.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_modifier.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_paint_method.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/progress/progress_paint_property.cpp",
diff --git a/test/unittest/core/pattern/progress/progress_builder_test_ng.cpp b/test/unittest/core/pattern/progress/progress_builder_test_ng.cpp
index 70a754d5a5e61f4f6892e07ec19e9578e42dd813..4353409d9ca7e2881dbdd1e8a0ac8ac189ce5065 100644
--- a/test/unittest/core/pattern/progress/progress_builder_test_ng.cpp
+++ b/test/unittest/core/pattern/progress/progress_builder_test_ng.cpp
@@ -57,6 +57,7 @@ constexpr double NEG_VALUE = -1.0;
 constexpr double VALUE_OF_PROGRESS = 100.0;
 constexpr double NEG_VALUE_OF_PROGRESS = -100.0;
 constexpr double MAX_VALUE_OF_PROGRESS = 100000.0;
+constexpr double MAX_VALUE_OF_PROGRESS2 = 10000.0;
 constexpr double MAX_NEG_VALUE_OF_PROGRESS = -100000.0;
 constexpr ProgressType PROGRESS_TYPE_LINEAR = ProgressType::LINEAR;
 constexpr ProgressType PROGRESS_TYPE_SCALE = ProgressType::SCALE;
@@ -1153,4 +1154,39 @@ HWTEST_F(ProgressBuilderTestNg, ProgressHandleBlurEventTest002, TestSize.Level1)
     EXPECT_FALSE(pattern->isFocusTextColorSet_);
     EXPECT_FALSE(pattern->isFocusShadowSet_);
 }
+
+/**
+* @tc.name: ProgressHandleBlurEventTest003
+* @tc.desc: SetBuilderFunc and get value
+* @tc.type: FUNC
+*/
+HWTEST_F(ProgressBuilderTestNg, ProgressHandleBlurEventTest003, TestSize.Level1)
+{
+    /**
+    * @tc.steps: step1. create progress.
+    */
+    CreateProgress(MAX_VALUE_OF_PROGRESS, MAX_VALUE_OF_PROGRESS2, PROGRESS_TYPE_MOON);
+    CreateDone();
+    auto eventHub = frameNode_->GetOrCreateEventHub<EventHub>();
+    CHECK_NULL_VOID(eventHub);
+    eventHub->SetEnabled(true);
+
+    auto progressPaintProperty = frameNode_->GetPaintProperty<ProgressPaintProperty>();
+    ASSERT_NE(progressPaintProperty, nullptr);
+    progressPaintProperty->UpdateMaxValue(MAX_VALUE_OF_PROGRESS2);
+    auto pattern = frameNode_->GetPattern<ProgressPattern>();
+    ASSERT_NE(pattern, nullptr);
+
+    /**
+    * @tc.steps: step2. set true and call HandleBlurEvent.
+    * @tc.expected: step2. isFocusScaleSet_, isFocusShadowSet_, isFocusShadowSet_ is false.
+    */
+    pattern->isFocusScaleSet_ = true;
+    pattern->isFocusTextColorSet_ = true;
+    pattern->isFocusShadowSet_ = true;
+    pattern->HandleBlurEvent();
+    EXPECT_FALSE(pattern->isFocusScaleSet_);
+    EXPECT_FALSE(pattern->isFocusTextColorSet_);
+    EXPECT_FALSE(pattern->isFocusShadowSet_);
+}
 } // namespace OHOS::Ace::NG
\ No newline at end of file