diff --git a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h
index 23845605e849ee1247284224f17fd4ee6c6b89bd..784e28b7042ad45a1385e4d48dd5dc04928878cb 100644
--- a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h
+++ b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h
@@ -12,12 +12,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef OHOS_ANI_DISPLAY_UTILS_H
-#define OHOS_ANI_DISPLAY_UTILS_H
+#ifndef DISPLAY_ANI_UTILS_H
+#define DISPLAY_ANI_UTILS_H
+
 #include <hitrace_meter.h>
 
 #include "ani.h"
+#include "display_ani_utils.h"
 #include "display_ani.h"
+#include "display_info.h"
+#include "display.h"
 #include "singleton_container.h"
 #include "display_manager.h"
 #include "window_manager_hilog.h"
@@ -27,30 +31,225 @@
 namespace OHOS {
 namespace Rosen {
 
-class DisplayAniUtils {
-public:
-static void convertRect(DMRect rect, ani_object rectObj, ani_env* env);
+enum class DisplayStateMode : uint32_t {
+    STATE_UNKNOWN = 0,
+    STATE_OFF,
+    STATE_ON,
+    STATE_DOZE,
+    STATE_DOZE_SUSPEND,
+    STATE_VR,
+    STATE_ON_SUSPEND
+};
 
-static void convertWaterArea(WaterfallDisplayAreaRects waterfallDisplayAreaRects,
-    ani_object waterfallObj, ani_env *env);
+static const std::map<DisplayState,      DisplayStateMode> NATIVE_TO_JS_DISPLAY_STATE_MAP {
+    { DisplayState::UNKNOWN,      DisplayStateMode::STATE_UNKNOWN      },
+    { DisplayState::OFF,          DisplayStateMode::STATE_OFF          },
+    { DisplayState::ON,           DisplayStateMode::STATE_ON           },
+    { DisplayState::DOZE,         DisplayStateMode::STATE_DOZE         },
+    { DisplayState::DOZE_SUSPEND, DisplayStateMode::STATE_DOZE_SUSPEND },
+    { DisplayState::VR,           DisplayStateMode::STATE_VR           },
+    { DisplayState::ON_SUSPEND,   DisplayStateMode::STATE_ON_SUSPEND   },
+};
 
-static ani_status cvtDisplay(sptr<Display> display, ani_env* env, ani_object obj);
 
-static ani_status GetStdString(ani_env *env, ani_string ani_str, std::string &result);
+void DisplayAniUtils::convertRect(DMRect rect, ani_object rectObj, ani_env* env)
+{
+    TLOGI(WmsLogTag::DMS, "[ANI] rect area start");
+    TLOGI(WmsLogTag::DMS, "[ANI] rect area info: %{public}d, %{public}d, %{public}u, %{public}u",
+        rect.posX_, rect.posY_, rect.width_, rect.height_);
+    env->Object_SetFieldByName_Double(rectObj, "<property>left", rect.posX_);
+    env->Object_SetFieldByName_Double(rectObj, "<property>width", rect.width_);
+    env->Object_SetFieldByName_Double(rectObj, "<property>top", rect.posY_);
+    env->Object_SetFieldByName_Double(rectObj, "<property>height", rect.height_);
+}
 
-static ani_status NewAniObject(ani_env* env, ani_class cls, const char *signature, ani_object* result, ...);
+void DisplayAniUtils::convertWaterArea(WaterfallDisplayAreaRects waterfallDisplayAreaRects,
+    ani_object waterfallObj, ani_env *env)
+{
+    TLOGI(WmsLogTag::DMS, "[ANI] start convert WaterArea");
+    ani_ref leftObj;
+    ani_ref rightObj;
+    ani_ref topObj;
+    ani_ref bottomObj;
+    env->Object_GetFieldByName_Ref(waterfallObj, "<property>left", &leftObj);
+    env->Object_GetFieldByName_Ref(waterfallObj, "<property>right", &rightObj);
+    env->Object_GetFieldByName_Ref(waterfallObj, "<property>top", &topObj);
+    env->Object_GetFieldByName_Ref(waterfallObj, "<property>bottom", &bottomObj);
+    convertRect(waterfallDisplayAreaRects.left, static_cast<ani_object>(leftObj), env);
+    convertRect(waterfallDisplayAreaRects.right, static_cast<ani_object>(rightObj), env);
+    convertRect(waterfallDisplayAreaRects.top, static_cast<ani_object>(topObj), env);
+    convertRect(waterfallDisplayAreaRects.bottom, static_cast<ani_object>(bottomObj), env);
+}
 
-static ani_status NewAniObjectNoParams(ani_env* env, ani_class cls, ani_object* object);
+ani_status DisplayAniUtils::cvtDisplay(sptr<Display> display, ani_env* env, ani_object obj)
+{
+    sptr<DisplayInfo> info = display->GetDisplayInfoWithCache();
+    int setfieldid = env->Object_SetFieldByName_Double(obj, "<property>id", info->GetDisplayId());
+    if (ANI_OK != setfieldid) {
+        TLOGE(WmsLogTag::DMS, "[ANI] set id failed: %{public}d", setfieldid);
+    }
+    const ani_size stringLength = info->GetName().size();
+    TLOGI(WmsLogTag::DMS, "[ANI] display = %{public}u, name = %{public}s",
+        static_cast<uint32_t>(info->GetDisplayId()), info->GetName().c_str());
+    ani_string str = nullptr;
+    env->String_NewUTF8(info->GetName().data(), stringLength, &str);
+    env->Object_SetFieldByName_Ref(obj, "<property>name", str);
+    env->Object_SetFieldByName_Boolean(obj, "<property>alive", info->GetAliveStatus());
+    if (NATIVE_TO_JS_DISPLAY_STATE_MAP.count(info->GetDisplayState()) != 0) {
+        env->Object_SetFieldByName_Int(obj, "<property>state", static_cast<uint32_t>(info->GetDisplayState()));
+    } else {
+        env->Object_SetFieldByName_Int(obj, "<property>state", 0);
+    }
+    env->Object_SetFieldByName_Double(obj, "<property>refreshRate", info->GetRefreshRate());
+    env->Object_SetFieldByName_Double(obj, "<property>rotation", static_cast<uint32_t>(info->GetRotation()));
+    ani_status setfieldRes = env->Object_SetFieldByName_Double(obj, "<property>width",
+        static_cast<uint32_t>(info->GetWidth()));
+    if (ANI_OK != setfieldRes) {
+        TLOGE(WmsLogTag::DMS, "[ANI] set failed: %{public}d, %{public}u", info->GetWidth(), setfieldRes);
+    }
+    env->Object_SetFieldByName_Double(obj, "<property>height", display->GetHeight());
+    env->Object_SetFieldByName_Double(obj, "<property>availableWidth", info->GetAvailableWidth());
+    env->Object_SetFieldByName_Double(obj, "<property>availableHeight", info->GetAvailableHeight());
+    env->Object_SetFieldByName_Double(obj, "<property>densityDPI", info->GetVirtualPixelRatio() * DOT_PER_INCH);
+    env->Object_SetFieldByName_Double(obj, "<property>orientation",
+        static_cast<uint32_t>(info->GetDisplayOrientation()));
+    env->Object_SetFieldByName_Double(obj, "<property>densityPixels", info->GetVirtualPixelRatio());
+    env->Object_SetFieldByName_Double(obj, "<property>scaledDensity", info->GetVirtualPixelRatio());
+    env->Object_SetFieldByName_Double(obj, "<property>xDPI", info->GetXDpi());
+    env->Object_SetFieldByName_Double(obj, "<property>yDPI", info->GetYDpi());
+    auto colorSpaces = info->GetColorSpaces();
+    auto hdrFormats = info->GetHdrFormats();
+    TLOGI(WmsLogTag::DMS, "[ANI] colorSpaces(0) %{public}zu, %{public}u", colorSpaces.size(), colorSpaces[1]);
+    if (colorSpaces.size() != 0) {
+        ani_array colorSpacesAni;
+        CreateAniArrayInt(env, colorSpaces.size(), &colorSpacesAni, colorSpaces);
+        if (ANI_OK != env->Object_SetFieldByName_Ref(obj, "<property>colorSpaces",
+            static_cast<ani_ref>(colorSpacesAni))) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Array set colorSpaces field error");
+        }
+    }
+    if (hdrFormats.size() != 0) {
+        ani_array hdrFormatsAni;
+        CreateAniArrayInt(env, hdrFormats.size(), &hdrFormatsAni, hdrFormats);
+        if (ANI_OK != env->Object_SetFieldByName_Ref(obj, "<property>hdrFormats",
+            static_cast<ani_ref>(hdrFormatsAni))) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Array set hdrFormats field error");
+        }
+    }
+    return ANI_OK;
+}
 
-static ani_object CreateAniUndefined(ani_env* env);
+void DisplayAniUtils::CreateAniArrayInt(ani_env* env, ani_size size, ani_array* aniArray, std::vector<uint32_t> vec)
+{
+    if (ANI_OK != env->Array_New(size, nullptr, aniArray)) {
+        TLOGE(WmsLogTag::DMS, "[ANI] create colorSpace array error");
+    }
+    ani_class intClass = nullptr;
+    if (ANI_OK != env->FindClass("Lstd/core/Int;", &intClass)) {
+        TLOGE(WmsLogTag::DMS, "[ANI] Find int class error");
+    }
+    ani_method intCtor = nullptr;
+    if (ANI_OK != env->Class_FindMethod(intClass, "<ctor>", "I:V", &intCtor)) {
+        TLOGE(WmsLogTag::DMS, "[ANI] Find int class constructor error");
+    }
 
-static void CreateAniArrayInt(ani_env* env, ani_size size, ani_array_int *aniArray, std::vector<uint32_t> vec);
+    for (ani_size i = 0; i < size; ++i) {
+        ani_object boxedInt {};
+        if (ANI_OK != env->Object_New(intClass, intCtor, &boxedInt, vec[i])) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Create boxed int error");
+        }
+        if (ANI_OK != env->Array_Set(*aniArray, i, boxedInt)) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Array set error");
+        }
+}
 
-static ani_status GetAniString(ani_env* env, const std::string& str, ani_string* result);
+ani_status DisplayAniUtils::GetStdString(ani_env *env, ani_string ani_str, std::string &result)
+{
+    ani_size strSize;
+    ani_status ret = env->String_GetUTF8Size(ani_str, &strSize);
+    if (ret != ANI_OK) {
+        return ret;
+    }
+    std::vector<char> buffer(strSize + 1);
+    char* utf8_buffer = buffer.data();
+    ani_size bytes_written = 0;
+    ret = env->String_GetUTF8(ani_str, utf8_buffer, strSize + 1, &bytes_written);
+    if (ret != ANI_OK) {
+        return ret;
+    }
+    utf8_buffer[bytes_written] = '\0';
+    result = std::string(utf8_buffer);
+    return ret;
+}
+
+ani_status DisplayAniUtils::NewAniObject(ani_env* env, ani_class cls, const char *signature, ani_object* result, ...)
+{
+    ani_method aniCtor;
+    auto ret = env->Class_FindMethod(cls, "<ctor>", signature, &aniCtor);
+    if (ret != ANI_OK) {
+        return ret;
+    }
+    va_list args;
+    va_start(args, result);
+    ani_status status = env->Object_New(cls, aniCtor, result, args);
+    va_end(args);
+    return status;
+}
+
+ani_status DisplayAniUtils::NewAniObjectNoParams(ani_env* env, ani_class cls, ani_object* object)
+{
+    ani_method aniCtor;
+    auto ret = env->Class_FindMethod(cls, "<ctor>", ":V", &aniCtor);
+    if (ret != ANI_OK) {
+        TLOGE(WmsLogTag::DMS, "[ANI] find ctor method fail");
+        return ret;
+    }
+    return env->Object_New(cls, aniCtor, object);
+}
+
+ani_object DisplayAniUtils::CreateAniUndefined(ani_env* env)
+{
+    ani_ref aniRef;
+    env->GetUndefined(&aniRef);
+    return static_cast<ani_object>(aniRef);
+}
+
+ani_status DisplayAniUtils::GetAniString(ani_env* env, const std::string& str, ani_string* result)
+{
+    return env->String_NewUTF8(str.c_str(), static_cast<ani_size>(str.size()), result);
+}
+
+ani_status DisplayAniUtils::CallAniFunctionVoid(ani_env *env, const char* ns,
+    const char* fn, const char* signature, ...)
+{
+    TLOGI(WmsLogTag::DMS, "[ANI]CallAniFunctionVoid begin");
+    ani_status ret = ANI_OK;
+    ani_namespace aniNamespace{};
+    if ((ret = env->FindNamespace(ns, &aniNamespace)) != ANI_OK) {
+        TLOGE(WmsLogTag::DMS, "[ANI]canot find ns %{public}d", ret);
+        return ret;
+    }
+    ani_function func{};
+    if ((ret = env->Namespace_FindFunction(aniNamespace, fn, signature, &func)) != ANI_OK) {
+        TLOGE(WmsLogTag::DMS, "[ANI]canot find callBack %{public}d", ret);
+        return ret;
+    }
+    va_list args;
+    va_start(args, signature);
+    TLOGI(WmsLogTag::DMS, "[ANI]CallAniFunctionVoid begin %{public}s", signature);
+    if (func == nullptr) {
+        TLOGI(WmsLogTag::DMS, "[ANI] null func ani");
+        return ret;
+    }
+    ret = env->Function_Call_Void_V(func, args);
+    va_end(args);
+    if (ret != ANI_OK) {
+        TLOGE(WmsLogTag::DMS, "[ANI]canot run callBack %{public}d", ret);
+        return ret;
+    }
+    return ret;
+}
 
-static ani_status CallAniFunctionVoid(ani_env *env, const char* ns,
-    const char* fn, const char* signature, ...);
-};
 }
 }
 #endif
\ No newline at end of file
diff --git a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp
index f26579bc2664c6a10acfccb0a53eb1444c98aab6..f2f8d2bc0e79b490e3239ff58948bca70c6ea7ca 100644
--- a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp
+++ b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp
@@ -119,7 +119,7 @@ ani_status DisplayAniUtils::cvtDisplay(sptr<Display> display, ani_env* env, ani_
     auto hdrFormats = info->GetHdrFormats();
     TLOGI(WmsLogTag::DMS, "[ANI] colorSpaces(0) %{public}zu, %{public}u", colorSpaces.size(), colorSpaces[1]);
     if (colorSpaces.size() != 0) {
-        ani_array_int colorSpacesAni;
+        ani_array colorSpacesAni;
         CreateAniArrayInt(env, colorSpaces.size(), &colorSpacesAni, colorSpaces);
         if (ANI_OK != env->Object_SetFieldByName_Ref(obj, "<property>colorSpaces",
             static_cast<ani_ref>(colorSpacesAni))) {
@@ -127,7 +127,7 @@ ani_status DisplayAniUtils::cvtDisplay(sptr<Display> display, ani_env* env, ani_
         }
     }
     if (hdrFormats.size() != 0) {
-        ani_array_int hdrFormatsAni;
+        ani_array hdrFormatsAni;
         CreateAniArrayInt(env, hdrFormats.size(), &hdrFormatsAni, hdrFormats);
         if (ANI_OK != env->Object_SetFieldByName_Ref(obj, "<property>hdrFormats",
             static_cast<ani_ref>(hdrFormatsAni))) {
@@ -137,14 +137,28 @@ ani_status DisplayAniUtils::cvtDisplay(sptr<Display> display, ani_env* env, ani_
     return ANI_OK;
 }
 
-void DisplayAniUtils::CreateAniArrayInt(ani_env* env, ani_size size, ani_array_int *aniArray, std::vector<uint32_t> vec)
+void DisplayAniUtils::CreateAniArrayInt(ani_env* env, ani_size size, ani_array* aniArray, std::vector<uint32_t> vec)
 {
-    if (ANI_OK != env->Array_New_Int(size, aniArray)) {
+    if (ANI_OK != env->Array_New(size, nullptr, aniArray)) {
         TLOGE(WmsLogTag::DMS, "[ANI] create colorSpace array error");
     }
-    ani_int* aniArrayBuf = reinterpret_cast<ani_int *>(vec.data());
-    if (ANI_OK != env->Array_SetRegion_Int(*aniArray, 0, size, aniArrayBuf)) {
-        TLOGE(WmsLogTag::DMS, "[ANI] Array set region int error");
+    ani_class intClass = nullptr;
+    if (ANI_OK != env->FindClass("Lstd/core/Int;", &intClass)) {
+        TLOGE(WmsLogTag::DMS, "[ANI] Find int class error");
+    }
+    ani_method intCtor = nullptr;
+    if (ANI_OK != env->Class_FindMethod(intClass, "<ctor>", "I:V", &intCtor)) {
+        TLOGE(WmsLogTag::DMS, "[ANI] Find int class constructor error");
+    }
+
+    for (ani_size i = 0; i < size; ++i) {
+        ani_object boxedInt {};
+        if (ANI_OK != env->Object_New(intClass, intCtor, &boxedInt, vec[i])) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Create boxed int error");
+        }
+        if (ANI_OK != env->Array_Set(*aniArray, i, boxedInt)) {
+            TLOGE(WmsLogTag::DMS, "[ANI] Array set error");
+        }
     }
 }
 
@@ -236,4 +250,4 @@ ani_status DisplayAniUtils::CallAniFunctionVoid(ani_env *env, const char* ns,
 }
 
 }
-}
\ No newline at end of file
+}
diff --git a/interfaces/kits/ani/window_runtime/window_stage_ani/src/ani_window_utils.cpp b/interfaces/kits/ani/window_runtime/window_stage_ani/src/ani_window_utils.cpp
index 2d50c99e3d3eeec2c3ee4bcf6f7e7bf8debe6dc2..aa43c7772ee756438cbc4ae1d635ceca8fd35be2 100644
--- a/interfaces/kits/ani/window_runtime/window_stage_ani/src/ani_window_utils.cpp
+++ b/interfaces/kits/ani/window_runtime/window_stage_ani/src/ani_window_utils.cpp
@@ -216,6 +216,107 @@ ani_object AniWindowUtils::CreateAniAvoidArea(ani_env* env, const AvoidArea& avo
     return aniAvoidArea;
 }
 
+ani_object AniWindowUtils::CreateAniKeyboardInfo(ani_env* env, const KeyboardPanelInfo& keyboardPanelInfo)
+{
+    TLOGI(WmsLogTag::WMS_KEYBOARD, "[ANI]");
+    ani_class aniClass;
+    ani_status ret = env->FindClass("L@ohos/window/window/KeyboardInfoInternal;", &aniClass);
+    if (ret != ANI_OK) {
+        TLOGE(WmsLogTag::WMS_KEYBOARD, "[ANI] class not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_method aniCtor;
+    ret = env->Class_FindMethod(aniClass, "<ctor>", nullptr, &aniCtor);
+    if (ret != ANI_OK) {
+        TLOGE(WmsLogTag::WMS_KEYBOARD, "[ANI] ctor not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_object keyboardInfo;
+    ret = env->Object_New(aniClass, aniCtor, &keyboardInfo);
+    if (ret != ANI_OK) {
+        TLOGE(WmsLogTag::WMS_KEYBOARD, "[ANI] failed to new obj");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    CallAniMethodVoid(env, keyboardInfo, aniClass, "<set>rect", nullptr,
+        CreateAniRect(env, keyboardPanelInfo.rect_));
+    return keyboardInfo;
+}
+
+ani_object AniWindowUtils::CreateAniSystemBarTintState(ani_env* env, DisplayId displayId,
+    const SystemBarRegionTints& tints)
+{
+    TLOGI(WmsLogTag::DEFAULT, "[ANI]");
+    ani_class aniClass;
+    if (env->FindClass("L@ohos/window/window/SystemBarTintStateInternal;", &aniClass) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] class not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_method aniCtor;
+    if (env->Class_FindMethod(aniClass, "<ctor>", nullptr, &aniCtor) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] ctor not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_object state;
+    if (env->Object_New(aniClass, aniCtor, &state) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] fail to new obj");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    CallAniMethodVoid(env, state, aniClass, "<set>displayId", nullptr, static_cast<ani_long>(displayId));
+    ani_array regionTintArray = nullptr;
+    if (env->Array_New(tints.size(), CreateAniUndefined(env), &regionTintArray) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] create array failed");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    for (size_t i = 0; i < tints.size(); i++) {
+        if (env->Array_Set(regionTintArray, i, CreateAniSystemBarRegionTint(env, tints[i])) != ANI_OK) {
+            TLOGE(WmsLogTag::DEFAULT, "[ANI] create region tint failed");
+            return AniWindowUtils::CreateAniUndefined(env);
+        }
+    }
+    CallAniMethodVoid(env, state, aniClass, "<set>regionTint", nullptr, regionTintArray);
+    return state;
+}
+
+ani_object AniWindowUtils::CreateAniSystemBarRegionTint(ani_env* env, const SystemBarRegionTint& tint)
+{
+    ani_class regionTintCls;
+    if (env->FindClass("L@ohos/window/window/SystemBarRegionTintInternal;", &regionTintCls) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] class not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_method regionTintCtor;
+    if (env->Class_FindMethod(regionTintCls, "<ctor>", nullptr, &regionTintCtor) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] ctor not found");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    ani_object regionTint;
+    if (env->Object_New(regionTintCls, regionTintCtor, &regionTint) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] fail to new obj");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(tint.type_) != 0) {
+        CallAniMethodVoid(env, regionTint, regionTintCls, "<set>type", nullptr,
+            ani_long(NATIVE_JS_TO_WINDOW_TYPE_MAP.at(tint.type_)));
+    } else {
+        CallAniMethodVoid(env, regionTint, regionTintCls, "<set>type", nullptr, ani_long(tint.type_));
+    }
+    CallAniMethodVoid(env, regionTint, regionTintCls, "<set>isEnable", nullptr, ani_boolean(tint.prop_.enable_));
+    ani_string backgroundColor;
+    if (GetAniString(env, GetHexColor(tint.prop_.backgroundColor_), &backgroundColor) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] create string failed");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    CallAniMethodVoid(env, regionTint, regionTintCls, "<set>backgroundColor", nullptr, backgroundColor);
+    ani_string contentColor;
+    if (GetAniString(env, GetHexColor(tint.prop_.contentColor_), &contentColor) != ANI_OK) {
+        TLOGE(WmsLogTag::DEFAULT, "[ANI] create string failed");
+        return AniWindowUtils::CreateAniUndefined(env);
+    }
+    CallAniMethodVoid(env, regionTint, regionTintCls, "<set>contentColor", nullptr, contentColor);
+    CallAniMethodVoid(env, regionTint, regionTintCls, "<set>region", nullptr, CreateAniRect(env, tint.region_));
+    return regionTint;
+}
+
 ani_status AniWindowUtils::CallAniFunctionVoid(ani_env *env, const char* ns,
     const char* fn, const char* signature, ...)
 {
@@ -747,4 +848,4 @@ WmErrorCode AniWindowUtils::ToErrorCode(WMError error, WmErrorCode defaultCode)
     return defaultCode;
 }
 } // namespace Rosen
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS