diff --git a/interfaces/kits/ani/webview/native/webviewcontroller/native_media_player_impl.cpp b/interfaces/kits/ani/webview/native/webviewcontroller/native_media_player_impl.cpp
index 688b9d78e997f6dee6ff06670c1a5e486f8fdd07..9c4d0076db6867ccc4566a45f6985e889865a3fc 100644
--- a/interfaces/kits/ani/webview/native/webviewcontroller/native_media_player_impl.cpp
+++ b/interfaces/kits/ani/webview/native/webviewcontroller/native_media_player_impl.cpp
@@ -113,7 +113,14 @@ NWebNativeMediaPlayerBridgeImpl::NWebNativeMediaPlayerBridgeImpl(int32_t nwebId,
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
     }
-    env->GlobalReference_Create(value, &value_);
+    if (env == nullptr) {
+        WVLOG_E("env is nulptr");
+        return;
+    }
+    ani_status status = env->GlobalReference_Create(value, &value_);
+    if (status != ANI_OK) {
+        WVLOG_E("nwebNativeMediaPlayerBridgeImpl create reference failed.");
+    }
 }
 
 NWebNativeMediaPlayerBridgeImpl::~NWebNativeMediaPlayerBridgeImpl()
@@ -122,12 +129,19 @@ NWebNativeMediaPlayerBridgeImpl::~NWebNativeMediaPlayerBridgeImpl()
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
     }
-    env->GlobalReference_Delete(value_);
+    if (env == nullptr) {
+        WVLOG_E("env is nulptr");
+        return;
+    }
+    ani_status status = env->GlobalReference_Delete(value_);
+    if (status != ANI_OK) {
+        WVLOG_E("nwebNativeMediaPlayerBridgeImpl delete reference failed.");
+    }
 }
 
 void NWebNativeMediaPlayerBridgeImpl::UpdateRect(double x, double y, double width, double height)
 {
-    WVLOG_I("begin to update rect, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to update rect, nweb id is %{public}d", nwebId_);
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -145,7 +159,7 @@ void NWebNativeMediaPlayerBridgeImpl::UpdateRect(double x, double y, double widt
 
 void NWebNativeMediaPlayerBridgeImpl::Play()
 {
-    WVLOG_I("begin to play, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to play, nweb id is %{public}d", nwebId_);
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -158,7 +172,7 @@ void NWebNativeMediaPlayerBridgeImpl::Play()
 
 void NWebNativeMediaPlayerBridgeImpl::Pause()
 {
-    WVLOG_I("begin to pause, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to pause, nweb id is %{public}d", nwebId_);
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -171,7 +185,7 @@ void NWebNativeMediaPlayerBridgeImpl::Pause()
 
 void NWebNativeMediaPlayerBridgeImpl::Seek(double time)
 {
-    WVLOG_I("begin to seek, nweb id is %{public}d, time is %{public}f", nwebId_, time);
+    WVLOG_D("begin to seek, nweb id is %{public}d, time is %{public}f", nwebId_, time);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -185,7 +199,7 @@ void NWebNativeMediaPlayerBridgeImpl::Seek(double time)
 
 void NWebNativeMediaPlayerBridgeImpl::SetVolume(double volume)
 {
-    WVLOG_I("begin to set volume, nweb id is %{public}d, volume is %{public}f", nwebId_, volume);
+    WVLOG_D("begin to set volume, nweb id is %{public}d, volume is %{public}f", nwebId_, volume);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -199,7 +213,7 @@ void NWebNativeMediaPlayerBridgeImpl::SetVolume(double volume)
 
 void NWebNativeMediaPlayerBridgeImpl::SetMuted(bool isMuted)
 {
-    WVLOG_I("begin to set muted, nweb id is %{public}d, muted flag is %{public}d", nwebId_, isMuted);
+    WVLOG_D("begin to set muted, nweb id is %{public}d, muted flag is %{public}d", nwebId_, isMuted);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -213,7 +227,7 @@ void NWebNativeMediaPlayerBridgeImpl::SetMuted(bool isMuted)
 
 void NWebNativeMediaPlayerBridgeImpl::SetPlaybackRate(double playbackRate)
 {
-    WVLOG_I("begin to set playback rate, nweb id is %{public}d, playback rate is %{public}f", nwebId_, playbackRate);
+    WVLOG_D("begin to set playback rate, nweb id is %{public}d, playback rate is %{public}f", nwebId_, playbackRate);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -227,7 +241,7 @@ void NWebNativeMediaPlayerBridgeImpl::SetPlaybackRate(double playbackRate)
 
 void NWebNativeMediaPlayerBridgeImpl::Release()
 {
-    WVLOG_I("begin to release, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to release, nweb id is %{public}d", nwebId_);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -239,7 +253,7 @@ void NWebNativeMediaPlayerBridgeImpl::Release()
 
 void NWebNativeMediaPlayerBridgeImpl::EnterFullScreen()
 {
-    WVLOG_I("begin to enter full screen, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to enter full screen, nweb id is %{public}d", nwebId_);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -251,7 +265,7 @@ void NWebNativeMediaPlayerBridgeImpl::EnterFullScreen()
 
 void NWebNativeMediaPlayerBridgeImpl::ExitFullScreen()
 {
-    WVLOG_I("begin to exit full screen, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to exit full screen, nweb id is %{public}d", nwebId_);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -263,7 +277,7 @@ void NWebNativeMediaPlayerBridgeImpl::ExitFullScreen()
 
 void NWebNativeMediaPlayerBridgeImpl::ResumeMediaPlayer()
 {
-    WVLOG_I("begin to resume media player, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to resume media player, nweb id is %{public}d", nwebId_);
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -284,7 +298,7 @@ void NWebNativeMediaPlayerBridgeImpl::ResumeMediaPlayer()
 
 void NWebNativeMediaPlayerBridgeImpl::SuspendMediaPlayer(SuspendType type)
 {
-    WVLOG_I("begin to suspend media player, nweb id is %{public}d %{public}d", nwebId_, static_cast<int>(type));
+    WVLOG_D("begin to suspend media player, nweb id is %{public}d %{public}d", nwebId_, static_cast<int>(type));
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
@@ -308,6 +322,7 @@ void NWebNativeMediaPlayerBridgeImpl::SuspendMediaPlayer(SuspendType type)
     if (env->FunctionalObject_Call(static_cast<ani_fn_object>(suspendRef), ani_size(INTEGER_ONE), argv, &ref) !=
         ANI_OK) {
         WVLOG_E("SuspendMediaPlayer failed");
+        return;
     }
 }
 
@@ -319,7 +334,10 @@ NWebCreateNativeMediaPlayerCallbackImpl::NWebCreateNativeMediaPlayerCallbackImpl
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
     }
-    env->GlobalReference_Create(static_cast<ani_ref>(callback), &callback_);
+    if (env->GlobalReference_Create(static_cast<ani_ref>(callback), &callback_) != ANI_OK) {
+        WVLOG_E("nwebCreateNativeMediaPlayerCallbackImpl failed");
+        return;
+    }
 }
 
 NWebCreateNativeMediaPlayerCallbackImpl::~NWebCreateNativeMediaPlayerCallbackImpl()
@@ -328,13 +346,16 @@ NWebCreateNativeMediaPlayerCallbackImpl::~NWebCreateNativeMediaPlayerCallbackImp
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return;
     }
-    env->GlobalReference_Delete(callback_);
+    if (env->GlobalReference_Delete(callback_) != ANI_OK) {
+        WVLOG_E("nwebCreateNativeMediaPlayerCallbackImpl failed");
+        return;
+    }
 }
 
 std::shared_ptr<NWebNativeMediaPlayerBridge> NWebCreateNativeMediaPlayerCallbackImpl::OnCreate(
     std::shared_ptr<NWebNativeMediaPlayerHandler> handler, std::shared_ptr<NWebMediaInfo> mediaInfo)
 {
-    WVLOG_I("begin to create native media player, nweb id is %{public}d", nwebId_);
+    WVLOG_D("begin to create native media player, nweb id is %{public}d", nwebId_);
 
     if (!callback_) {
         WVLOG_E("callback is null, nweb id is %{public}d", nwebId_);
@@ -373,7 +394,7 @@ std::shared_ptr<NWebNativeMediaPlayerBridge> NWebCreateNativeMediaPlayerCallback
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructRect(
     std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)
 {
-    WVLOG_I("ConstructRect start");
+    WVLOG_D("ConstructRect start");
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -399,7 +420,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructRect(
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructHandler(
     std::shared_ptr<NWebNativeMediaPlayerHandler> handler)
 {
-    WVLOG_I("ConstructHandler start");
+    WVLOG_D("ConstructHandler start");
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -434,7 +455,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructHandler(
 
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructControls(const std::vector<std::string>& controls)
 {
-    WVLOG_I("ConstructControls start");
+    WVLOG_D("ConstructControls start");
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return nullptr;
@@ -466,7 +487,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructControls(const std:
 
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructHeaders(const std::map<std::string, std::string>& headers)
 {
-    WVLOG_I("ConstructHeaders start");
+    WVLOG_D("ConstructHeaders start");
 
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
@@ -502,7 +523,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructHeaders(const std::
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructAttributes(
     const std::map<std::string, std::string>& attributes)
 {
-    WVLOG_I("ConstructAttributes start");
+    WVLOG_D("ConstructAttributes start");
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return nullptr;
@@ -536,7 +557,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructAttributes(
 
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructMediaInfo(std::shared_ptr<NWebMediaInfo> mediaInfo)
 {
-    WVLOG_I("ConstructMediaInfo start");
+    WVLOG_D("ConstructMediaInfo start");
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return nullptr;
@@ -611,7 +632,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructMediaInfo(std::shar
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructSourceInfos(
     const std::vector<std::shared_ptr<NWebMediaSourceInfo>>& sourceInfos)
 {
-    WVLOG_I("ConstructSourceInfos start");
+    WVLOG_D("ConstructSourceInfos start");
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return nullptr;
@@ -661,7 +682,7 @@ ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructSourceInfos(
 ani_object NWebCreateNativeMediaPlayerCallbackImpl::ConstructSurfaceInfo(
     std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)
 {
-    WVLOG_I("ConstructSurfaceInfo start");
+    WVLOG_D("ConstructSurfaceInfo start");
     ani_env* env = nullptr;
     if (vm_->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return nullptr;
diff --git a/interfaces/kits/ani/webview/native/webviewcontroller/webview_controller.cpp b/interfaces/kits/ani/webview/native/webviewcontroller/webview_controller.cpp
index 144bacee556fbfc6448d8f63bcdbd72c6490ba33..4752db2d30939b52b8f72b425a7799b1578db7ef 100644
--- a/interfaces/kits/ani/webview/native/webviewcontroller/webview_controller.cpp
+++ b/interfaces/kits/ani/webview/native/webviewcontroller/webview_controller.cpp
@@ -1004,8 +1004,11 @@ ErrCode WebviewController::HasImagesCallback(ani_vm *vm, ani_ref jsCallback)
     }
 
     auto callbackImpl = std::make_shared<WebviewHasImageCallback>(vm, jsCallback, nullptr);
-    nweb_ptr->HasImages(callbackImpl);
-    return NWebError::NO_ERROR;
+    if (callbackImpl) {
+        nweb_ptr->HasImages(callbackImpl);
+        return NWebError::NO_ERROR;
+    }
+    return NWebError::PARAM_CHECK_ERROR;
 }
 
 ErrCode WebviewController::HasImagesPromise(ani_vm *vm, ani_resolver deferred)
@@ -1039,8 +1042,11 @@ ErrCode WebviewController::HasImagesPromise(ani_vm *vm, ani_resolver deferred)
     }
 
     auto callbackImpl = std::make_shared<WebviewHasImageCallback>(vm, nullptr, deferred);
-    nweb_ptr->HasImages(callbackImpl);
-    return NWebError::NO_ERROR;
+    if (callbackImpl) {
+        nweb_ptr->HasImages(callbackImpl);
+        return NWebError::NO_ERROR;
+    }
+    return NWebError::PARAM_CHECK_ERROR;
 }
 
 void WebviewController::RemoveCache(bool includeDiskFiles)
diff --git a/interfaces/kits/ani/webview/native/webviewcontroller/webview_hasimage_callback.cpp b/interfaces/kits/ani/webview/native/webviewcontroller/webview_hasimage_callback.cpp
index ea95b00df2b29eab487799ed74ca2a08e6c1f33e..203cbc16ee2f5e6b28a5f5d74f6c545c5051f23a 100644
--- a/interfaces/kits/ani/webview/native/webviewcontroller/webview_hasimage_callback.cpp
+++ b/interfaces/kits/ani/webview/native/webviewcontroller/webview_hasimage_callback.cpp
@@ -81,8 +81,7 @@ void WebviewHasImageCallback::OnReceiveValue(bool result)
         return;
     }
 
-    auto task = [this, result]() { WebviewHasImageCallback::AfterWorkCb(result); };
-    task();
+    WebviewHasImageCallback::AfterWorkCb(result);
     vm_->DetachCurrentThread();
 }
 
diff --git a/interfaces/kits/ani/webview/src/webdatabase/ani_web_data_base.cpp b/interfaces/kits/ani/webview/src/webdatabase/ani_web_data_base.cpp
index a7c44d51dc366d9fe4c707ade5c8ec50d43e9570..c1d350562b1cab51afa7ca2d85884bbd494f702f 100644
--- a/interfaces/kits/ani/webview/src/webdatabase/ani_web_data_base.cpp
+++ b/interfaces/kits/ani/webview/src/webdatabase/ani_web_data_base.cpp
@@ -13,13 +13,13 @@
  * limitations under the License.
  */
 
+#include "ani_web_data_base.h"
 #include <array>
 #include <iostream>
 #include <string>
 
 #include "ani_business_error.h"
 #include "ani_parse_utils.h"
-#include "ani_web_data_base.h"
 #include "nweb_helper.h"
 #include "nweb_log.h"
 #include "securec.h"
diff --git a/interfaces/kits/ani/webview/src/webviewcontroller/ani_native_media_player_handler.cpp b/interfaces/kits/ani/webview/src/webviewcontroller/ani_native_media_player_handler.cpp
index f265ebb3447342ea4308156876f807e87d6a6673..de034898cbcc3d8897b68cc915243232b2fd3533 100644
--- a/interfaces/kits/ani/webview/src/webviewcontroller/ani_native_media_player_handler.cpp
+++ b/interfaces/kits/ani/webview/src/webviewcontroller/ani_native_media_player_handler.cpp
@@ -112,9 +112,15 @@ ani_object createObjectDouble(ani_env* env, ani_double status)
 {
     static constexpr const char* className = "Lstd/core/Double;";
     ani_class doubleCls {};
-    env->FindClass(className, &doubleCls);
+    if (env->FindClass(className, &doubleCls) != ANI_OK) {
+        WVLOG_E("createObjectDouble failed - invalid FindClass type");
+        return nullptr;
+    }
     ani_method ctor {};
-    env->Class_FindMethod(doubleCls, "<ctor>", "d:", &ctor);
+    if (env->Class_FindMethod(doubleCls, "<ctor>", "d:", &ctor) != ANI_OK) {
+        WVLOG_E("createObjectDouble findMethod Failed.");
+        return nullptr;
+    }
     ani_object obj {};
     if (env->Object_New(doubleCls, ctor, &obj, status) != ANI_OK) {
         WVLOG_E("createObjectDouble failed");
@@ -127,9 +133,15 @@ ani_object createObjectBoolean(ani_env* env, ani_boolean status)
 {
     static constexpr const char* className = "Lstd/core/Boolean;";
     ani_class booleanCls {};
-    env->FindClass(className, &booleanCls);
+    if (env->FindClass(className, &booleanCls) != ANI_OK) {
+        WVLOG_E("createObjectBoolean failed - invalid FindClass type");
+        return nullptr;
+    }
     ani_method ctor {};
-    env->Class_FindMethod(booleanCls, "<ctor>", "z:", &ctor);
+    if (env->Class_FindMethod(booleanCls, "<ctor>", "z:", &ctor) != ANI_OK) {
+        WVLOG_E("createObjectBoolean findMethod Failed.");
+        return nullptr;
+    }
     ani_object obj {};
     if (env->Object_New(booleanCls, ctor, &obj, status) != ANI_OK) {
         WVLOG_E("createObjectBoolean failed");
@@ -140,7 +152,7 @@ ani_object createObjectBoolean(ani_env* env, ani_boolean status)
 
 static void HandleStatusChanged(ani_env* env, ani_object object, ani_enum_item status)
 {
-    WVLOG_I("handle_status_changed is called");
+    WVLOG_D("handle_status_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -167,13 +179,13 @@ static void HandleStatusChanged(ani_env* env, ani_object object, ani_enum_item s
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_status_changed is called, status is %{public}d", statusStr);
+    WVLOG_D("handle_status_changed is called, status is %{public}d", statusStr);
     handler->HandleStatusChanged(static_cast<PlaybackStatus>(statusStr));
 }
 
 static void HandleVolumeChanged(ani_env* env, ani_object object, ani_double volume)
 {
-    WVLOG_I("handle_volume_changed is called");
+    WVLOG_D("handle_volume_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -201,13 +213,13 @@ static void HandleVolumeChanged(ani_env* env, ani_object object, ani_double volu
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_volume_changed is called, volume is %{public}f", volumeStr);
+    WVLOG_D("handle_volume_changed is called, volume is %{public}f", volumeStr);
     handler->HandleVolumeChanged(volumeStr);
 }
 
 static void HandleMutedChanged(ani_env* env, ani_object object, ani_boolean muted)
 {
-    WVLOG_I("handle_muted_changed is called");
+    WVLOG_D("handle_muted_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -230,13 +242,13 @@ static void HandleMutedChanged(ani_env* env, ani_object object, ani_boolean mute
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_muted_changed is called, muted is %{public}d", mutedStr);
+    WVLOG_D("handle_muted_changed is called, muted is %{public}d", mutedStr);
     handler->HandleMutedChanged(mutedStr);
 }
 
 static void HandlePlaybackRateChanged(ani_env* env, ani_object object, ani_double playbackRate)
 {
-    WVLOG_I("handle_playback_rate_changed is called");
+    WVLOG_D("handle_playback_rate_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -264,13 +276,13 @@ static void HandlePlaybackRateChanged(ani_env* env, ani_object object, ani_doubl
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_playback_rate_changed is called, playbackRate is %{public}f", playbackRateStr);
+    WVLOG_D("handle_playback_rate_changed is called, playbackRate is %{public}f", playbackRateStr);
     handler->HandlePlaybackRateChanged(playbackRateStr);
 }
 
 static void HandleDurationChanged(ani_env* env, ani_object object, ani_double duration)
 {
-    WVLOG_I("handle_duration_changed is called");
+    WVLOG_D("handle_duration_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -298,13 +310,13 @@ static void HandleDurationChanged(ani_env* env, ani_object object, ani_double du
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_duration_changed is called, duration is %{public}f", durationStr);
+    WVLOG_D("handle_duration_changed is called, duration is %{public}f", durationStr);
     handler->HandleDurationChanged(durationStr);
 }
 
 static void HandleTimeUpdate(ani_env* env, ani_object object, ani_double currentPlayTime)
 {
-    WVLOG_I("handle_time_update is called");
+    WVLOG_D("handle_time_update is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -332,13 +344,13 @@ static void HandleTimeUpdate(ani_env* env, ani_object object, ani_double current
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_time_update is called, currentPlayTime is %{public}f", currentPlayTimeStr);
+    WVLOG_D("handle_time_update is called, currentPlayTime is %{public}f", currentPlayTimeStr);
     handler->HandleTimeUpdate(currentPlayTimeStr);
 }
 
 static void HandleBufferedEndTimeChanged(ani_env* env, ani_object object, ani_double bufferedEndTime)
 {
-    WVLOG_I("handle_buffered_end_time_changed is called");
+    WVLOG_D("handle_buffered_end_time_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -366,13 +378,13 @@ static void HandleBufferedEndTimeChanged(ani_env* env, ani_object object, ani_do
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_buffered_end_time_changed is called, bufferedEndTime is %{public}f", bufferedEndTimeStr);
+    WVLOG_D("handle_buffered_end_time_changed is called, bufferedEndTime is %{public}f", bufferedEndTimeStr);
     handler->HandleBufferedEndTimeChanged(bufferedEndTimeStr);
 }
 
 static void HandleEnded(ani_env* env, ani_object object)
 {
-    WVLOG_I("handle_ended is called");
+    WVLOG_D("handle_ended is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -389,7 +401,7 @@ static void HandleEnded(ani_env* env, ani_object object)
 
 static void HandleNetworkStateChanged(ani_env* env, ani_object object, ani_enum_item state)
 {
-    WVLOG_I("handle_network_state_changed is called");
+    WVLOG_D("handle_network_state_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -413,13 +425,13 @@ static void HandleNetworkStateChanged(ani_env* env, ani_object object, ani_enum_
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_network_state_changed is called, state is %{public}d", stateStr);
+    WVLOG_D("handle_network_state_changed is called, state is %{public}d", stateStr);
     handler->HandleNetworkStateChanged(static_cast<NetworkState>(stateStr));
 }
 
 static void HandleReadyStateChanged(ani_env* env, ani_object object, ani_enum_item state)
 {
-    WVLOG_I("handle_ready_state_changed is called");
+    WVLOG_D("handle_ready_state_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -443,13 +455,13 @@ static void HandleReadyStateChanged(ani_env* env, ani_object object, ani_enum_it
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_ready_state_changed is called, state is %{public}d", stateStr);
+    WVLOG_D("handle_ready_state_changed is called, state is %{public}d", stateStr);
     handler->HandleReadyStateChanged(static_cast<ReadyState>(stateStr));
 }
 
 static void HandleFullScreenChanged(ani_env* env, ani_object object, ani_boolean fullscreen)
 {
-    WVLOG_I("handle_full_screen_changed is called");
+    WVLOG_D("handle_full_screen_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -472,13 +484,13 @@ static void HandleFullScreenChanged(ani_env* env, ani_object object, ani_boolean
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_full_screen_changed is called, fullscreen is %{public}d", fullscreenStr);
+    WVLOG_D("handle_full_screen_changed is called, fullscreen is %{public}d", fullscreenStr);
     handler->HandleFullScreenChanged(fullscreenStr);
 }
 
 static void HandleSeeking(ani_env* env, ani_object object)
 {
-    WVLOG_I("handle_seeking is called");
+    WVLOG_D("handle_seeking is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -495,7 +507,7 @@ static void HandleSeeking(ani_env* env, ani_object object)
 
 static void HandleSeekFinished(ani_env* env, ani_object object)
 {
-    WVLOG_I("handle_seek_finished is called");
+    WVLOG_D("handle_seek_finished is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -512,7 +524,7 @@ static void HandleSeekFinished(ani_env* env, ani_object object)
 
 static void HandleError(ani_env* env, ani_object object, ani_enum_item error, ani_string errorMessage)
 {
-    WVLOG_I("handle_error is called");
+    WVLOG_D("handle_error is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -543,14 +555,14 @@ static void HandleError(ani_env* env, ani_object object, ani_enum_item error, an
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I(
+    WVLOG_D(
         "handle_error is called, error is %{public}d, errorMessage is %{public}s", errorStr, errorMessageStr.c_str());
     handler->HandleError(static_cast<MediaError>(errorStr), errorMessageStr);
 }
 
 static void HandleVideoSizeChanged(ani_env* env, ani_object object, ani_double width, ani_double height)
 {
-    WVLOG_I("handle_video_size_changed is called");
+    WVLOG_D("handle_video_size_changed is called");
 
     if (env == nullptr) {
         WVLOG_E("env is nullptr");
@@ -584,7 +596,7 @@ static void HandleVideoSizeChanged(ani_env* env, ani_object object, ani_double w
         WVLOG_E("native media player handler is null");
         return;
     }
-    WVLOG_I("handle_video_size_changed is called, width is %{public}f, height is %{public}f",
+    WVLOG_D("handle_video_size_changed is called, width is %{public}f, height is %{public}f",
         widthStr, heightStr);
     handler->HandleVideoSizeChanged(widthStr, heightStr);
 }
diff --git a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp
index 802a71cf3824b706420e1005e6cf5caaaa43a3e8..f04aaa22f83a62f62acbe5543140db165ef309fc 100644
--- a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp
+++ b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp
@@ -3226,7 +3226,10 @@ static ani_enum_item GetMediaPlaybackState(ani_env* env, ani_object object)
     }
     ani_int mediaPlaybackState = 0;
     ani_enum enumType;
-    env->FindEnum(ANI_ENUM_MEDIA_PLAY_BACK_STATE, &enumType);
+    if ((env->FindEnum(ANI_ENUM_MEDIA_PLAY_BACK_STATE, &enumType)) != ANI_OK) {
+        WVLOG_E("findEnum is error");
+        return nullptr;
+    }
     auto* controller = reinterpret_cast<WebviewController *>(AniParseUtils::Unwrap(env, object));
     if (!controller || !controller->IsInit()) {
         AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR);
@@ -3234,7 +3237,10 @@ static ani_enum_item GetMediaPlaybackState(ani_env* env, ani_object object)
     }
     mediaPlaybackState = static_cast<ani_int>(controller->GetMediaPlaybackState());
     ani_enum_item state;
-    env->Enum_GetEnumItemByIndex(enumType, mediaPlaybackState, &state);
+    if ((env->Enum_GetEnumItemByIndex(enumType, mediaPlaybackState, &state)) != ANI_OK) {
+        WVLOG_E("getEnum is error");
+        return nullptr;
+    }
     return state;
 }
 
@@ -3246,7 +3252,10 @@ void OnCreateNativeMediaPlayer(ani_env* env, ani_object object, ani_fn_object ca
     }
 
     ani_vm *vm = nullptr;
-    env->GetVM(&vm);
+    if (env->GetVM(&vm) != ANI_OK) {
+        WVLOG_E("Failed to get VM from env");
+        return;
+    }
     g_vm = vm;
     WVLOG_D("put on_create_native_media_player callback");
 
@@ -4703,6 +4712,350 @@ static ani_object RunJavaScriptPromiseExt(ani_env* env, ani_object object, ani_o
     return RunJSPromise(env, object, script, true);
 }
 
+static void EnableBackForwardCache(ani_env *env, ani_object object, ani_object featuresObject)
+{
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return;
+    }
+    bool nativeEmbed = false;
+    bool mediaTakeOver = false;
+    ani_boolean embedObj = ANI_FALSE;
+    ani_boolean mediaObj = ANI_FALSE;
+    ani_boolean isUndefined = ANI_TRUE;
+    env->Reference_IsUndefined(featuresObject, &isUndefined);
+    if (isUndefined != ANI_TRUE) {
+        if (env->Object_GetFieldByName_Boolean(featuresObject, "nativeEmbed", &embedObj) == ANI_OK) {
+            nativeEmbed = static_cast<bool>(embedObj);
+        }
+
+        if (env->Object_GetFieldByName_Boolean(featuresObject, "mediaTakeOver", &mediaObj) == ANI_OK) {
+            mediaTakeOver = static_cast<bool>(mediaObj);
+        }
+    }
+    NWebHelper::Instance().EnableBackForwardCache(nativeEmbed, mediaTakeOver);
+    return;
+}
+
+static void SetBackForwardCacheOptions(ani_env *env, ani_object object, ani_object optionsObject)
+{
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return;
+    }
+    auto* controller = reinterpret_cast<WebviewController *>(AniParseUtils::Unwrap(env, object));
+    if (!controller) {
+        WVLOG_E("SetBackForwardCacheOptions: Init webview controller error.");
+        return;
+    }
+    int32_t size = BFCACHE_DEFAULT_SIZE;
+    int32_t timeToLive = BFCACHE_DEFAULT_TIMETOLIVE;
+    ani_int sizeObj = static_cast<ani_int>(size);
+    ani_int timeToLiveObj = static_cast<ani_int>(timeToLive);
+    ani_boolean isUndefined = ANI_TRUE;
+    env->Reference_IsUndefined(optionsObject, &isUndefined);
+    if (isUndefined != ANI_TRUE) {
+        if (env->Object_GetPropertyByName_Int(optionsObject, "size", &sizeObj) == ANI_OK) {
+            size = static_cast<int32_t>(sizeObj);
+        }
+        if (env->Object_GetPropertyByName_Int(optionsObject, "timeToLive", &timeToLiveObj) == ANI_OK) {
+            timeToLive = static_cast<int32_t>(timeToLiveObj);
+        }
+    }
+    WVLOG_D("SetBackForwardCacheOptions size:%{public}d, timeToLive:%{public}d", size, timeToLive);
+    controller->SetBackForwardCacheOptions(size, timeToLive);
+    return;
+}
+
+static void StoreWebArchiveCallbackInternal(
+    ani_env* env, std::string baseNameStr, bool autoNameStr, ani_ref jsCallback, int32_t nwebId)
+{
+    if (!env) {
+        return;
+    }
+    if (!jsCallback) {
+        return;
+    }
+    auto nweb_ptr = NWebHelper::Instance().GetNWeb(nwebId);
+    if (!nweb_ptr) {
+        std::vector<ani_ref> resultRef;
+        ani_ref tmp = NWebError::AniBusinessError::CreateError(env, INVALID_RESOURCE);
+        resultRef.push_back(tmp);
+        env->GetNull(&tmp);
+        resultRef.push_back(tmp);
+        ani_ref fnReturnVal;
+        env->FunctionalObject_Call(
+            static_cast<ani_fn_object>(jsCallback), resultRef.size(), resultRef.data(), &fnReturnVal);
+        env->GlobalReference_Delete(jsCallback);
+        return;
+    }
+
+    auto callbackImpl = std::make_shared<OHOS::NWeb::NWebStoreWebArchiveCallback>();
+    callbackImpl->SetCallBack([env, jCallback = std::move(jsCallback)](std::string result) {
+        if (!env) {
+            return;
+        }
+        std::vector<ani_ref> resultRef;
+        if (!result.empty()) {
+            ani_ref tmp;
+            env->GetNull(&tmp);
+            ani_string str {};
+            env->String_NewUTF8(result.c_str(), result.size(), &str);
+            resultRef.push_back(tmp);
+            resultRef.push_back(str);
+        } else {
+            ani_ref tmp = NWebError::AniBusinessError::CreateError(env, INVALID_RESOURCE);
+            resultRef.push_back(tmp);
+            env->GetNull(&tmp);
+            resultRef.push_back(tmp);
+        }
+        ani_ref fnReturnVal;
+        env->FunctionalObject_Call(
+            static_cast<ani_fn_object>(jCallback), resultRef.size(), resultRef.data(), &fnReturnVal);
+        env->GlobalReference_Delete(jCallback);
+    });
+    nweb_ptr->StoreWebArchive(baseNameStr, autoNameStr, callbackImpl);
+}
+
+static void StoreWebArchiveCallback(
+    ani_env* env, ani_object object, ani_string baseName, ani_boolean autoName, ani_fn_object callbackObj)
+{
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return;
+    }
+    ani_boolean isUndefined = ANI_TRUE;
+    if (env->Reference_IsUndefined(baseName, &isUndefined) != ANI_OK || isUndefined == ANI_TRUE) {
+        WVLOG_E("baseName is undefined");
+        return;
+    }
+    std::string baseNameStr;
+    if (!AniParseUtils::ParseString(env, baseName, baseNameStr)) {
+        WVLOG_E("Parse baseName failed");
+        AniBusinessError::ThrowError(env, NWebError::PARAM_CHECK_ERROR,
+            NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "baseName", "string"));
+        return;
+    }
+    bool autoNameStr = static_cast<bool>(autoName);
+
+    auto* controller = reinterpret_cast<WebviewController*>(AniParseUtils::Unwrap(env, object));
+    if (!controller) {
+        WVLOG_E("controller is null");
+        return;
+    }
+    int32_t nwebId_ = controller->GetWebId();
+
+    ani_ref jsCallback = nullptr;
+    env->GlobalReference_Create(callbackObj, &jsCallback);
+    return StoreWebArchiveCallbackInternal(env, baseNameStr, autoNameStr, jsCallback, nwebId_);
+}
+
+static void StoreWebArchivePromiseInternal(
+    ani_env* env, std::string baseNameStr, bool autoNameStr, ani_resolver deferred, int32_t nwebId)
+{
+    if (!env) {
+        return;
+    }
+    if (!deferred) {
+        return;
+    }
+    auto nweb_ptr = NWebHelper::Instance().GetNWeb(nwebId);
+    if (!nweb_ptr) {
+        WVLOG_E("nweb_ptr is nullptr");
+        ani_ref jsResult = nullptr;
+        jsResult = NWebError::AniBusinessError::CreateError(env, INIT_ERROR);
+        env->PromiseResolver_Reject(deferred, reinterpret_cast<ani_error>(jsResult));
+        return;
+    }
+
+    auto callbackImpl = std::make_shared<OHOS::NWeb::NWebStoreWebArchiveCallback>();
+    callbackImpl->SetCallBack([env, deferred](std::string result) {
+        if (!env) {
+            return;
+        }
+        std::vector<ani_ref> resultRef(RESULT_COUNT);
+        resultRef[0] = NWebError::AniBusinessError::CreateError(env, INVALID_RESOURCE);
+        ani_string str {};
+        env->String_NewUTF8(result.c_str(), result.size(), &str);
+        resultRef[1] = static_cast<ani_ref>(str);
+        if (!result.empty()) {
+            env->PromiseResolver_Resolve(deferred, resultRef[1]);
+        } else {
+            env->PromiseResolver_Reject(deferred, reinterpret_cast<ani_error>(resultRef[0]));
+        }
+    });
+    nweb_ptr->StoreWebArchive(baseNameStr, autoNameStr, callbackImpl);
+}
+
+static ani_object StoreWebArchivePromise(ani_env* env, ani_object object, ani_string baseName, ani_boolean autoName)
+{
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return nullptr;
+    }
+    ani_boolean isUndefined = ANI_TRUE;
+    if (env->Reference_IsUndefined(baseName, &isUndefined) != ANI_OK || isUndefined == ANI_TRUE) {
+        WVLOG_E("baseName is undefined");
+        return nullptr;
+    }
+    std::string baseNameStr;
+    if (!AniParseUtils::ParseString(env, baseName, baseNameStr)) {
+        WVLOG_E("Parse baseName failed");
+        AniBusinessError::ThrowError(env, NWebError::PARAM_CHECK_ERROR,
+            NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "baseName", "string"));
+        return nullptr;
+    }
+    bool autoNameStr = static_cast<bool>(autoName);
+    auto* controller = reinterpret_cast<WebviewController*>(AniParseUtils::Unwrap(env, object));
+    if (!controller) {
+        WVLOG_E("controller is null");
+        return nullptr;
+    }
+    int32_t nwebId_ = controller->GetWebId();
+    ani_object promise;
+    ani_resolver deferred;
+    env->Promise_New(&deferred, &promise);
+    StoreWebArchivePromiseInternal(env, baseNameStr, autoNameStr, deferred, nwebId_);
+    return promise;
+}
+
+static void HasImageCallback(ani_env* env, ani_object object, ani_fn_object callback)
+{
+    WVLOG_D("HasImageCallback begin");
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return;
+    }
+    ani_vm* vm = nullptr;
+    if (env->GetVM(&vm) != ANI_OK) {
+        WVLOG_E("Failed to get VM from env");
+        return;
+    }
+    if (!vm) {
+        WVLOG_E("vm is nullptr");
+        return;
+    }
+
+    WebviewController* webviewController = reinterpret_cast<WebviewController *>(AniParseUtils::Unwrap(env, object));
+    if (!webviewController || !webviewController->IsInit()) {
+        WVLOG_E("Unwrap failed");
+        AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR);
+        return;
+    }
+
+    ani_ref jsCallback = nullptr;
+    auto status = env->GlobalReference_Create(callback, &jsCallback);
+    if (status != ANI_OK) {
+        WVLOG_E("GlobalReference_Create failed, status is : %{public}d", status);
+        return;
+    }
+    if (jsCallback) {
+        ErrCode ret = webviewController->HasImagesCallback(vm, jsCallback);
+        if (ret == NWEB_ERROR) {
+            AniBusinessError::ThrowErrorByErrCode(env, ret);
+            return;
+        } else if (ret != NO_ERROR) {
+            AniBusinessError::ThrowErrorByErrCode(env, ret);
+            return;
+        }
+    }
+}
+
+ani_object HasImagePromise(ani_env* env, ani_object object)
+{
+    WVLOG_D("HasImagePromise begin");
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return nullptr;
+    }
+    ani_vm* vm = nullptr;
+    if (env->GetVM(&vm) != ANI_OK) {
+        WVLOG_E("Failed to get VM from env");
+        return nullptr;
+    }
+    if (!vm) {
+        WVLOG_E("vm is nullptr");
+        return nullptr;
+    }
+
+    WebviewController* webviewController = reinterpret_cast<WebviewController *>(AniParseUtils::Unwrap(env, object));
+    if (!webviewController || !webviewController->IsInit()) {
+        WVLOG_E("Unwrap failed");
+        AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR);
+        return nullptr;
+    }
+    ani_resolver deferred = nullptr;
+    ani_object promise = nullptr;
+    auto status = env->Promise_New(&deferred, &promise);
+    if (status != ANI_OK) {
+        WVLOG_E("Promise_New failed, status is : %{public}d", status);
+        return nullptr;
+    }
+
+    if (promise && deferred) {
+        ErrCode ret = webviewController->HasImagesPromise(vm, deferred);
+        if (ret == NWEB_ERROR) {
+            AniBusinessError::ThrowErrorByErrCode(env, ret);
+            return nullptr;
+        } else if (ret != NO_ERROR) {
+            AniBusinessError::ThrowErrorByErrCode(env, ret);
+            return nullptr;
+        }
+    }
+    return promise;
+}
+
+static ani_object GetCertificateSync(ani_env* env, ani_object object)
+{
+    ani_object certificateObj = nullptr;
+    if (!env) {
+        WVLOG_E("env is nullptr");
+        return certificateObj;
+    }
+    auto* controller = reinterpret_cast<WebviewController*>(AniParseUtils::Unwrap(env, object));
+    if (!controller || !controller->IsInit()) {
+        AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR);
+        return certificateObj;
+    }
+    std::vector<std::string> certChainDerData;
+    if (!controller->GetCertChainDerData(certChainDerData)) {
+        WVLOG_E("GetCertificateSync failed");
+        return certificateObj;
+    }
+    ani_class cls;
+    if (env->FindClass("Lescompat/Array;", &cls) != ANI_OK) {
+        return certificateObj;
+    }
+    ani_method arrayCtor;
+    if (env->Class_FindMethod(cls, "<ctor>", "I:V", &arrayCtor) != ANI_OK) {
+        return certificateObj;
+    }
+    if (env->Object_New(cls, arrayCtor, &certificateObj, certChainDerData.size()) != ANI_OK) {
+        return certificateObj;
+    }
+    ani_status status;
+    for (uint8_t i = 0; i < certChainDerData.size(); ++i) {
+        if (i == UINT8_MAX) {
+            WVLOG_E("error, cert chain data array reach max");
+            break;
+        }
+        void* data = nullptr;
+        ani_arraybuffer buffer = nullptr;
+        env->CreateArrayBuffer(certChainDerData[i].size(), &data, &buffer);
+        int retCode =
+            memcpy_s(data, certChainDerData[i].size(), certChainDerData[i].data(), certChainDerData[i].size());
+        if (retCode != 0) {
+            return certificateObj;
+        }
+        if ((status = env->Array_Set(
+                 static_cast<ani_array>(certificateObj), i, static_cast<ani_ref>(buffer))) != ANI_OK) {
+            WVLOG_E("error in set element");
+            return certificateObj;
+        }
+    }
+    return certificateObj;
+}
+
 static ani_ref CreateWebPrintDocumentAdapter(ani_env* env, ani_object object, ani_string jobName)
 {
     if (!env) {