diff --git a/test/fuzztest/BUILD.gn b/test/fuzztest/BUILD.gn
index 6ed190c71f3c8a6707bb72392239b01cc5bc54d4..3fcd403c71bccf3f9704e4cd861a1f0218b9f544 100644
--- a/test/fuzztest/BUILD.gn
+++ b/test/fuzztest/BUILD.gn
@@ -36,9 +36,7 @@ group("fuzztest") {
     "player_fuzztest/playermp4_fuzzer:PlayerMp4FuzzTest",
     "player_fuzztest/playerseek_fuzzer:PlayerSeekFuzzTest",
     "player_fuzztest/playersei_fuzzer:PlayerSeiFuzzTest",
-    "player_fuzztest/playerservicestub_fuzzer:PlayerServiceStubFuzzTest",
     "player_fuzztest/playersetvolume_fuzzer:PlayerSetVolumeFuzzTest",
-    "player_fuzztest/playerstub_fuzzer:PlayerStubFuzzTest",
     "recorder_fuzztest/recorderservicestub_fuzzer:RecorderServiceStubFuzzTest",
     "recorder_fuzztest/recordersetaudiochannels_fuzzer:RecorderSetAudioChannelsFuzzTest",
     "recorder_fuzztest/recordersetaudiochannelsnum_fuzzer:RecorderSetAudioChannelsNumFuzzTest",
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/BUILD.gn b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/BUILD.gn
similarity index 96%
rename from test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/BUILD.gn
rename to test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/BUILD.gn
index 7e6e9d48e3cc0787ed7630937347413157bdbc71..45bc97e3ed7dc9d32d165abc9c14907233749716 100644
--- a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/BUILD.gn
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/BUILD.gn
@@ -18,10 +18,10 @@ import("//foundation/multimedia/player_framework/config.gni")
 MEDIA_ROOT_DIR = "//foundation/multimedia/player_framework/"
 
 ##############################fuzztest##########################################
-ohos_fuzztest("MonitorServiceStubFuzzTest") {
+ohos_fuzztest("MonitorServiceStub1FuzzTest") {
   module_out_path = "$MODULE_OUTPUT_PATH/monitor"
   fuzz_config_file =
-      "$MEDIA_ROOT_DIR/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer"
+      "$MEDIA_ROOT_DIR/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer"
   resource_config_file = "$MEDIA_ROOT_DIR/test/fuzztest/resource/ohos_test.xml"
 
   include_dirs = [
@@ -61,7 +61,7 @@ ohos_fuzztest("MonitorServiceStubFuzzTest") {
   if (player_framework_support_monitor) {
     sources = [
       "../../../../test/fuzztest/common/stub_common.cpp",
-      "monitorservicestub_fuzzer.cpp",
+      "monitorservicestub1_fuzzer.cpp",
     ]
   }
   deps = [
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/corpus/init b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/corpus/init
similarity index 97%
rename from test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/corpus/init
rename to test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/corpus/init
index d27c29f2d9d44dbc2999359e54b643d02932fd86..6198079a28e860189d4294f6598f8ac6804c0dff 100644
--- a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/corpus/init
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/corpus/init
@@ -1,16 +1,16 @@
-/*
- * Copyright (c) 2024 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.
- */
-
+/*
+ * Copyright (c) 2024 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.
+ */
+
 FUZZ
\ No newline at end of file
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.cpp b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub1_fuzzer.cpp
similarity index 83%
rename from test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.cpp
rename to test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub1_fuzzer.cpp
index 9e29a54fac23ab0f9471f07a020af46cc4f20147..fe63c19cc3d6b673fa548b4dd5cc28fb9129a07f 100644
--- a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.cpp
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub1_fuzzer.cpp
@@ -1,98 +1,95 @@
-/*
- * Copyright (c) 2024 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 "monitorservicestub_fuzzer.h"
-#include <cmath>
-#include <iostream>
-#include "string_ex.h"
-#include "directory_ex.h"
-#include <unistd.h>
-#include "media_server.h"
-#include "media_parcel.h"
-#include "i_standard_monitor_service.h"
-#include "stub_common.h"
-
-using namespace std;
-using namespace OHOS;
-using namespace Media;
-
-namespace OHOS {
-namespace Media {
-MonitorServiceStubFuzzer::MonitorServiceStubFuzzer()
-{
-}
-
-MonitorServiceStubFuzzer::~MonitorServiceStubFuzzer()
-{
-}
-
-const int32_t SYSTEM_ABILITY_ID = 3002;
-const bool RUN_ON_CREATE = false;
-bool MonitorServiceStubFuzzer::FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size)
-{
-    if (data == nullptr || size < sizeof(int64_t)) {
-        return true;
-    }
-    std::shared_ptr<MediaServer> mediaServer =
-        std::make_shared<MediaServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
-    sptr<IRemoteObject> listener = new(std::nothrow) MediaListenerStubFuzzer();
-    sptr<IRemoteObject> monitor = mediaServer->GetSubSystemAbility(
-        IStandardMediaService::MediaSystemAbility::MEDIA_MONITOR, listener);
-    if (monitor == nullptr) {
-        return false;
-    }
-
-    sptr<IRemoteStub<IStandardMonitorService>> monitorStub =
-        iface_cast<IRemoteStub<IStandardMonitorService>>(monitor);
-    if (monitorStub == nullptr) {
-        return false;
-    }
-
-    const int maxIpcNum = 10;
-    for (uint32_t code = 0; code <= maxIpcNum; code++) {
-        MessageParcel msg;
-        msg.WriteInterfaceToken(monitorStub->GetDescriptor());
-        msg.WriteBuffer(data, size);
-        msg.RewindRead(0);
-        MessageParcel reply;
-        MessageOption option;
-        monitorStub->OnRemoteRequest(code, msg, reply, option);
-    }
-
-    return true;
-}
-}
-
-bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size)
-{
-    if (data == nullptr) {
-        return true;
-    }
-
-    if (size < sizeof(int32_t)) {
-        return true;
-    }
-    MonitorServiceStubFuzzer testMonitor;
-    return testMonitor.FuzzMonitorOnRemoteRequest(data, size);
-}
-}
-
-/* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
-{
-    /* Run your code on data */
-    OHOS::FuzzTestMonitorOnRemoteRequest(data, size);
-    return 0;
+/*
+ * Copyright (c) 2024 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 "monitorservicestub_fuzzer.h"
+#include <cmath>
+#include <iostream>
+#include "string_ex.h"
+#include "directory_ex.h"
+#include <unistd.h>
+#include "media_server.h"
+#include "media_parcel.h"
+#include "i_standard_monitor_service.h"
+#include "stub_common.h"
+
+using namespace std;
+using namespace OHOS;
+using namespace Media;
+
+namespace OHOS {
+namespace Media {
+MonitorServiceStubFuzzer::MonitorServiceStubFuzzer()
+{
+}
+
+MonitorServiceStubFuzzer::~MonitorServiceStubFuzzer()
+{
+}
+
+const int32_t SYSTEM_ABILITY_ID = 3002;
+const bool RUN_ON_CREATE = false;
+bool MonitorServiceStubFuzzer::FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int64_t)) {
+        return true;
+    }
+    std::shared_ptr<MediaServer> mediaServer =
+        std::make_shared<MediaServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
+    sptr<IRemoteObject> listener = new(std::nothrow) MediaListenerStubFuzzer();
+    sptr<IRemoteObject> monitor = mediaServer->GetSubSystemAbility(
+        IStandardMediaService::MediaSystemAbility::MEDIA_MONITOR, listener);
+    if (monitor == nullptr) {
+        return false;
+    }
+
+    sptr<IRemoteStub<IStandardMonitorService>> monitorStub =
+        iface_cast<IRemoteStub<IStandardMonitorService>>(monitor);
+    if (monitorStub == nullptr) {
+        return false;
+    }
+
+    uint32_t code = 0;
+    MessageParcel msg;
+    msg.WriteInterfaceToken(monitorStub->GetDescriptor());
+    msg.WriteBuffer(data, size);
+    msg.RewindRead(0);
+    MessageParcel reply;
+    MessageOption option;
+    monitorStub->OnRemoteRequest(code, msg, reply, option);
+    return true;
+}
+}
+
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size)
+{
+    if (data == nullptr) {
+        return true;
+    }
+
+    if (size < sizeof(int32_t)) {
+        return true;
+    }
+    MonitorServiceStubFuzzer testMonitor;
+    return testMonitor.FuzzMonitorOnRemoteRequest(data, size);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::FuzzTestMonitorOnRemoteRequest(data, size);
+    return 0;
 }
\ No newline at end of file
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.h b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub_fuzzer.h
similarity index 96%
rename from test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.h
rename to test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub_fuzzer.h
index e43476c5b3709244b650b61283307f5126e6b0df..41dc6a3991889160d83bdf74910229bc05e52cc1 100644
--- a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/monitorservicestub_fuzzer.h
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/monitorservicestub_fuzzer.h
@@ -1,39 +1,39 @@
-/*
- * Copyright (c) 2024 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 MONITORSERVICESTUB_FUZZER
-#define MONITORSERVICESTUB_FUZZER
-
-#include <cstdint>
-#include <unistd.h>
-#include <climits>
-#include <cstdio>
-#include <cstdlib>
-#include <fcntl.h>
-
-#define FUZZ_PROJECT_NAME "monitorservicestub_fuzzer"
-
-namespace OHOS {
-namespace Media {
-class MonitorServiceStubFuzzer {
-public:
-    MonitorServiceStubFuzzer();
-    ~MonitorServiceStubFuzzer();
-    bool FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size);
-};
-}
-bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size);
-}
+/*
+ * Copyright (c) 2024 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 MONITORSERVICESTUB_FUZZER
+#define MONITORSERVICESTUB_FUZZER
+
+#include <cstdint>
+#include <unistd.h>
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <fcntl.h>
+
+#define FUZZ_PROJECT_NAME "monitorservicestub_fuzzer"
+
+namespace OHOS {
+namespace Media {
+class MonitorServiceStubFuzzer {
+public:
+    MonitorServiceStubFuzzer();
+    ~MonitorServiceStubFuzzer();
+    bool FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size);
+};
+}
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size);
+}
 #endif // MONITORSERVICESTUB_FUZZER
\ No newline at end of file
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/project.xml b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/project.xml
similarity index 97%
rename from test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/project.xml
rename to test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/project.xml
index 61d63a0715de022600b3ff9465d20223551325c8..7133b2b92440904a5ed04b838733acea0f97486a 100644
--- a/test/fuzztest/monitor_fuzztest/monitorservicestub_fuzzer/project.xml
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub1_fuzzer/project.xml
@@ -1,25 +1,25 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c) 2024 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.
--->
-<fuzz_config>
-  <fuzztest>
-    <!-- maximum length of a test input -->
-    <max_len>1000</max_len>
-    <!-- maximum total time in seconds to run the fuzzer -->
-    <max_total_time>300</max_total_time>
-    <!-- memory usage limit in Mb -->
-    <rss_limit_mb>4096</rss_limit_mb>
-  </fuzztest>
-</fuzz_config>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2024 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/BUILD.gn b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/BUILD.gn
similarity index 63%
rename from test/fuzztest/player_fuzztest/playerstub_fuzzer/BUILD.gn
rename to test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/BUILD.gn
index 9f5d404e66d1613c2e2ff8d4b364c266ae8a7c78..7e2b03e4c62f0c8d47cd1faf863606d53de4bfa7 100644
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/BUILD.gn
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Huawei Device Co., Ltd.
+# Copyright (c) 2024 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
@@ -15,22 +15,26 @@
 import("//build/config/features.gni")
 import("//build/test.gni")
 import("//foundation/multimedia/player_framework/config.gni")
-module_output_path = "$MODULE_OUTPUT_PATH/media_player"
+MEDIA_ROOT_DIR = "//foundation/multimedia/player_framework/"
 
 ##############################fuzztest##########################################
-ohos_fuzztest("PlayerStubFuzzTest") {
-  module_out_path = module_output_path
+ohos_fuzztest("MonitorServiceStub2FuzzTest") {
+  module_out_path = "$MODULE_OUTPUT_PATH/monitor"
   fuzz_config_file =
-      "../../../../test/fuzztest/player_fuzztest/playerstub_fuzzer"
+      "$MEDIA_ROOT_DIR/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer"
+  resource_config_file = "$MEDIA_ROOT_DIR/test/fuzztest/resource/ohos_test.xml"
 
   include_dirs = [
-    "../../../../services/services/player/ipc",
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native",
+    "$MEDIA_ROOT_DIR/services/utils/include",
+    "$MEDIA_ROOT_DIR/test/fuzztest/common/",
+    "$MEDIA_PLAYER_GRAPHIC/interfaces/innerkits/surface",
+    "../../../../services/services/monitor/ipc",
     "../../../../services/services/sa_media/ipc",
     "../../../../services/services/sa_media/server",
     "../../../../services/services/sa_media/server_manager",
-    "../../../../test/fuzztest/player_fuzztest",
-    "../../../../interfaces/inner_api/native",
-    "../../../../test/fuzztest/common",
+    "../../../../../media_foundation/interface/inner_api",
+    "../../../../../media_foundation/interface/inner_api/common",
   ]
   cflags = [
     "-std=c++17",
@@ -53,29 +57,25 @@ ohos_fuzztest("PlayerStubFuzzTest") {
     "-Wimplicit-fallthrough",
     "-Wsign-compare",
     "-Wunused-parameter",
-    "-DBINDER_IPC_32BIT",
   ]
-  if (player_framework_support_player) {
+  if (player_framework_support_monitor) {
     sources = [
       "../../../../test/fuzztest/common/stub_common.cpp",
-      "player_service_proxy_fuzzer.cpp",
-      "playerstub_fuzzer.cpp",
+      "monitorservicestub2_fuzzer.cpp",
     ]
   }
-  deps = [ "../../../../services/services:media_service" ]
+  deps = [
+    "../../../../services/services:media_service",
+    "../../../../services/utils:media_service_utils",
+  ]
   external_deps = [
     "c_utils:utils",
     "graphic_surface:surface",
     "hilog:libhilog",
     "ipc:ipc_single",
-    "player_framework:media_client",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
   ]
 
-  if (player_framework_support_lowpower_av_sink) {
-    external_deps += [
-      "drivers_interface_lpplayer:liblow_power_player_proxy_1.0",
-    ]
-  }
+  part_name = "player_framework"
 }
diff --git a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/corpus/init b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/corpus/init
similarity index 92%
rename from test/fuzztest/player_fuzztest/playerservicestub_fuzzer/corpus/init
rename to test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/corpus/init
index 8eb5a7d6eb6b7d71f0c70c244e5768d62bee6ac5..6198079a28e860189d4294f6598f8ac6804c0dff 100644
--- a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/corpus/init
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/corpus/init
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 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
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.cpp b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub2_fuzzer.cpp
similarity index 43%
rename from test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.cpp
rename to test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub2_fuzzer.cpp
index 49f003d16273948b86cb2af6ab50cca794db8c1b..61e1af5a212ed34415902759a07d9e96eaf6680c 100644
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.cpp
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub2_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 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
@@ -13,37 +13,34 @@
  * limitations under the License.
  */
 
-#include "playerstub_fuzzer.h"
+#include "monitorservicestub_fuzzer.h"
+#include <cmath>
+#include <iostream>
+#include "string_ex.h"
+#include "directory_ex.h"
 #include <unistd.h>
-#include "stub_common.h"
 #include "media_server.h"
 #include "media_parcel.h"
-#include "i_standard_player_service.h"
-#include "media_server_manager.h"
+#include "i_standard_monitor_service.h"
+#include "stub_common.h"
+
+using namespace std;
+using namespace OHOS;
+using namespace Media;
 
 namespace OHOS {
 namespace Media {
-bool FuzzPlayerStub(uint8_t *data, size_t size)
+MonitorServiceStubFuzzer::MonitorServiceStubFuzzer()
+{
+}
+
+MonitorServiceStubFuzzer::~MonitorServiceStubFuzzer()
 {
-    if (data == nullptr || size < sizeof(int64_t)) {
-        return true;
-    }
-    sptr<PlayerServiceProxyFuzzer> playerProxy = PlayerServiceProxyFuzzer::Create();
-    if (playerProxy == nullptr) {
-        return false;
-    }
-    for (uint32_t codeId = 0; codeId < PlayerServiceProxyFuzzer::MAX_IPC_ID; codeId++) {
-        if (codeId != PlayerServiceProxyFuzzer::DESTROY) {
-            playerProxy->SendRequest(codeId, data, size, true);
-        }
-    }
-    playerProxy->SendRequest(PlayerServiceProxyFuzzer::DESTROY, data, size, false);
-    return true;
 }
 
 const int32_t SYSTEM_ABILITY_ID = 3002;
 const bool RUN_ON_CREATE = false;
-bool FuzzPlayerStubLocal(uint8_t *data, size_t size)
+bool MonitorServiceStubFuzzer::FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size)
 {
     if (data == nullptr || size < sizeof(int64_t)) {
         return true;
@@ -51,40 +48,48 @@ bool FuzzPlayerStubLocal(uint8_t *data, size_t size)
     std::shared_ptr<MediaServer> mediaServer =
         std::make_shared<MediaServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     sptr<IRemoteObject> listener = new(std::nothrow) MediaListenerStubFuzzer();
-    sptr<IRemoteObject> player = mediaServer->GetSubSystemAbility(
-        IStandardMediaService::MediaSystemAbility::MEDIA_PLAYER, listener);
-    if (player == nullptr) {
+    sptr<IRemoteObject> monitor = mediaServer->GetSubSystemAbility(
+        IStandardMediaService::MediaSystemAbility::MEDIA_MONITOR, listener);
+    if (monitor == nullptr) {
         return false;
     }
 
-    sptr<IRemoteStub<IStandardPlayerService>> playerStub = iface_cast<IRemoteStub<IStandardPlayerService>>(player);
-    if (playerStub == nullptr) {
+    sptr<IRemoteStub<IStandardMonitorService>> monitorStub =
+        iface_cast<IRemoteStub<IStandardMonitorService>>(monitor);
+    if (monitorStub == nullptr) {
         return false;
     }
 
-    bool isWirteToken = size >0 && data[0] % 9 != 0;
-    for (uint32_t code = 0; code <= PlayerServiceProxyFuzzer::MAX_IPC_ID; code++) {
-        MessageParcel msg;
-        if (isWirteToken) {
-            msg.WriteInterfaceToken(playerStub->GetDescriptor());
-        }
-        msg.WriteBuffer(data, size);
-        msg.RewindRead(0);
-        MessageParcel reply;
-        MessageOption option;
-        playerStub->OnRemoteRequest(code, msg, reply, option);
-    }
-    MediaServerManager::GetInstance().DestoryMemoryReportTask();
+    uint32_t code = 1;
+    MessageParcel msg;
+    msg.WriteInterfaceToken(monitorStub->GetDescriptor());
+    msg.WriteBuffer(data, size);
+    msg.RewindRead(0);
+    MessageParcel reply;
+    MessageOption option;
+    monitorStub->OnRemoteRequest(code, msg, reply, option);
     return true;
 }
 }
+
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size)
+{
+    if (data == nullptr) {
+        return true;
+    }
+
+    if (size < sizeof(int32_t)) {
+        return true;
+    }
+    MonitorServiceStubFuzzer testMonitor;
+    return testMonitor.FuzzMonitorOnRemoteRequest(data, size);
+}
 }
 
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
 {
     /* Run your code on data */
-    OHOS::Media::FuzzPlayerStub(data, size);
-    OHOS::Media::FuzzPlayerStubLocal(data, size);
+    OHOS::FuzzTestMonitorOnRemoteRequest(data, size);
     return 0;
 }
\ No newline at end of file
diff --git a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.h b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub_fuzzer.h
similarity index 53%
rename from test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.h
rename to test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub_fuzzer.h
index a5d6386b4ea356ac6fa2be2f0df06582ea8080e6..41dc6a3991889160d83bdf74910229bc05e52cc1 100644
--- a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.h
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/monitorservicestub_fuzzer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 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
@@ -13,22 +13,27 @@
  * limitations under the License.
  */
 
-#ifndef PLAYERSERVICESTUB_FUZZER
-#define PLAYERSERVICESTUB_FUZZER
+#ifndef MONITORSERVICESTUB_FUZZER
+#define MONITORSERVICESTUB_FUZZER
 
-#define FUZZ_PROJECT_NAME "playerservicestub_fuzzer"
-#include "i_standard_media_service.h"
+#include <cstdint>
+#include <unistd.h>
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <fcntl.h>
+
+#define FUZZ_PROJECT_NAME "monitorservicestub_fuzzer"
 
 namespace OHOS {
 namespace Media {
-class PlayerServiceStubFuzzer {
+class MonitorServiceStubFuzzer {
 public:
-    PlayerServiceStubFuzzer();
-    ~PlayerServiceStubFuzzer();
-    bool FuzzServiceStub(uint8_t *data, size_t size);
+    MonitorServiceStubFuzzer();
+    ~MonitorServiceStubFuzzer();
+    bool FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size);
 };
 }
-bool FuzzPlayerServiceStub(uint8_t *data, size_t size);
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size);
 }
-
-#endif // PLAYERSERVICESTUB_FUZZER
+#endif // MONITORSERVICESTUB_FUZZER
\ No newline at end of file
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/project.xml b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/project.xml
similarity index 95%
rename from test/fuzztest/player_fuzztest/playerstub_fuzzer/project.xml
rename to test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/project.xml
index 4fdbc407f205680885fa42663163b5c987f123a6..7133b2b92440904a5ed04b838733acea0f97486a 100644
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/project.xml
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub2_fuzzer/project.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c) 2023 Huawei Device Co., Ltd.
+<!-- Copyright (c) 2024 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.
diff --git a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/BUILD.gn b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/BUILD.gn
similarity index 55%
rename from test/fuzztest/player_fuzztest/playerservicestub_fuzzer/BUILD.gn
rename to test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/BUILD.gn
index 842919407d70e485abcb899a90c2091578f71adb..9e7e07f656e2fa7ffe1422a121f91566e4123510 100644
--- a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/BUILD.gn
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Copyright (c) 2024 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
@@ -15,20 +15,26 @@
 import("//build/config/features.gni")
 import("//build/test.gni")
 import("//foundation/multimedia/player_framework/config.gni")
-module_output_path = "$MODULE_OUTPUT_PATH/media_player"
+MEDIA_ROOT_DIR = "//foundation/multimedia/player_framework/"
 
 ##############################fuzztest##########################################
-ohos_fuzztest("PlayerServiceStubFuzzTest") {
-  module_out_path = module_output_path
+ohos_fuzztest("MonitorServiceStub3FuzzTest") {
+  module_out_path = "$MODULE_OUTPUT_PATH/monitor"
   fuzz_config_file =
-      "../../../../test/fuzztest/player_fuzztest/playerservicestub_fuzzer"
+      "$MEDIA_ROOT_DIR/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer"
+  resource_config_file = "$MEDIA_ROOT_DIR/test/fuzztest/resource/ohos_test.xml"
 
   include_dirs = [
-    "../../../../services/include",
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native",
+    "$MEDIA_ROOT_DIR/services/utils/include",
+    "$MEDIA_ROOT_DIR/test/fuzztest/common/",
+    "$MEDIA_PLAYER_GRAPHIC/interfaces/innerkits/surface",
+    "../../../../services/services/monitor/ipc",
     "../../../../services/services/sa_media/ipc",
-    "../../../../test/fuzztest/player_fuzztest",
-    "../../../../interfaces/inner_api/native",
-    "../../../../test/fuzztest/common",
+    "../../../../services/services/sa_media/server",
+    "../../../../services/services/sa_media/server_manager",
+    "../../../../../media_foundation/interface/inner_api",
+    "../../../../../media_foundation/interface/inner_api/common",
   ]
   cflags = [
     "-std=c++17",
@@ -51,24 +57,25 @@ ohos_fuzztest("PlayerServiceStubFuzzTest") {
     "-Wimplicit-fallthrough",
     "-Wsign-compare",
     "-Wunused-parameter",
-    "-DBINDER_IPC_32BIT",
   ]
-  if (player_framework_support_player) {
-    sources = [ "playerservicestub_fuzzer.cpp" ]
+  if (player_framework_support_monitor) {
+    sources = [
+      "../../../../test/fuzztest/common/stub_common.cpp",
+      "monitorservicestub3_fuzzer.cpp",
+    ]
   }
-  deps = [ "../../../../services/services:media_service" ]
+  deps = [
+    "../../../../services/services:media_service",
+    "../../../../services/utils:media_service_utils",
+  ]
   external_deps = [
     "c_utils:utils",
     "graphic_surface:surface",
+    "hilog:libhilog",
     "ipc:ipc_single",
-    "player_framework:media_client",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
   ]
 
-  if (player_framework_support_lowpower_av_sink) {
-    external_deps += [
-      "drivers_interface_lpplayer:liblow_power_player_proxy_1.0",
-    ]
-  }
+  part_name = "player_framework"
 }
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/corpus/init b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/corpus/init
similarity index 90%
rename from test/fuzztest/player_fuzztest/playerstub_fuzzer/corpus/init
rename to test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/corpus/init
index 1cb3a7baa0485faa069997d9e5078d593628123c..6198079a28e860189d4294f6598f8ac6804c0dff 100644
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/corpus/init
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/corpus/init
@@ -1,16 +1,16 @@
-/*
- * Copyright (c) 2023 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.
- */
-
+/*
+ * Copyright (c) 2024 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.
+ */
+
 FUZZ
\ No newline at end of file
diff --git a/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub3_fuzzer.cpp b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub3_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..554c825050e0dca6efaf8ef7bd2da04b38773f99
--- /dev/null
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub3_fuzzer.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2024 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 "monitorservicestub_fuzzer.h"
+#include <cmath>
+#include <iostream>
+#include "string_ex.h"
+#include "directory_ex.h"
+#include <unistd.h>
+#include "media_server.h"
+#include "media_parcel.h"
+#include "i_standard_monitor_service.h"
+#include "stub_common.h"
+
+using namespace std;
+using namespace OHOS;
+using namespace Media;
+
+namespace OHOS {
+namespace Media {
+MonitorServiceStubFuzzer::MonitorServiceStubFuzzer()
+{
+}
+
+MonitorServiceStubFuzzer::~MonitorServiceStubFuzzer()
+{
+}
+
+const int32_t SYSTEM_ABILITY_ID = 3002;
+const bool RUN_ON_CREATE = false;
+bool MonitorServiceStubFuzzer::FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int64_t)) {
+        return true;
+    }
+    std::shared_ptr<MediaServer> mediaServer =
+        std::make_shared<MediaServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
+    sptr<IRemoteObject> listener = new(std::nothrow) MediaListenerStubFuzzer();
+    sptr<IRemoteObject> monitor = mediaServer->GetSubSystemAbility(
+        IStandardMediaService::MediaSystemAbility::MEDIA_MONITOR, listener);
+    if (monitor == nullptr) {
+        return false;
+    }
+
+    sptr<IRemoteStub<IStandardMonitorService>> monitorStub =
+        iface_cast<IRemoteStub<IStandardMonitorService>>(monitor);
+    if (monitorStub == nullptr) {
+        return false;
+    }
+
+    uint32_t code = 2;
+    MessageParcel msg;
+    msg.WriteInterfaceToken(monitorStub->GetDescriptor());
+    msg.WriteBuffer(data, size);
+    msg.RewindRead(0);
+    MessageParcel reply;
+    MessageOption option;
+    monitorStub->OnRemoteRequest(code, msg, reply, option);
+    return true;
+}
+}
+
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size)
+{
+    if (data == nullptr) {
+        return true;
+    }
+
+    if (size < sizeof(int32_t)) {
+        return true;
+    }
+    MonitorServiceStubFuzzer testMonitor;
+    return testMonitor.FuzzMonitorOnRemoteRequest(data, size);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::FuzzTestMonitorOnRemoteRequest(data, size);
+    return 0;
+}
\ No newline at end of file
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.h b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub_fuzzer.h
similarity index 52%
rename from test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.h
rename to test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub_fuzzer.h
index a7f38652086653693dd513737098cce7e93528aa..41dc6a3991889160d83bdf74910229bc05e52cc1 100644
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/playerstub_fuzzer.h
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/monitorservicestub_fuzzer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 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
@@ -13,15 +13,27 @@
  * limitations under the License.
  */
 
-#ifndef PLAYERSTUB_FUZZER_H
-#define PLAYERSTUB_FUZZER_H
+#ifndef MONITORSERVICESTUB_FUZZER
+#define MONITORSERVICESTUB_FUZZER
 
-#define FUZZ_PROJECT_NAME "playerstub_fuzzer"
-#include "player_service_proxy_fuzzer.h"
+#include <cstdint>
+#include <unistd.h>
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <fcntl.h>
+
+#define FUZZ_PROJECT_NAME "monitorservicestub_fuzzer"
 
 namespace OHOS {
 namespace Media {
-bool FuzzPlayerStub(uint8_t *data, size_t size);
+class MonitorServiceStubFuzzer {
+public:
+    MonitorServiceStubFuzzer();
+    ~MonitorServiceStubFuzzer();
+    bool FuzzMonitorOnRemoteRequest(uint8_t *data, size_t size);
+};
 }
+bool FuzzTestMonitorOnRemoteRequest(uint8_t *data, size_t size);
 }
-#endif // PLAYERSTUB_FUZZER_H
\ No newline at end of file
+#endif // MONITORSERVICESTUB_FUZZER
\ No newline at end of file
diff --git a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/project.xml b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/project.xml
similarity index 95%
rename from test/fuzztest/player_fuzztest/playerservicestub_fuzzer/project.xml
rename to test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/project.xml
index 6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec..7133b2b92440904a5ed04b838733acea0f97486a 100644
--- a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/project.xml
+++ b/test/fuzztest/monitor_fuzztest/monitorservicestub3_fuzzer/project.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+<!-- Copyright (c) 2024 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.
diff --git a/test/fuzztest/player_fuzztest/playerapi_fuzzer/playerapi_fuzzer.cpp b/test/fuzztest/player_fuzztest/playerapi_fuzzer/playerapi_fuzzer.cpp
index d0987fa81695147b73960fd990544866b2dc9a6b..fc7d9047ddb049d2d304646cda69dd5ab1bacfba 100644
--- a/test/fuzztest/player_fuzztest/playerapi_fuzzer/playerapi_fuzzer.cpp
+++ b/test/fuzztest/player_fuzztest/playerapi_fuzzer/playerapi_fuzzer.cpp
@@ -119,7 +119,7 @@ bool PlayerApiFuzzer::RunFuzz(uint8_t *data, size_t size)
     sleep(PLAY_TIME_1_SEC);
     SelectTrack(playerStub);
     FuzzedDataProvider fdp(data, size);
-    int seekTime = abs(fdp.ConsumeIntegral<int32_t>())%g_duration;
+    int seekTime = 1;
     playerStub->Seek(seekTime, SEEK_NEXT_SYNC);
     sleep(PLAY_TIME_1_SEC);
     playerStub->Play();
diff --git a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.cpp b/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.cpp
deleted file mode 100644
index 2adbafc081346fc1b7c62defd29d5958e295d34e..0000000000000000000000000000000000000000
--- a/test/fuzztest/player_fuzztest/playerservicestub_fuzzer/playerservicestub_fuzzer.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2022 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 "playerservicestub_fuzzer.h"
-#include <iostream>
-#include "i_standard_media_listener.h"
-#include "iservice_registry.h"
-#include "system_ability_definition.h"
-
-using namespace std;
-using namespace OHOS;
-using namespace OHOS::Media;
-
-namespace OHOS {
-namespace Media {
-class PlayerServiceListenerStubFuzzer : public IRemoteStub<IStandardMediaListener>, public NoCopyable {
-public:
-    PlayerServiceListenerStubFuzzer() = default;
-    ~PlayerServiceListenerStubFuzzer() = default;
-};
-
-class MediaServiceProxyFuzzer : public IRemoteProxy<IStandardMediaService>, public NoCopyable {
-public:
-    explicit MediaServiceProxyFuzzer(const sptr<IRemoteObject> &impl) : IRemoteProxy<IStandardMediaService>(impl) {}
-    virtual ~MediaServiceProxyFuzzer() {}
-
-    sptr<IRemoteObject> GetSubSystemAbility(IStandardMediaService::MediaSystemAbility subSystemId,
-        const sptr<IRemoteObject> &listener)
-    {
-        MessageParcel data;
-        MessageParcel reply;
-        MessageOption option;
-
-        bool token = data.WriteInterfaceToken(MediaServiceProxyFuzzer::GetDescriptor());
-        if (!token) {
-            cout << "Failed to write descriptor!" << endl;
-            return nullptr;
-        }
-        (void)data.WriteInt32(static_cast<int32_t>(subSystemId));
-        (void)data.WriteRemoteObject(listener);
-        (void)Remote()->SendRequest(MediaServiceMsg::GET_SUBSYSTEM, data, reply, option);
-        return reply.ReadRemoteObject();
-    }
-
-    sptr<IRemoteObject> GetSubSystemAbilityWithTimeOut(IStandardMediaService::MediaSystemAbility subSystemId,
-        const sptr<IRemoteObject> &listener, uint32_t timeoutMs)
-    {
-        (void) timeoutMs;
-        return GetSubSystemAbility(subSystemId, listener);
-    }
-
-    void ReleaseClientListener()
-    {
-        MessageParcel data;
-        MessageParcel reply;
-        MessageOption option;
-        (void)Remote()->SendRequest(MediaServiceMsg::RELEASE_CLIENT_LISTENER, data, reply, option);
-    }
-
-    bool CanKillMediaService()
-    {
-        MessageParcel data;
-        MessageParcel reply;
-        MessageOption option;
-        (void)Remote()->SendRequest(MediaServiceMsg::CAN_KILL_MEDIA_SERVICE, data, reply, option);
-        return reply.ReadBool();
-    }
-
-    std::vector<pid_t> GetPlayerPids()
-    {
-        MessageParcel data;
-        MessageParcel reply;
-        MessageOption option;
-        (void)Remote()->SendRequest(MediaServiceMsg::GET_PLAYER_PIDS, data, reply, option);
-        std::vector<pid_t> res;
-        return res;
-    }
-
-    int32_t FreezeStubForPids(const std::set<int32_t> &pidList, bool isProxy)
-    {
-        (void)pidList;
-        (void)isProxy;
-        return 0;
-    }
-
-    int32_t ResetAllProxy()
-    {
-        return 0;
-    }
-
-    int32_t GetLppCapacity(LppAvCapabilityInfo &lppAvCapability)
-    {
-        (void)lppAvCapability;
-        return 0;
-    }
-private:
-    static inline BrokerDelegator<MediaServiceProxyFuzzer> delegator_;
-};
-
-PlayerServiceStubFuzzer::PlayerServiceStubFuzzer()
-{
-}
-
-PlayerServiceStubFuzzer::~PlayerServiceStubFuzzer()
-{
-}
-
-bool PlayerServiceStubFuzzer::FuzzServiceStub(uint8_t *data, size_t size)
-{
-    constexpr int32_t subSystemIdList = 8;
-    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    sptr<IRemoteObject> object = samgr->GetSystemAbility(OHOS::PLAYER_DISTRIBUTED_SERVICE_ID);
-    if (object == nullptr) {
-        cout << "media object is nullptr." << endl;
-        return false;
-    }
-    sptr<IStandardMediaService> mediaProxy_ = nullptr;
-    mediaProxy_ = iface_cast<IStandardMediaService>(object);
-    if (mediaProxy_ == nullptr) {
-        cout << "media proxy is nullptr." << endl;
-        return false;
-    }
-    sptr<IRemoteObject> listenerStub_ = nullptr;
-    listenerStub_ = new(std::nothrow) PlayerServiceListenerStubFuzzer();
-
-    IStandardMediaService::MediaSystemAbility subSystemId[subSystemIdList] {
-            IStandardMediaService::MediaSystemAbility::MEDIA_PLAYER,
-            IStandardMediaService::MediaSystemAbility::MEDIA_RECORDER,
-            IStandardMediaService::MediaSystemAbility::MEDIA_CODEC,
-            IStandardMediaService::MediaSystemAbility::MEDIA_AVMETADATAHELPER,
-            IStandardMediaService::MediaSystemAbility::MEDIA_CODECLIST,
-            IStandardMediaService::MediaSystemAbility::MEDIA_AVCODEC,
-            IStandardMediaService::MediaSystemAbility::RECORDER_PROFILES,
-        };
-    int32_t systemId = *reinterpret_cast<int32_t *>(data) % (subSystemIdList);
-    mediaProxy_->GetSubSystemAbility(subSystemId[systemId], listenerStub_);
-    return true;
-}
-}
-
-bool FuzzPlayerServiceStub(uint8_t *data, size_t size)
-{
-    if ((data == nullptr) || (size < sizeof(int32_t))) {
-        return true;
-    }
-    PlayerServiceStubFuzzer player;
-    return player.FuzzServiceStub(data, size);
-}
-}
-
-/* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
-{
-    /* Run your code on data */
-    OHOS::FuzzPlayerServiceStub(data, size);
-    return 0;
-}
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.cpp b/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.cpp
deleted file mode 100644
index 1bac51eaf29ef215e8b2cbe5f2d144ddc893e484..0000000000000000000000000000000000000000
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.cpp
+++ /dev/null
@@ -1,846 +0,0 @@
-/*
- * Copyright (c) 2023-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 "player_service_proxy_fuzzer.h"
-#include <iostream>
-#include <fcntl.h>
-#include <unistd.h>
-#include "directory_ex.h"
-#include "media_parcel.h"
-
-namespace OHOS {
-namespace Media {
-namespace {
-    using Fuzzer = PlayerServiceProxyFuzzer;
-    using PlayerStubFunc = std::function<int32_t(Fuzzer*, uint8_t*, size_t, bool)>;
-    std::map<uint32_t, PlayerStubFunc> playerFuncs_ {
-        {Fuzzer::SET_LISTENER_OBJ, Fuzzer::SetListenerObjectStatic},
-        {Fuzzer::SET_SOURCE, Fuzzer::SetSourceStatic},
-        {Fuzzer::SET_MEDIA_DATA_SRC_OBJ, Fuzzer::SetMediaDataSourceStatic},
-        {Fuzzer::SET_FD_SOURCE, Fuzzer::SetFdSourceStatic},
-        {Fuzzer::ADD_SUB_SOURCE, Fuzzer::AddSubSourceStatic},
-        {Fuzzer::ADD_SUB_FD_SOURCE, Fuzzer::AddSubFdSourceStatic},
-        {Fuzzer::PLAY, Fuzzer::PlayStatic},
-        {Fuzzer::PREPARE, Fuzzer::PrepareStatic},
-        {Fuzzer::PREPAREASYNC, Fuzzer::PrepareAsyncStatic},
-        {Fuzzer::PAUSE, Fuzzer::PauseStatic},
-        {Fuzzer::STOP, Fuzzer::StopStatic},
-        {Fuzzer::RESET, Fuzzer::ResetStatic},
-        {Fuzzer::RELEASE, Fuzzer::ReleaseStatic},
-        {Fuzzer::SET_VOLUME, Fuzzer::SetVolumeStatic},
-        {Fuzzer::SEEK, Fuzzer::SeekStatic},
-        {Fuzzer::GET_CURRENT_TIME, Fuzzer::GetCurrentTimeStatic},
-        {Fuzzer::GET_PLAY_BACK_POSITION, Fuzzer::GetPlaybackPositionStatic},
-        {Fuzzer::GET_DURATION, Fuzzer::GetDurationStatic},
-        {Fuzzer::SET_PLAYERBACK_SPEED, Fuzzer::SetPlaybackSpeedStatic},
-        {Fuzzer::GET_PLAYERBACK_SPEED, Fuzzer::GetPlaybackSpeedStatic},
-        {Fuzzer::SET_VIDEO_SURFACE, Fuzzer::SetVideoSurfaceStatic},
-        {Fuzzer::IS_PLAYING, Fuzzer::IsPlayingStatic},
-        {Fuzzer::IS_LOOPING, Fuzzer::IsLoopingStatic},
-        {Fuzzer::SET_LOOPING, Fuzzer::SetLoopingStatic},
-        {Fuzzer::SET_RENDERER_DESC, Fuzzer::SetParameterStatic},
-        {Fuzzer::DESTROY, Fuzzer::DestroyStubStatic},
-        {Fuzzer::SET_CALLBACK, Fuzzer::SetPlayerCallbackStatic},
-        {Fuzzer::GET_VIDEO_TRACK_INFO, Fuzzer::GetVideoTrackInfoStatic},
-        {Fuzzer::GET_AUDIO_TRACK_INFO, Fuzzer::GetAudioTrackInfoStatic},
-        {Fuzzer::GET_SUBTITLE_TRACK_INFO, Fuzzer::GetSubtitleTrackInfoStatic},
-        {Fuzzer::GET_VIDEO_WIDTH, Fuzzer::GetVideoWidthStatic},
-        {Fuzzer::GET_VIDEO_HEIGHT, Fuzzer::GetVideoHeightStatic},
-        {Fuzzer::SELECT_BIT_RATE, Fuzzer::SelectBitRateStatic},
-        {Fuzzer::SELECT_TRACK, Fuzzer::SelectTrackStatic},
-        {Fuzzer::DESELECT_TRACK, Fuzzer::DeselectTrackStatic},
-        {Fuzzer::GET_CURRENT_TRACK, Fuzzer::GetCurrentTrackStatic},
-    };
-}
-PlayerServiceProxyFuzzer::PlayerServiceProxyFuzzer(const sptr<IRemoteObject> &impl)
-    : IRemoteProxy<IStandardPlayerService>(impl)
-{
-}
-
-sptr<PlayerServiceProxyFuzzer> PlayerServiceProxyFuzzer::Create()
-{
-    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    sptr<IRemoteObject> object = samgr->GetSystemAbility(OHOS::PLAYER_DISTRIBUTED_SERVICE_ID);
-    if (object == nullptr) {
-        std::cout << "media object is nullptr." << std::endl;
-        return nullptr;
-    }
-    sptr<IStandardMediaService> mediaProxy = iface_cast<IStandardMediaService>(object);
-    if (mediaProxy == nullptr) {
-        std::cout << "mediaProxy is nullptr." << std::endl;
-        return nullptr;
-    }
-    sptr<IRemoteObject> listenerStub = new(std::nothrow) MediaListenerStubFuzzer();
-    sptr<IRemoteObject> playerObject = mediaProxy->GetSubSystemAbility(
-        IStandardMediaService::MediaSystemAbility::MEDIA_PLAYER, listenerStub);
-    if (playerObject == nullptr) {
-        std::cout << "playerObject is nullptr." << std::endl;
-        return nullptr;
-    }
-
-    sptr<PlayerServiceProxyFuzzer> playerProxy = iface_cast<PlayerServiceProxyFuzzer>(playerObject);
-    if (playerProxy == nullptr) {
-        std::cout << "playerProxy is nullptr." << std::endl;
-        return nullptr;
-    }
-    return playerProxy;
-}
-
-void PlayerServiceProxyFuzzer::SendRequest(uint32_t code, uint8_t *inputData, size_t size, bool isFuzz)
-{
-    auto itFunc = playerFuncs_.find(code);
-    if (itFunc != playerFuncs_.end()) {
-        auto memberFunc = itFunc->second;
-        if (memberFunc != nullptr) {
-            memberFunc(this, inputData, size, isFuzz);
-        }
-    }
-}
-
-int32_t PlayerServiceProxyFuzzer::SetListenerObjectStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_LISTENER_OBJ, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Failed to write descriptor" << std::endl;
-        return false;
-    }
-    std::string urlStr(reinterpret_cast<const char *>(inputData), size);
-    (void)data.WriteString(urlStr);
-    return ptr->SendRequest(SET_SOURCE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetMediaDataSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetMediaDataSource:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_MEDIA_DATA_SRC_OBJ, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetFdSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetFdSource:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    int32_t fdValue;
-    int64_t offsetValue;
-    int64_t lengthValue;
-    if (isFuzz) {
-        fdValue = *reinterpret_cast<int32_t *>(inputData);
-        lengthValue = *reinterpret_cast<int64_t *>(inputData);
-        offsetValue = *reinterpret_cast<uint32_t *>(inputData) % *reinterpret_cast<int64_t *>(inputData);
-        (void)data.WriteFileDescriptor(fdValue);
-        (void)data.WriteInt64(offsetValue);
-        (void)data.WriteInt64(lengthValue);
-        return ptr->SendRequest(SET_FD_SOURCE, data, reply, option);
-    } else {
-        const std::string path = "/data/test/media/H264_AAC.mp4";
-        fdValue = open(path.c_str(), O_RDONLY);
-        offsetValue = 0;
-        if (fdValue < 0) {
-            std::cout << "Open file failed" << std::endl;
-            (void)close(fdValue);
-            return -1;
-        }
-
-        struct stat64 buffer;
-        if (fstat64(fdValue, &buffer) != 0) {
-            std::cout << "Get file state failed" << std::endl;
-            (void)close(fdValue);
-            return -1;
-        }
-        lengthValue = static_cast<int64_t>(buffer.st_size);
-        (void)data.WriteFileDescriptor(fdValue);
-        (void)data.WriteInt64(offsetValue);
-        (void)data.WriteInt64(lengthValue);
-        int32_t ret = ptr->SendRequest(SET_FD_SOURCE, data, reply, option);
-        (void)close(fdValue);
-        return ret;
-    }
-}
-
-int32_t PlayerServiceProxyFuzzer::AddSubSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "AddSubSource:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    std::string url(reinterpret_cast<const char *>(inputData), size);
-    (void)data.WriteString(url);
-    return ptr->SendRequest(ADD_SUB_SOURCE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::AddSubFdSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "AddSubFdSource:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    int32_t fdValue = *reinterpret_cast<int32_t *>(inputData);
-    int64_t lengthValue = *reinterpret_cast<int64_t *>(inputData);
-    int64_t offsetValue = *reinterpret_cast<uint32_t *>(inputData) % *reinterpret_cast<int64_t *>(inputData);
-    (void)data.WriteFileDescriptor(fdValue);
-    (void)data.WriteInt64(offsetValue);
-    (void)data.WriteInt64(lengthValue);
-    return ptr->SendRequest(ADD_SUB_FD_SOURCE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::PlayStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Play:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(PLAY, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::PrepareStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Prepare:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(PREPARE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::PrepareAsyncStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "PrepareAsync:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(PREPAREASYNC, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::PauseStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Pause:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(PAUSE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::StopStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Stop:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(STOP, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::ResetStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Reset:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(RESET, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::ReleaseStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Release:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(RELEASE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetVolumeStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetVolume:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteFloat(*reinterpret_cast<int32_t *>(inputData));
-    (void)data.WriteFloat(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_VOLUME, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SeekStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Seek:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SEEK, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetCurrentTimeStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetCurrentTime:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_CURRENT_TIME, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetPlaybackPositionStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetPlaybackPosition:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_PLAY_BACK_POSITION, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetDurationStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetDuration:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_DURATION, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetPlaybackSpeedStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetPlaybackSpeed:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_PLAYERBACK_SPEED, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetPlaybackSpeedStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetPlaybackSpeed:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_PLAYERBACK_SPEED, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetVideoSurfaceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetVideoSurface:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_VIDEO_SURFACE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::IsPlayingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "IsPlaying:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(IS_PLAYING, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::IsLoopingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "IsLooping:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(IS_LOOPING, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetLoopingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-    bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetLooping:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-    (void)data.WriteBool(*reinterpret_cast<int32_t *>(inputData) % 2);  // 2 true or false
-    return ptr->SendRequest(SET_LOOPING, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetParameterStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_RENDERER_DESC, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::DestroyStubStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    if (isFuzz) {
-        (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    }
-    return ptr->SendRequest(DESTROY, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SetPlayerCallbackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SetPlayerCallback:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SET_CALLBACK, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetVideoTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetVideoTrackInfo:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_VIDEO_TRACK_INFO, data, reply, option);
-}
-
-
-int32_t PlayerServiceProxyFuzzer::GetPlaybackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetPlaybackInfo:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_PLAYBACK_INFO, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetAudioTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetAudioTrackInfo:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_AUDIO_TRACK_INFO, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetSubtitleTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetSubtitleTrackInfo:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_SUBTITLE_TRACK_INFO, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetVideoWidthStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetVideoWidth:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_VIDEO_WIDTH, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetVideoHeightStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetVideoHeight:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_VIDEO_HEIGHT, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SelectBitRateStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SelectBitRate:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SELECT_BIT_RATE, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SelectTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "SelectTrack:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(SELECT_TRACK, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::DeselectTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "DeselectTrack:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(DESELECT_TRACK, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::GetCurrentTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData,
-    size_t size, bool isFuzz)
-{
-    (void)size;
-    (void)isFuzz;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    bool token = data.WriteInterfaceToken(PlayerServiceProxyFuzzer::GetDescriptor());
-    if (!token) {
-        std::cout << "GetCurrentTrack:Failed to write descriptor!" << std::endl;
-        return false;
-    }
-
-    (void)data.WriteInt32(*reinterpret_cast<int32_t *>(inputData));
-    return ptr->SendRequest(GET_CURRENT_TRACK, data, reply, option);
-}
-
-int32_t PlayerServiceProxyFuzzer::SendRequest(uint32_t code,
-    MessageParcel &data, MessageParcel &reply, MessageOption &option)
-{
-    return Remote()->SendRequest(code, data, reply, option);
-}
-}
-}
\ No newline at end of file
diff --git a/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.h b/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.h
deleted file mode 100644
index cffc08962fc4781545cfff8b54f08a9419cd33a4..0000000000000000000000000000000000000000
--- a/test/fuzztest/player_fuzztest/playerstub_fuzzer/player_service_proxy_fuzzer.h
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Copyright (c) 2023-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 PLAYER_SERVICE_PROXY_FUZZER_H
-#define PLAYER_SERVICE_PROXY_FUZZER_H
-
-#include "stub_common.h"
-#include "i_standard_player_service.h"
-
-namespace OHOS {
-namespace Media {
-class PlayerServiceProxyFuzzer : public IRemoteProxy<IStandardPlayerService> {
-public:
-    static sptr<PlayerServiceProxyFuzzer> Create();
-    explicit PlayerServiceProxyFuzzer(const sptr<IRemoteObject> &impl);
-    virtual ~PlayerServiceProxyFuzzer() {}
-    void SendRequest(uint32_t code, uint8_t *inputData, size_t size, bool isFuzz);
-    int32_t SetListenerObject(const sptr<IRemoteObject> &object) override
-    {
-        return 0;
-    }
-    int32_t SetPlayerProducer(const PlayerProducer producer) override
-    {
-        return 0;
-    }
-    int32_t SetSource(const std::string &url) override
-    {
-        return 0;
-    }
-    int32_t SetSource(const sptr<IRemoteObject> &object) override
-    {
-        return 0;
-    }
-    int32_t SetSource(int32_t fd, int64_t offset, int64_t size) override
-    {
-        return 0;
-    }
-    int32_t SetMediaSource(const std::shared_ptr<AVMediaSource> &mediaSource, AVPlayStrategy strategy) override
-    {
-        return 0;
-    }
-    int32_t SetSourceLoader(const sptr<IRemoteObject> &object) override
-    {
-        return 0;
-    }
-    int32_t AddSubSource(const std::string &url) override
-    {
-        return 0;
-    }
-    int32_t AddSubSource(int32_t fd, int64_t offset, int64_t size) override
-    {
-        return 0;
-    }
-    int32_t Play() override
-    {
-        return 0;
-    }
-    int32_t Prepare() override
-    {
-        return 0;
-    }
-    int32_t PrepareAsync() override
-    {
-        return 0;
-    }
-    int32_t Pause() override
-    {
-        return 0;
-    }
-    int32_t Stop() override
-    {
-        return 0;
-    }
-    int32_t Reset() override
-    {
-        return 0;
-    }
-    int32_t Release() override
-    {
-        return 0;
-    }
-    int32_t ReleaseSync() override
-    {
-        return 0;
-    }
-    int32_t SetVolume(float leftVolume, float rightVolume) override
-    {
-        return 0;
-    }
-    int32_t SetVolumeMode(int32_t mode) override
-    {
-        return 0;
-    }
-    int32_t Seek(int32_t mSeconds, PlayerSeekMode mode) override
-    {
-        return 0;
-    }
-    int32_t GetCurrentTime(int32_t &currentTime) override
-    {
-        return 0;
-    }
-    int32_t GetVideoTrackInfo(std::vector<Format> &videoTrack) override
-    {
-        return 0;
-    }
-    int32_t GetPlaybackInfo(Format& playbackInfo) override
-    {
-        return 0;
-    }
-    int32_t GetAudioTrackInfo(std::vector<Format> &audioTrack) override
-    {
-        return 0;
-    }
-    int32_t GetSubtitleTrackInfo(std::vector<Format> &subtitleTrack) override
-    {
-        return 0;
-    }
-    int32_t GetVideoWidth() override
-    {
-        return 0;
-    }
-    int32_t GetVideoHeight() override
-    {
-        return 0;
-    }
-    int32_t GetDuration(int32_t &duration) override
-    {
-        return 0;
-    }
-    int32_t SetPlaybackSpeed(PlaybackRateMode mode) override
-    {
-        return 0;
-    }
-    int32_t SetPlaybackRate(float rate) override
-    {
-        return 0;
-    }
-    int32_t GetPlaybackSpeed(PlaybackRateMode &mode) override
-    {
-        return 0;
-    }
-    int32_t SetVideoSurface(sptr<Surface> surface) override
-    {
-        return 0;
-    }
-    bool IsPlaying() override
-    {
-        return 0;
-    }
-    bool IsLooping() override
-    {
-        return 0;
-    }
-    int32_t SetLooping(bool loop) override
-    {
-        return 0;
-    }
-    int32_t SetParameter(const Format &param) override
-    {
-        return 0;
-    }
-    int32_t DestroyStub() override
-    {
-        return 0;
-    }
-    int32_t SetPlayerCallback() override
-    {
-        return 0;
-    }
-    int32_t SelectBitRate(uint32_t bitRate) override
-    {
-        return 0;
-    }
-    int32_t SelectTrack(int32_t index, PlayerSwitchMode mode) override
-    {
-        return 0;
-    }
-    int32_t DeselectTrack(int32_t index) override
-    {
-        return 0;
-    }
-    int32_t GetCurrentTrack(int32_t trackType, int32_t &index) override
-    {
-        return 0;
-    }
-    int32_t SetDecryptConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySessionProxy,
-        bool svp) override
-    {
-        return 0;
-    }
-    int32_t SetMediaMuted(MediaType mediaType, bool isMuted) override
-    {
-        return 0;
-    }
-    static int32_t SetListenerObjectStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetMediaDataSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-        bool isFuzz);
-    static int32_t SetFdSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t AddSubSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t AddSubFdSourceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t PlayStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t PrepareStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t PrepareAsyncStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t PauseStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t StopStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t ResetStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t ReleaseStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetVolumeStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SeekStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetCurrentTimeStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetPlaybackPositionStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-        bool isFuzz);
-    static int32_t GetDurationStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetPlaybackSpeedStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetPlaybackSpeedStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetVideoSurfaceStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t IsPlayingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t IsLoopingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetLoopingStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetParameterStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t DestroyStubStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SetPlayerCallbackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetVideoTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetPlaybackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetAudioTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetSubtitleTrackInfoStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size,
-        bool isFuzz);
-    static int32_t GetVideoWidthStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetVideoHeightStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SelectBitRateStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t SelectTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t DeselectTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-    static int32_t GetCurrentTrackStatic(PlayerServiceProxyFuzzer* ptr, uint8_t *inputData, size_t size, bool isFuzz);
-
-private:
-    int32_t SendRequest(uint32_t code, MessageParcel &inputData, MessageParcel &reply, MessageOption &option);
-    static inline BrokerDelegator<PlayerServiceProxyFuzzer> delegator_;
-};
-}
-}
-
-#endif // PLAYER_SERVICE_PROXY_FUZZER_H
-