diff --git a/sdk/BUILD.gn b/sdk/BUILD.gn
index e3e201d61a5af493c0a6bd9be32a35d90433d680..16e8bfbd6e9545233c064435026c3d92e87ceb83 100644
--- a/sdk/BUILD.gn
+++ b/sdk/BUILD.gn
@@ -83,6 +83,7 @@ ohos_shared_library("commonlib_ets_ani") {
     "icu:shared_icuuc",
     "openssl:libcrypto_shared",
     "runtime_core:ani",
+    "runtime_core:ani_helpers",
   ]
   if (is_standard_system) {
     external_deps += [ "hilog:libhilog" ]
diff --git a/sdk/native/api/ani_textdecoder.cpp b/sdk/native/api/ani_textdecoder.cpp
index 3f53ede58dbad60734d30cbd49b5aa5185c3ba20..3737c37611c1be7f0f83facc41c7b6ddb45723e1 100644
--- a/sdk/native/api/ani_textdecoder.cpp
+++ b/sdk/native/api/ani_textdecoder.cpp
@@ -15,6 +15,7 @@
 
 #include <iostream>
 #include "ani_textdecoder.h"
+#include <ani_signature_builder.h>
 #include "securec.h"
 #include "ohos/init_data.h"
 
@@ -142,15 +143,19 @@ ani_object TextDecoder::ThrowError(ani_env *env, std::string message)
 {
     ani_string errString;
     env->String_NewUTF8(message.c_str(), message.size(), &errString);
-    static const char *className = "L@ohos/util/util/BusinessError;";
     ani_class cls;
-    if (ANI_OK != env->FindClass(className, &cls)) {
-        HILOG_ERROR("TextDecoder:: Not found %{public}s", className);
+    auto classTypeError = arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "BusinessError"});
+    if (ANI_OK != env->FindClass(classTypeError.Descriptor().c_str(), &cls)) {
+        HILOG_ERROR("TextDecoder:: Not found %{public}s", classTypeError.Descriptor().c_str());
         return nullptr;
     }
 
     ani_method errorCtor;
-    if (ANI_OK != env->Class_FindMethod(cls, "<ctor>", "Lstd/core/String;:V", &errorCtor)) {
+    auto methodCtor = arkts::ani_signature::Builder::BuildConstructorName();
+    arkts::ani_signature::SignatureBuilder methodCtorSigBuilder;
+    methodCtorSigBuilder.AddClass({"std", "core", "String"});
+    auto methodCtorSignature = methodCtorSigBuilder.BuildSignatureDescriptor();
+    if (ANI_OK != env->Class_FindMethod(cls, methodCtor.c_str(), methodCtorSignature.c_str(), &errorCtor)) {
         HILOG_ERROR("TextDecoder:: Class_FindMethod <ctor> Failed");
         return nullptr;
     }
diff --git a/sdk/native/api/ani_textencoder.cpp b/sdk/native/api/ani_textencoder.cpp
index 8381a0948accd5923e8921410cc1515e5f595896..7140a8a1e3eb2b0ee990a48a0d70b41093bf1b7e 100644
--- a/sdk/native/api/ani_textencoder.cpp
+++ b/sdk/native/api/ani_textencoder.cpp
@@ -18,6 +18,7 @@
 #include <optional>
 #include <vector>
 #include "ani_textencoder.h"
+#include <ani_signature_builder.h>
 
 #define ANI_RETURN_NULLOPT_ON_FAILURE(retCode, ...) \
     if (ANI_OK != (retCode)) {                      \
@@ -57,10 +58,12 @@ ani_object NewUint8Array(ani_env *env, const char* signature, Args... args)
 {
     // todo with further optimization: Can FindClass and FindMethod be one-pass?
     ani_class arrayClass;
-    ANI_RETURN_NULLPTR_ON_FAILURE(env->FindClass("Lescompat/Uint8Array;", &arrayClass),
+    auto classTypeUint8Array = arkts::ani_signature::Builder::BuildClass({"escompat", "Uint8Array"});
+    ANI_RETURN_NULLPTR_ON_FAILURE(env->FindClass(classTypeUint8Array.Descriptor().c_str(), &arrayClass),
         "Internal failure: env->FindClass()");
     ani_method arrayCtor;
-    ANI_RETURN_NULLPTR_ON_FAILURE(env->Class_FindMethod(arrayClass, "<ctor>", signature, &arrayCtor),
+    auto methodCtor = arkts::ani_signature::Builder::BuildConstructorName();
+    ANI_RETURN_NULLPTR_ON_FAILURE(env->Class_FindMethod(arrayClass, methodCtor.c_str(), signature, &arrayCtor),
         "Internal failure: env->Class_FindMethod() with signature %{public}s", signature);
     ani_object res;
     ANI_RETURN_NULLPTR_ON_FAILURE(env->Object_New(arrayClass, arrayCtor, &res, args...),
@@ -310,21 +313,29 @@ ani_object DoEncodeIntoUint8Array(
     }
 
     ani_class resultClass;
-    const char *resultClassName = "L@ohos/util/util/EncodeIntoUint8ArrayInfoInner;";
-    if (ANI_OK != env->FindClass(resultClassName, &resultClass)) {
-        HILOG_ERROR("TextEncoder:: Failed to get class %{public}s", resultClassName);
+    auto classTypeName =
+    arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "EncodeIntoUint8ArrayInfoInner"});
+    if (ANI_OK != env->FindClass(classTypeName.Descriptor().c_str(), &resultClass)) {
+        HILOG_ERROR("TextEncoder:: Failed to get class %{public}s", classTypeName.Descriptor().c_str());
         return nullptr; // todo: Exception handling
     }
     ani_method resultCtor;
-    if (ANI_OK != env->Class_FindMethod(resultClass, "<ctor>", "II:V", &resultCtor)) {
-        HILOG_ERROR("TextEncoder:: Failed to get constructor of class %{public}s", resultClassName);
+    auto methodCtor = arkts::ani_signature::Builder::BuildConstructorName();
+    arkts::ani_signature::SignatureBuilder methodCtorSigBuilder;
+    methodCtorSigBuilder.AddInt();
+    methodCtorSigBuilder.AddInt();
+    auto methodCtorSignature = methodCtorSigBuilder.BuildSignatureDescriptor();
+    if (ANI_OK != env->Class_FindMethod(resultClass, methodCtor.c_str(), methodCtorSignature.c_str(), &resultCtor)) {
+        HILOG_ERROR("TextEncoder:: Failed to get constructor of class %{public}s",
+            classTypeName.Descriptor().c_str());
         return nullptr; // todo: Exception handling
     }
     ani_object res;
     if (ANI_OK != env->Object_New(resultClass, resultCtor, &res,
                                   static_cast<ani_int>(writeRes->nInputCharsConsumed),
                                   static_cast<ani_int>(writeRes->resultSizeBytes))) {
-        HILOG_ERROR("TextEncoder:: Failed to construct object of class %{public}s", resultClassName);
+        HILOG_ERROR("TextEncoder:: Failed to construct object of class %{public}s",
+            classTypeName.Descriptor().c_str());
         return nullptr; // todo: Exception handling
     }
     return res;
diff --git a/sdk/native/main.cpp b/sdk/native/main.cpp
index 5fe5c344a4c930ce1e8f3d8b61d73a6a13154879..a2f9f4b91a9fcb6e21e78dbfcac00face701dc69 100644
--- a/sdk/native/main.cpp
+++ b/sdk/native/main.cpp
@@ -15,6 +15,7 @@
 
 #include <ani.h>
 #include <array>
+#include <ani_signature_builder.h>
 #include <iostream>
 #include "api/ani_textdecoder.h"
 #include "api/ani_textencoder.h"
@@ -110,7 +111,7 @@ static void clean(ani_env *env, ani_object object)
     if (ANI_OK != env->Object_GetFieldByName_Long(object, "nativePtr", &ptr)) {
         return;
     }
-    auto decodedPtr = reinterpret_cast<TextDecoder *>(ptr);
+    auto decodedPtr = reinterpret_cast<TextDecoder*>(ptr);
     if (decodedPtr != nullptr) {
         delete decodedPtr;
     }
@@ -125,23 +126,39 @@ static void BindNativeDecoder(ani_env *env, ani_object object, ani_string ani_en
 
 static ani_status BindTextDecoder(ani_env *env)
 {
-    static const char *className = "L@ohos/util/util/TextDecoder;";
     ani_class cls;
-    if (ANI_OK != env->FindClass(className, &cls)) {
-        HILOG_ERROR("TextDecoder:: Not found %{public}s", className);
+    auto classsTypeDecoder = arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "TextDecoder"});
+    if (ANI_OK != env->FindClass(classsTypeDecoder.Descriptor().c_str(), &cls)) {
+        HILOG_ERROR("TextDecoder:: Not found %{public}s", classsTypeDecoder.Descriptor().c_str());
         return ANI_ERROR;
     }
-
-    static const char *cleanerName = "L@ohos/util/util/TextDecoderCleaner;";
     ani_class cleanercls;
-    if (ANI_OK != env->FindClass(cleanerName, &cleanercls)) {
-        HILOG_ERROR("TextDecoder:: Not found %{public}s", cleanerName);
+    auto classsTypeCleaner =
+    arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "TextDecoderCleaner"});
+    if (ANI_OK != env->FindClass(classsTypeCleaner.Descriptor().c_str(), &cleanercls)) {
+        HILOG_ERROR("TextDecoder:: Not found %{public}s", classsTypeCleaner.Descriptor().c_str());
         return ANI_ERROR;
     }
-
+    arkts::ani_signature::SignatureBuilder BindNativeDecoderSigBuilder;
+    BindNativeDecoderSigBuilder.AddClass({"std", "core", "String"});
+    BindNativeDecoderSigBuilder.AddInt();
+    auto BindNativeDecoderSignature = BindNativeDecoderSigBuilder.BuildSignatureDescriptor();
+    arkts::ani_signature::SignatureBuilder DecodeSigBuilder;
+    DecodeSigBuilder.AddClass({"escompat", "Uint8Array"});
+    DecodeSigBuilder.AddBoolean();
+    DecodeSigBuilder.SetReturnClass("std.core.String");
+    auto DecodeSignature = DecodeSigBuilder.BuildSignatureDescriptor();
     std::array methods = {
-        ani_native_function {"bindNativeDecoder", "Lstd/core/String;I:V", reinterpret_cast<void *>(BindNativeDecoder)},
-        ani_native_function {"decode", "Lescompat/Uint8Array;Z:Lstd/core/String;", reinterpret_cast<void *>(Decode)},
+        ani_native_function {
+            "bindNativeDecoder",
+            BindNativeDecoderSignature.c_str(),
+            reinterpret_cast<void*>(BindNativeDecoder)
+        },
+        ani_native_function {
+            "decode",
+            DecodeSignature.c_str(),
+            reinterpret_cast<void*>(Decode)
+        },
     };
 
     std::array cleanerMethods = {
@@ -149,12 +166,14 @@ static ani_status BindTextDecoder(ani_env *env)
     };
 
     if (ANI_OK != env->Class_BindNativeMethods(cls, methods.data(), methods.size())) {
-        HILOG_ERROR("TextDecoder:: Cannot bind native methods to className %{public}s", className);
+        HILOG_ERROR("TextDecoder:: Cannot bind native methods to className %{public}s",
+            classsTypeDecoder.Descriptor().c_str());
         return ANI_ERROR;
     }
 
     if (ANI_OK != env->Class_BindNativeMethods(cleanercls, cleanerMethods.data(), cleanerMethods.size())) {
-        HILOG_ERROR("TextDecoder:: Cannot bind native CleanerMethods to className %{public}s", cleanerName);
+        HILOG_ERROR("TextDecoder:: Cannot bind native CleanerMethods to className %{public}s",
+            classsTypeCleaner.Descriptor().c_str());
         return ANI_ERROR;
     }
     return ANI_OK;
@@ -171,19 +190,26 @@ static ani_string GenerateRandomUUID(ani_env *env, ani_boolean entropyCache)
 
 static ani_status BindUtilHelper(ani_env *env)
 {
-    static const char *className = "L@ohos/util/util/UtilHelper;";
     ani_class cls;
-    if (ANI_OK != env->FindClass(className, &cls)) {
-        std::cerr << "Not found '" << className << "'" << std::endl;
+    auto classTypeHelper = arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "UtilHelper"});
+    if (ANI_OK != env->FindClass(classTypeHelper.Descriptor().c_str(), &cls)) {
+        HILOG_ERROR("UtilHelper:: Not found %{public}s", classTypeHelper.Descriptor().c_str());
         return ANI_ERROR;
     }
-
+    arkts::ani_signature::SignatureBuilder GenerateRandomUUIDSigBuilder;
+    GenerateRandomUUIDSigBuilder.AddBoolean();
+    GenerateRandomUUIDSigBuilder.SetReturnClass("std.core.String");
+    auto GenerateRandomUUIDSignature = GenerateRandomUUIDSigBuilder.BuildSignatureDescriptor();
     std::array methods = {
-        ani_native_function {"generateRandomUUID", "Z:Lstd/core/String;", reinterpret_cast<void *>(GenerateRandomUUID)},
+        ani_native_function {
+            "generateRandomUUID",
+            GenerateRandomUUIDSignature.c_str(),
+            reinterpret_cast<void*>(GenerateRandomUUID)
+        },
     };
-
     if (ANI_OK != env->Class_BindNativeMethods(cls, methods.data(), methods.size())) {
-        HILOG_ERROR("UtilHelper:: Cannot bind native methods to className : %s\n", className);
+        HILOG_ERROR("UtilHelper:: Cannot bind native methods to className  %{public}s",
+            classTypeHelper.Descriptor().c_str());
         return ANI_ERROR;
     }
     return ANI_OK;
@@ -192,25 +218,39 @@ static ani_status BindUtilHelper(ani_env *env)
 [[maybe_unused]] static ani_status BindTextEncoder(ani_env *env)
 {
     ani_class cls;
-    const char *className = "L@ohos/util/util/TextEncoder;";
-    if (ANI_OK != env->FindClass(className, &cls)) {
-        HILOG_ERROR("TextEncoder:: Not found %{public}s", className);
+    auto classTypeEncoder = arkts::ani_signature::Builder::BuildClass({"@ohos", "util", "util", "TextEncoder"});
+    if (ANI_OK != env->FindClass(classTypeEncoder.Descriptor().c_str(), &cls)) {
+        HILOG_ERROR("TextEncoder:: Not found %{public}s", classTypeEncoder.Descriptor().c_str());
         return ANI_ERROR;
     }
+    arkts::ani_signature::SignatureBuilder BindNativeEncoderSigBuilder;
+    BindNativeEncoderSigBuilder.AddClass({"std", "core", "String"});
+    BindNativeEncoderSigBuilder.AddClass({"std", "core", "String"});
+    BindNativeEncoderSigBuilder.SetReturnClass({"escompat", "Uint8Array"});
+    auto BindNativeEncoderSignature = BindNativeEncoderSigBuilder.BuildSignatureDescriptor();
+
+    arkts::ani_signature::SignatureBuilder EncoderSigBuilder;
+    EncoderSigBuilder.AddClass({"std", "core", "String"});
+    EncoderSigBuilder.AddClass({"std", "core", "String"});
+    EncoderSigBuilder.AddClass({"escompat", "Uint8Array"});
+    EncoderSigBuilder.SetReturnClass("@ohos.util.util.EncodeIntoUint8ArrayInfo");
+    auto EncoderSignature = EncoderSigBuilder.BuildSignatureDescriptor();
+
     std::array barMethods = {
         ani_native_function {
             "doEncodeInto",
-            "Lstd/core/String;Lstd/core/String;:Lescompat/Uint8Array;",
-            reinterpret_cast<void*>(DoEncodeInto),
+            BindNativeEncoderSignature.c_str(),
+            reinterpret_cast<void*>(DoEncodeInto)
         },
-        ani_native_function{
+        ani_native_function {
             "doEncodeInfoUint8Array",
-            "Lstd/core/String;Lstd/core/String;Lescompat/Uint8Array;:L@ohos/util/util/EncodeIntoUint8ArrayInfo;",
-            reinterpret_cast<void*>(DoEncodeIntoUint8Array),
+            EncoderSignature.c_str(),
+            reinterpret_cast<void*>(DoEncodeIntoUint8Array)
         },
     };
     if (ANI_OK != env->Class_BindNativeMethods(cls, barMethods.data(), barMethods.size())) {
-        HILOG_ERROR("TextEncoder:: Cannot bind native methods to %{public}s", className);
+        HILOG_ERROR("TextEncoder:: Cannot bind native methods to %{public}s",
+            classTypeEncoder.Descriptor().c_str());
         return ANI_ERROR;
     }
     SetOhosIcuDirectory();