diff --git a/common/BUILD.gn b/common/BUILD.gn
index ad283415b812d2034cc304b0f740b59468d00516..e2790d3b163fb4618ae121670a1c562c95edc513 100644
--- a/common/BUILD.gn
+++ b/common/BUILD.gn
@@ -16,6 +16,11 @@ import("../multimedia_camera_framework.gni")
 
 config("camera_utils_config") {
   include_dirs = [
+    "include",
+    "include/task_manager",
+    "include/task_manager/task_group",
+    "include/timer",
+    "include/timer/core",    
     "utils",
     "utils/av_codec/include",
     "utils/camera_notification/include",
@@ -33,26 +38,22 @@ config("camera_utils_config") {
     "${multimedia_camera_framework_path}/services/camera_service/binder/base/include",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/utils",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager/task_group",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer/core",
   ]
 }
 
+
 common_sources = [
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/task_group/task_group.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/task_manager.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/task_registry.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/core/timer_core.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/steady_clock.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/time_broker.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/camera_deferred_timer.cpp",
-  "${multimedia_camera_framework_path}/services/deferred_processing_service/src/utils/dp_utils.cpp",
+  "src/task_manager/task_group/base_task_group.cpp",
+  "src/task_manager/task_group/delayed_task_group.cpp",
+  "src/task_manager/task_group/task_group.cpp",
+  "src/task_manager/task_manager.cpp",
+  "src/task_manager/task_registry.cpp",
+  "src/task_manager/thread_pool.cpp",
+  "src/task_manager/thread_utils.cpp",
+  "src/timer/core/timer_core.cpp",
+  "src/timer/steady_clock.cpp",
+  "src/timer/time_broker.cpp",
+  "src/timer/camera_deferred_timer.cpp",
   "utils/anonymization.cpp",
   "utils/av_codec/src/av_codec_proxy.cpp",
   "utils/camera_dynamic_loader.cpp",
diff --git a/services/deferred_processing_service/include/base/task_manager/task_group/base_task_group.h b/common/include/task_manager/task_group/base_task_group.h
similarity index 94%
rename from services/deferred_processing_service/include/base/task_manager/task_group/base_task_group.h
rename to common/include/task_manager/task_group/base_task_group.h
index 4e7b87ed45a3f9e7fe20b7d07cebe3b94be6f44f..eb3f18fb5c6843017fd4529e3c68ade32955d787 100644
--- a/services/deferred_processing_service/include/base/task_manager/task_group/base_task_group.h
+++ b/common/include/task_manager/task_group/base_task_group.h
@@ -16,12 +16,6 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_BASE_TASK_GROUP_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_BASE_TASK_GROUP_H
 
-#include <any>
-#include <atomic>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <mutex>
 #include "itask_group.h"
 #include "blocking_queue.h"
 #include "thread_pool.h"
diff --git a/services/deferred_processing_service/include/base/task_manager/task_group/delayed_task_group.h b/common/include/task_manager/task_group/delayed_task_group.h
similarity index 95%
rename from services/deferred_processing_service/include/base/task_manager/task_group/delayed_task_group.h
rename to common/include/task_manager/task_group/delayed_task_group.h
index b4b84b9ca3b145193270e76983e9e27a0ad91386..8810c7ceea4be348e4e00391421625701a1f0a1a 100644
--- a/services/deferred_processing_service/include/base/task_manager/task_group/delayed_task_group.h
+++ b/common/include/task_manager/task_group/delayed_task_group.h
@@ -16,10 +16,6 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_DELAYED_TASK_GROUP_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_DELAYED_TASK_GROUP_H
 
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
 #include "base_task_group.h"
 #include "timer/time_broker.h"
 
diff --git a/services/deferred_processing_service/include/base/task_manager/task_group/itask_group.h b/common/include/task_manager/task_group/itask_group.h
similarity index 97%
rename from services/deferred_processing_service/include/base/task_manager/task_group/itask_group.h
rename to common/include/task_manager/task_group/itask_group.h
index e7df7dd01e9df557ee8baa6e583aa0d4ec837143..446732de4b2419082713c620aca1958592a3a710 100644
--- a/services/deferred_processing_service/include/base/task_manager/task_group/itask_group.h
+++ b/common/include/task_manager/task_group/itask_group.h
@@ -17,9 +17,7 @@
 #define OHOS_DEFERRED_PROCESSING_SERVICE_I_TASK_GROUP_H
 
 #include <any>
-#include <cstdint>
 #include <functional>
-#include <string>
 
 namespace OHOS {
 namespace CameraStandard {
diff --git a/services/deferred_processing_service/include/base/task_manager/task_group/task_group.h b/common/include/task_manager/task_group/task_group.h
similarity index 100%
rename from services/deferred_processing_service/include/base/task_manager/task_group/task_group.h
rename to common/include/task_manager/task_group/task_group.h
diff --git a/services/deferred_processing_service/include/base/task_manager/task_manager.h b/common/include/task_manager/task_manager.h
similarity index 95%
rename from services/deferred_processing_service/include/base/task_manager/task_manager.h
rename to common/include/task_manager/task_manager.h
index 4c30d5299371c680b4d53b6dba0cf1d3d9a73716..f6b776523ad469ea5c17a160f52db45f4139cb4a 100644
--- a/services/deferred_processing_service/include/base/task_manager/task_manager.h
+++ b/common/include/task_manager/task_manager.h
@@ -17,13 +17,7 @@
 #define OHOS_DEFERRED_PROCESSING_SERVICE_TASK_MANAGER_H
 #define EXPORT_API __attribute__((visibility("default")))
 
-#include <atomic>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <string>
 #include "task_registry.h"
-#include "thread_pool.h"
 
 namespace OHOS {
 namespace CameraStandard {
diff --git a/services/deferred_processing_service/include/base/task_manager/task_registry.h b/common/include/task_manager/task_registry.h
similarity index 94%
rename from services/deferred_processing_service/include/base/task_manager/task_registry.h
rename to common/include/task_manager/task_registry.h
index ce64872bb684c8990ae25589ee2d2b8f145a34af..e98b9518c933584101837ea04575e42edc8089d0 100644
--- a/services/deferred_processing_service/include/base/task_manager/task_registry.h
+++ b/common/include/task_manager/task_registry.h
@@ -16,12 +16,7 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_TASK_REGISTRY_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_TASK_REGISTRY_H
 
-#include <atomic>
-#include <cstdint>
-#include <functional>
 #include <map>
-#include <mutex>
-#include <string>
 
 #include "thread_pool.h"
 #include "itask_group.h"
diff --git a/services/deferred_processing_service/include/base/task_manager/thread_pool.h b/common/include/task_manager/thread_pool.h
similarity index 94%
rename from services/deferred_processing_service/include/base/task_manager/thread_pool.h
rename to common/include/task_manager/thread_pool.h
index 320048ce90d86d4c1cef8867562c1d0b2ed2e578..ac81f7b18afb93ff2834b31b48c8c4336d75bc95 100644
--- a/services/deferred_processing_service/include/base/task_manager/thread_pool.h
+++ b/common/include/task_manager/thread_pool.h
@@ -16,16 +16,9 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_THREAD_POOL_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_THREAD_POOL_H
 
-#include <pthread.h>
-#include <atomic>
-#include <condition_variable>
-#include <cstdint>
+#include <deque>
 #include <functional>
-#include <mutex>
-#include <queue>
-#include <string>
 #include <thread>
-#include <vector>
 
 namespace OHOS {
 namespace CameraStandard {
diff --git a/services/deferred_processing_service/include/base/task_manager/thread_utils.h b/common/include/task_manager/thread_utils.h
similarity index 100%
rename from services/deferred_processing_service/include/base/task_manager/thread_utils.h
rename to common/include/task_manager/thread_utils.h
diff --git a/services/deferred_processing_service/include/base/timer/camera_deferred_timer.h b/common/include/timer/camera_deferred_timer.h
similarity index 100%
rename from services/deferred_processing_service/include/base/timer/camera_deferred_timer.h
rename to common/include/timer/camera_deferred_timer.h
diff --git a/services/deferred_processing_service/include/base/timer/core/timer_core.h b/common/include/timer/core/timer_core.h
similarity index 93%
rename from services/deferred_processing_service/include/base/timer/core/timer_core.h
rename to common/include/timer/core/timer_core.h
index 9338af81e70d0aad4db3b1ae9859cccc9b365aec..92d678d4e1e7bd9bc00b53a80d292c64900694c0 100644
--- a/services/deferred_processing_service/include/base/timer/core/timer_core.h
+++ b/common/include/timer/core/timer_core.h
@@ -16,18 +16,12 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_TIMER_CORE_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_TIMER_CORE_H
 
-#include <atomic>
-#include <condition_variable>
-#include <chrono>
-#include <cstdint>
 #include <map>
-#include <memory>
-#include <mutex>
 #include <queue>
 #include <thread>
-#include <vector>
 #include "timer/camera_deferred_timer.h"
 
+
 namespace OHOS {
 namespace CameraStandard {
 namespace DeferredProcessing {
diff --git a/services/deferred_processing_service/include/base/timer/steady_clock.h b/common/include/timer/steady_clock.h
similarity index 88%
rename from services/deferred_processing_service/include/base/timer/steady_clock.h
rename to common/include/timer/steady_clock.h
index ac0c08bed8b81dd2e029870945ed41279b57f188..3febe57d20f6c4af5348c7c5cd74012b62f5319b 100644
--- a/services/deferred_processing_service/include/base/timer/steady_clock.h
+++ b/common/include/timer/steady_clock.h
@@ -17,16 +17,8 @@
 #define OHOS_DEFERRED_PROCESSING_SERVICE_STEADY_CLOCK_H
 #define EXPORT_API __attribute__((visibility("default")))
 
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <string>
-#include <vector>
-#include "timer/camera_deferred_timer.h"
 
+#include <chrono>
 namespace OHOS {
 namespace CameraStandard {
 namespace DeferredProcessing {
diff --git a/services/deferred_processing_service/include/base/timer/time_broker.h b/common/include/timer/time_broker.h
similarity index 95%
rename from services/deferred_processing_service/include/base/timer/time_broker.h
rename to common/include/timer/time_broker.h
index c91a421aca769d2710e69cdf39483827c6c1a2c5..2b4ba31d156dc5e41e8cb23574e640265692275a 100644
--- a/services/deferred_processing_service/include/base/timer/time_broker.h
+++ b/common/include/timer/time_broker.h
@@ -16,14 +16,11 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_TIME_BROKER_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_TIME_BROKER_H
 
-#include <cstdint>
-#include <functional>
+
 #include <map>
-#include <memory>
-#include <mutex>
+
 #include <queue>
-#include <string>
-#include <vector>
+
 #include "timer/camera_deferred_timer.h"
 
 namespace OHOS {
diff --git a/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp b/common/src/task_manager/task_group/base_task_group.cpp
similarity index 69%
rename from services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp
rename to common/src/task_manager/task_group/base_task_group.cpp
index 270fd1b66bdc5dbde425a389e55ffca22cc84442..7eba3d40ffbbea29bd22a6643b2c30d8c177e071 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp
+++ b/common/src/task_manager/task_group/base_task_group.cpp
@@ -14,7 +14,8 @@
  */
 
 #include "base_task_group.h"
-#include "dp_log.h"
+
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -28,12 +29,12 @@ BaseTaskGroup::BaseTaskGroup(const std::string& name, TaskFunc func, bool serial
       inflight_(false),
       que_(name + " queue")
 {
-    DP_DEBUG_LOG("task group (%s).", name_.c_str());
+    MEDIA_DEBUG_LOG("task group (%s).", name_.c_str());
 }
 
 BaseTaskGroup::~BaseTaskGroup()
 {
-    DP_DEBUG_LOG("task group name: %s, handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
+    MEDIA_DEBUG_LOG("task group name: %s, handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
     que_.SetActive(false);
     que_.Clear();
 }
@@ -42,7 +43,7 @@ void BaseTaskGroup::Initialize()
 {
     handle_ = GenerateHandle();
     que_.SetActive(true);
-    DP_DEBUG_LOG("task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
+    MEDIA_DEBUG_LOG("task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
 }
 
 const std::string& BaseTaskGroup::GetName()
@@ -59,9 +60,10 @@ bool BaseTaskGroup::SubmitTask(std::any param)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (que_.Full()) {
-        DP_WARNING_LOG("Submit task (%s), handle: %{public}d, que is full!", name_.c_str(), static_cast<int>(handle_));
+        MEDIA_WARNING_LOG("Submit task (%s), handle: %{public}d, que is full!", name_.c_str(),
+            static_cast<int>(handle_));
     } else {
-        DP_DEBUG_LOG("Submit task (%s), handle: %{public}d, size: %zu.", name_.c_str(),
+        MEDIA_DEBUG_LOG("Submit task (%s), handle: %{public}d, size: %zu.", name_.c_str(),
             static_cast<int>(handle_), que_.Size());
     }
     que_.Push(std::move(param));
@@ -72,23 +74,24 @@ bool BaseTaskGroup::SubmitTask(std::any param)
 void BaseTaskGroup::CancelAllTasks()
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_DEBUG_LOG("Cancel all tasks for task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
+    MEDIA_DEBUG_LOG("Cancel all tasks for task group (%s), handle: %{public}d", name_.c_str(),
+        static_cast<int>(handle_));
     que_.Clear();
-    DP_CHECK_RETURN(!serial_);
+    CHECK_RETURN(!serial_);
     inflight_ = false;
 }
 
 size_t BaseTaskGroup::GetTaskCount()
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_DEBUG_LOG("Get task count for task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
+    MEDIA_DEBUG_LOG("Get task count for task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
     return que_.Size();
 }
 
 std::function<void()> BaseTaskGroup::GetTaskUnlocked()
 {
     if (que_.Empty()) {
-        DP_DEBUG_LOG("(%s) no available tasks.", name_.c_str());
+        MEDIA_DEBUG_LOG("(%s) no available tasks.", name_.c_str());
         return {};
     }
     std::weak_ptr<BaseTaskGroup> weakThis(shared_from_this());
@@ -99,7 +102,7 @@ std::function<void()> BaseTaskGroup::GetTaskUnlocked()
             thiz->OnTaskComplete();
         }
     };
-    DP_DEBUG_LOG("return one task %s, handle:%{public}d, size: %zu.", name_.c_str(), static_cast<int>(handle_),
+    MEDIA_DEBUG_LOG("return one task %s, handle:%{public}d, size: %zu.", name_.c_str(), static_cast<int>(handle_),
         que_.Size());
     return task;
 }
@@ -107,7 +110,7 @@ std::function<void()> BaseTaskGroup::GetTaskUnlocked()
 TaskGroupHandle BaseTaskGroup::GenerateHandle()
 {
     static std::atomic<uint64_t> counter = 0;
-    DP_DEBUG_LOG("(%s) entered.", name_.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", name_.c_str());
     uint64_t prefix = std::hash<std::string>{}(name_);
     uint64_t handle = ++counter;
     return prefix | handle;
@@ -115,9 +118,9 @@ TaskGroupHandle BaseTaskGroup::GenerateHandle()
 
 void BaseTaskGroup::DispatchTaskUnlocked()
 {
-    DP_DEBUG_LOG("(%s) entered.", name_.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", name_.c_str());
     if (serial_ && inflight_.load()) {
-        DP_DEBUG_LOG("(%s), task is running, redispatch tasks after finish running.", name_.c_str());
+        MEDIA_DEBUG_LOG("(%s), task is running, redispatch tasks after finish running.", name_.c_str());
         return;
     }
     auto task = GetTaskUnlocked();
@@ -125,7 +128,7 @@ void BaseTaskGroup::DispatchTaskUnlocked()
         inflight_ = true;
         threadPool_->Submit([task = std::move(task)] { task(); });
     } else {
-        DP_DEBUG_LOG("all tasks have completed for %s handle:%{public}d.", name_.c_str(), static_cast<int>(handle_));
+        MEDIA_DEBUG_LOG("all tasks have completed for %s handle:%{public}d.", name_.c_str(), static_cast<int>(handle_));
     }
 }
 void BaseTaskGroup::OnTaskComplete()
diff --git a/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp b/common/src/task_manager/task_group/delayed_task_group.cpp
similarity index 76%
rename from services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp
rename to common/src/task_manager/task_group/delayed_task_group.cpp
index 8bc6cb1b8ec55c82c58a46616b29e795ec6c7220..a561bf67f9f2f5bf1d251c72d9b7fee292915fe9 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp
+++ b/common/src/task_manager/task_group/delayed_task_group.cpp
@@ -14,8 +14,9 @@
  */
 
 #include "delayed_task_group.h"
+#include "camera_log.h"
 #include "timer/steady_clock.h"
-#include "dp_log.h"
+
 
 namespace OHOS {
 namespace CameraStandard {
@@ -23,13 +24,13 @@ namespace DeferredProcessing {
 DelayedTaskGroup::DelayedTaskGroup(const std::string& name, TaskFunc func, const ThreadPool* threadPool)
     : BaseTaskGroup(name, std::move(func), true, threadPool), mutex_(), timeBroker_(nullptr), paramMap_()
 {
-    DP_DEBUG_LOG("(%s) entered.", GetName().c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", GetName().c_str());
     Initialize();
 }
 
 DelayedTaskGroup::~DelayedTaskGroup()
 {
-    DP_DEBUG_LOG("(%s) entered.", GetName().c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", GetName().c_str());
     std::lock_guard<std::mutex> lock(mutex_);
     if (timeBroker_) {
         timeBroker_.reset();
@@ -39,7 +40,7 @@ DelayedTaskGroup::~DelayedTaskGroup()
 
 void DelayedTaskGroup::Initialize()
 {
-    DP_DEBUG_LOG("(%s) Initialize entered.", GetName().c_str());
+    MEDIA_DEBUG_LOG("(%s) Initialize entered.", GetName().c_str());
     BaseTaskGroup::Initialize();
     timeBroker_ = TimeBroker::Create("DelayedTaskGroup");
 }
@@ -47,12 +48,12 @@ void DelayedTaskGroup::Initialize()
 bool DelayedTaskGroup::SubmitTask(std::any param)
 {
     if (!param.has_value()) {
-        DP_DEBUG_LOG("(%s) SubmitTask failed due to containing no parameter.", GetName().c_str());
+        MEDIA_DEBUG_LOG("(%s) SubmitTask failed due to containing no parameter.", GetName().c_str());
         return false;
     }
     std::lock_guard<std::mutex> lock(mutex_);
     auto&& [delayTimeMs, task] = std::any_cast<std::tuple<uint32_t, std::function<void()>>&&>(std::move(param));
-    DP_DEBUG_LOG("(%s) SubmitTask, delayTimeMs %{public}d ,expiring timestamp: %{public}d",
+    MEDIA_DEBUG_LOG("(%s) SubmitTask, delayTimeMs %{public}d ,expiring timestamp: %{public}d",
         GetName().c_str(),
         static_cast<int>(delayTimeMs),
         static_cast<int>(SteadyClock::GetTimestampMilli() + delayTimeMs));
@@ -61,17 +62,17 @@ bool DelayedTaskGroup::SubmitTask(std::any param)
     if (ret) {
         paramMap_.emplace(handle, std::move(task));
     } else {
-        DP_ERR_LOG("(%s) SubmitTask failed due to RegisterCallback.", GetName().c_str());
+        MEDIA_ERR_LOG("(%s) SubmitTask failed due to RegisterCallback.", GetName().c_str());
     }
     return ret;
 }
     
 void DelayedTaskGroup::TimerExpired(uint32_t handle)
 {
-    DP_DEBUG_LOG("(%s) TimerExpired, handle = %{public}d", GetName().c_str(), static_cast<int>(handle));
+    MEDIA_DEBUG_LOG("(%s) TimerExpired, handle = %{public}d", GetName().c_str(), static_cast<int>(handle));
     std::lock_guard<std::mutex> lock(mutex_);
     if (paramMap_.count(handle) == 0) {
-        DP_DEBUG_LOG("(%s) TimerExpired, handle = %{public}d", GetName().c_str(), static_cast<int>(handle));
+        MEDIA_DEBUG_LOG("(%s) TimerExpired, handle = %{public}d", GetName().c_str(), static_cast<int>(handle));
         return;
     }
     BaseTaskGroup::SubmitTask(std::move(paramMap_[handle]));
diff --git a/services/deferred_processing_service/src/base/task_manager/task_group/task_group.cpp b/common/src/task_manager/task_group/task_group.cpp
similarity index 90%
rename from services/deferred_processing_service/src/base/task_manager/task_group/task_group.cpp
rename to common/src/task_manager/task_group/task_group.cpp
index 5910c89deb5e52e015bd11f5fb5a82a3ab2d80c4..44ffeffb0b6b6e38f955eda246d409fdf0c69d0b 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_group/task_group.cpp
+++ b/common/src/task_manager/task_group/task_group.cpp
@@ -14,8 +14,8 @@
  */
 
 #include "task_group.h"
-#include "base_task_group.h"
-#include "dp_log.h"
+
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -23,7 +23,7 @@ namespace DeferredProcessing {
 TaskGroup::TaskGroup(const std::string& name, TaskFunc func, bool serial, const ThreadPool* threadPool)
     : BaseTaskGroup(name, std::move(func), serial, threadPool)
 {
-    DP_DEBUG_LOG("(%s) entered.", GetName().c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", GetName().c_str());
 }
 
 } //namespace DeferredProcessing
diff --git a/services/deferred_processing_service/src/base/task_manager/task_manager.cpp b/common/src/task_manager/task_manager.cpp
similarity index 78%
rename from services/deferred_processing_service/src/base/task_manager/task_manager.cpp
rename to common/src/task_manager/task_manager.cpp
index d8d15281427f2ab7da674ba7fa76c77e359a79b2..8f7dbe9e5d595036c4d46030d23b8470f8194670 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_manager.cpp
+++ b/common/src/task_manager/task_manager.cpp
@@ -13,10 +13,11 @@
  * limitations under the License.
  */
 
+#include "task_manager.h"
+
 #include <tuple>
 
-#include "task_manager.h"
-#include "dp_log.h"
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -29,28 +30,28 @@ TaskManager::TaskManager(const std::string& name, uint32_t  numThreads, bool ser
       taskRegistry_(nullptr),
       delayedTaskHandle_(INVALID_TASK_GROUP_HANDLE)
 {
-    DP_INFO_LOG("name: %s, maxThreads: %{public}d.", name.c_str(), numThreads);
+    MEDIA_INFO_LOG("name: %s, maxThreads: %{public}d.", name.c_str(), numThreads);
     Initialize();
 }
 
 void TaskManager::Initialize()
 {
-    CAMERA_DP_SYNC_TRACE;
-    DP_INFO_LOG("entered.");
+    CAMERA_SYNC_TRACE;
+    MEDIA_INFO_LOG("entered.");
     pool_ = ThreadPool::Create(name_, numThreads_);
     taskRegistry_ = std::make_unique<TaskRegistry>(name_, pool_.get());
     std::weak_ptr defaultTaskHandle = defaultTaskHandle_;
     auto ret = RegisterTaskGroup("defaultTaskGroup",
         [this, defaultTaskHandle](std::any param) {
             auto taskHandle = defaultTaskHandle.lock();
-            DP_CHECK_RETURN(!taskHandle);
+            CHECK_RETURN(!taskHandle);
             if (param.has_value()) {
                 DoDefaultWorks(std::move(param));
             } else {
-                DP_ERR_LOG("register default task group: failed, param has no value");
+                MEDIA_ERR_LOG("register default task group: failed, param has no value");
             }
         }, serial_, false, *defaultTaskHandle_);
-    DP_INFO_LOG("register default task group: %{public}d, handle: %{public}d", ret,
+    MEDIA_INFO_LOG("register default task group: %{public}d, handle: %{public}d", ret,
         static_cast<int>(*defaultTaskHandle_));
     (void)(ret);
     return;
@@ -58,8 +59,8 @@ void TaskManager::Initialize()
 
 TaskManager::~TaskManager()
 {
-    CAMERA_DP_SYNC_TRACE;
-    DP_INFO_LOG("TaskManager name: %{public}s.", name_.c_str());
+    CAMERA_SYNC_TRACE;
+    MEDIA_INFO_LOG("TaskManager name: %{public}s.", name_.c_str());
     DeregisterTaskGroup("defaultTaskGroup", *defaultTaskHandle_);
     *defaultTaskHandle_ = INVALID_TASK_GROUP_HANDLE;
     if (delayedTaskHandle_ != INVALID_TASK_GROUP_HANDLE) {
@@ -83,7 +84,8 @@ void TaskManager::CreateDelayedTaskGroupIfNeed()
                 if (param.has_value()) {
                     DoDefaultWorks(std::move(param));
                 } else {
-                    DP_ERR_LOG("CreateDelayedTaskGroupIfNeed register default task group: failed, param has no value");
+                    MEDIA_ERR_LOG("CreateDelayedTaskGroupIfNeed register default \
+                                   task group: failed, param has no value");
                 }
             }, true, true, delayedTaskHandle_);
     }
@@ -92,12 +94,12 @@ void TaskManager::CreateDelayedTaskGroupIfNeed()
 
 void TaskManager::BeginBackgroundTasks()
 {
-    DP_INFO_LOG("name: %s.", name_.c_str());
+    MEDIA_INFO_LOG("name: %s.", name_.c_str());
 }
 
 void TaskManager::EndBackgroundTasks()
 {
-    DP_INFO_LOG("name: %s.", name_.c_str());
+    MEDIA_INFO_LOG("name: %s.", name_.c_str());
 }
 
 bool TaskManager::RegisterTaskGroup(const std::string& name, TaskFunc func, bool serial, TaskGroupHandle& handle)
@@ -107,13 +109,13 @@ bool TaskManager::RegisterTaskGroup(const std::string& name, TaskFunc func, bool
 
 bool TaskManager::DeregisterTaskGroup(const std::string& name, TaskGroupHandle& handle)
 {
-    CAMERA_DP_SYNC_TRACE;
+    CAMERA_SYNC_TRACE;
     bool ret = false;
     if (taskRegistry_) {
         ret = taskRegistry_->DeregisterTaskGroup(name, handle);
-        DP_INFO_LOG("deregister task group: %s, ret: %{public}d", name.c_str(), ret);
+        MEDIA_INFO_LOG("deregister task group: %s, ret: %{public}d", name.c_str(), ret);
     } else {
-        DP_INFO_LOG("invalid ptr");
+        MEDIA_INFO_LOG("invalid ptr");
     }
     return ret;
 }
@@ -131,9 +133,9 @@ bool TaskManager::SubmitTask(std::function<void()> task, uint32_t delayMilli)
 
 bool TaskManager::SubmitTask(TaskGroupHandle handle, std::any param)
 {
-    DP_INFO_LOG("submit task to handle: %{public}d", static_cast<int>(handle));
+    MEDIA_DEBUG_LOG("submit task to handle: %{public}d", static_cast<int>(handle));
     if (taskRegistry_ == nullptr) {
-        DP_ERR_LOG("invalid ptr");
+        MEDIA_ERR_LOG("invalid ptr");
         return false;
     }
     return taskRegistry_->SubmitTask(handle, std::move(param));
@@ -141,9 +143,9 @@ bool TaskManager::SubmitTask(TaskGroupHandle handle, std::any param)
 
 void TaskManager::CancelAllTasks()
 {
-    DP_INFO_LOG("Cancel all tasks to handle: %{public}d", static_cast<int>(*defaultTaskHandle_));
+    MEDIA_INFO_LOG("Cancel all tasks to handle: %{public}d", static_cast<int>(*defaultTaskHandle_));
     if (taskRegistry_ == nullptr) {
-        DP_ERR_LOG("invalid ptr");
+        MEDIA_ERR_LOG("invalid ptr");
         return;
     }
     taskRegistry_->CancelAllTasks(*defaultTaskHandle_);
@@ -151,7 +153,7 @@ void TaskManager::CancelAllTasks()
 
 bool TaskManager::IsEmpty()
 {
-    DP_INFO_LOG("Get tasks count: %{public}d", static_cast<int>(*defaultTaskHandle_));
+    MEDIA_INFO_LOG("Get tasks count: %{public}d", static_cast<int>(*defaultTaskHandle_));
     if (taskRegistry_ == nullptr) {
         return true;
     }
diff --git a/services/deferred_processing_service/src/base/task_manager/task_registry.cpp b/common/src/task_manager/task_registry.cpp
similarity index 72%
rename from services/deferred_processing_service/src/base/task_manager/task_registry.cpp
rename to common/src/task_manager/task_registry.cpp
index d267a8f69d119fab71f638a9360543fea67f954e..0754b0b3a7a4023a9c04274023941fe3c5f6cf84 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_registry.cpp
+++ b/common/src/task_manager/task_registry.cpp
@@ -14,9 +14,10 @@
  */
 
 #include "task_registry.h"
+
 #include "delayed_task_group.h"
 #include "task_group.h"
-#include "dp_log.h"
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -24,13 +25,13 @@ namespace DeferredProcessing {
 TaskRegistry::TaskRegistry(const std::string& name, const ThreadPool* threadPool)
     : name_(name), threadPool_(threadPool), mutex_(), registry_()
 {
-    DP_DEBUG_LOG("name: %s.", name.c_str());
+    MEDIA_DEBUG_LOG("name: %s.", name.c_str());
 }
 
 TaskRegistry::~TaskRegistry()
 {
-    CAMERA_DP_SYNC_TRACE;
-    DP_DEBUG_LOG("name: %s.", name_.c_str());
+    CAMERA_SYNC_TRACE;
+    MEDIA_DEBUG_LOG("name: %s.", name_.c_str());
     std::lock_guard<std::mutex> lock(mutex_);
     registry_.clear();
 }
@@ -38,9 +39,9 @@ TaskRegistry::~TaskRegistry()
 bool TaskRegistry::RegisterTaskGroup(const std::string& name, TaskFunc func, bool serial, bool delayTask,
     TaskGroupHandle& handle)
 {
-    DP_DEBUG_LOG("name: %s, serial: %{public}d, delayTask: %{public}d.", name.c_str(), serial, delayTask);
+    MEDIA_DEBUG_LOG("name: %s, serial: %{public}d, delayTask: %{public}d.", name.c_str(), serial, delayTask);
     if (IsTaskGroupAlreadyRegistered(name)) {
-        DP_DEBUG_LOG("failed, task group (%s) already existed!", name.c_str());
+        MEDIA_DEBUG_LOG("failed, task group (%s) already existed!", name.c_str());
         return false;
     }
     std::lock_guard<std::mutex> lock(mutex_);
@@ -60,17 +61,17 @@ bool TaskRegistry::RegisterTaskGroup(const std::string& name, TaskFunc func, boo
 
 bool TaskRegistry::DeregisterTaskGroup(const std::string& name, TaskGroupHandle& handle)
 {
-    CAMERA_DP_SYNC_TRACE;
-    DP_DEBUG_LOG("name: %s.", name.c_str());
+    CAMERA_SYNC_TRACE;
+    MEDIA_DEBUG_LOG("name: %s.", name.c_str());
     if (!IsTaskGroupAlreadyRegistered(name)) {
-        DP_DEBUG_LOG("name: %s, with handle:%{public}d, failed due to non exist task group!",
+        MEDIA_DEBUG_LOG("name: %s, with handle:%{public}d, failed due to non exist task group!",
             name.c_str(), static_cast<int>(handle));
         return false;
     }
     std::lock_guard<std::mutex> lock(mutex_);
     auto it = registry_.find(handle);
     if (it == registry_.end()) {
-        DP_DEBUG_LOG("name: %s, handle:%{public}d failed due to non-existent task group!",
+        MEDIA_DEBUG_LOG("name: %s, handle:%{public}d failed due to non-existent task group!",
             name.c_str(), static_cast<int>(handle));
         return false;
     }
@@ -80,11 +81,11 @@ bool TaskRegistry::DeregisterTaskGroup(const std::string& name, TaskGroupHandle&
 
 bool TaskRegistry::SubmitTask(TaskGroupHandle handle, std::any param)
 {
-    DP_DEBUG_LOG("submit one task to %{public}d", static_cast<int>(handle));
+    MEDIA_DEBUG_LOG("submit one task to %{public}d", static_cast<int>(handle));
     std::lock_guard<std::mutex> lock(mutex_);
     auto it = registry_.find(handle);
     if (it == registry_.end()) {
-        DP_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
+        MEDIA_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
         return false;
     }
     return it->second->SubmitTask(std::move(param));
@@ -92,11 +93,11 @@ bool TaskRegistry::SubmitTask(TaskGroupHandle handle, std::any param)
 
 void TaskRegistry::CancelAllTasks(TaskGroupHandle handle)
 {
-    DP_DEBUG_LOG("Cancel all tasks to %{public}d", static_cast<int>(handle));
+    MEDIA_DEBUG_LOG("Cancel all tasks to %{public}d", static_cast<int>(handle));
     std::lock_guard<std::mutex> lock(mutex_);
     auto it = registry_.find(handle);
     if (it == registry_.end()) {
-        DP_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
+        MEDIA_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
         return;
     }
     it->second->CancelAllTasks();
@@ -104,11 +105,11 @@ void TaskRegistry::CancelAllTasks(TaskGroupHandle handle)
 
 size_t TaskRegistry::GetTaskCount(TaskGroupHandle handle)
 {
-    DP_DEBUG_LOG("Get task count %{public}d", static_cast<int>(handle));
+    MEDIA_DEBUG_LOG("Get task count %{public}d", static_cast<int>(handle));
     std::lock_guard<std::mutex> lock(mutex_);
     auto it = registry_.find(handle);
     if (it == registry_.end()) {
-        DP_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
+        MEDIA_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
         return 0;
     }
     return it->second->GetTaskCount();
@@ -119,11 +120,11 @@ bool TaskRegistry::IsTaskGroupAlreadyRegistered(const std::string& name)
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto it = registry_.begin(); it != registry_.end(); ++it) {
         if (it->second->GetName() == name) {
-            DP_DEBUG_LOG("task group (%s) had registered.", name.c_str());
+            MEDIA_DEBUG_LOG("task group (%s) had registered.", name.c_str());
             return true;
         }
     }
-    DP_DEBUG_LOG("task group (%s) hasn't been registered.", name.c_str());
+    MEDIA_DEBUG_LOG("task group (%s) hasn't been registered.", name.c_str());
     return false;
 }
 } //namespace DeferredProcessing
diff --git a/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp b/common/src/task_manager/thread_pool.cpp
similarity index 78%
rename from services/deferred_processing_service/src/base/task_manager/thread_pool.cpp
rename to common/src/task_manager/thread_pool.cpp
index f79c4d26550196b3d7f183c1daf11540de526c6a..2de8e32fa8fbd74a0120b3fde5cbcd8661418d6e 100644
--- a/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp
+++ b/common/src/task_manager/thread_pool.cpp
@@ -14,10 +14,12 @@
  */
 
 #include "thread_pool.h"
+
 #include <sys/time.h>
 #include <algorithm>
+
+#include "camera_log.h"
 #include "thread_utils.h"
-#include "dp_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -38,18 +40,18 @@ ThreadPool::ThreadPool(const std::string& name, uint32_t numThreads)
         numThreads_ = 1;
     }
     numThreads_ = std::min(numThreads_, static_cast<uint32_t>(std::thread::hardware_concurrency()));
-    DP_DEBUG_LOG("name: %s, numThreads, orig: %u, new: %u.", name.c_str(), numThreads, numThreads_);
+    MEDIA_DEBUG_LOG("name: %s, numThreads, orig: %u, new: %u.", name.c_str(), numThreads, numThreads_);
 }
 
 ThreadPool::~ThreadPool()
 {
-    CAMERA_DP_SYNC_TRACE;
-    DP_DEBUG_LOG("name: %s.", name_.c_str());
+    CAMERA_SYNC_TRACE;
+    MEDIA_DEBUG_LOG("name: %s.", name_.c_str());
     isStopped_ = true;
     taskCv_.notify_all();
     for (auto& threadInfo : workers_) {
         if (threadInfo.thread.joinable()) {
-            DP_DEBUG_LOG("joining thread (%s).", threadInfo.name.c_str());
+            MEDIA_DEBUG_LOG("joining thread (%s).", threadInfo.name.c_str());
             threadInfo.thread.join();
         }
     }
@@ -57,7 +59,7 @@ ThreadPool::~ThreadPool()
 
 void ThreadPool::Initialize()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     workers_.reserve(numThreads_);
     std::string threadNamePrefix = name_ + "_DPS_Worker_";
     for (uint32_t i = 0; i < numThreads_; ++i) {
@@ -70,24 +72,24 @@ void ThreadPool::Initialize()
 
 void ThreadPool::WorkerLoop(const std::string& threadName)
 {
-    DP_DEBUG_LOG("(%s) entered.", threadName.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", threadName.c_str());
     while (!isStopped_.load()) {
-        DP_DEBUG_LOG("(%s) task excute start entered.", threadName.c_str());
+        MEDIA_DEBUG_LOG("(%s) task excute start entered.", threadName.c_str());
         auto task = GetTask();
         if (task) {
-            DP_DEBUG_LOG("(%s) task excuting entered.", threadName.c_str());
+            MEDIA_DEBUG_LOG("(%s) task excuting entered.", threadName.c_str());
             task();
-            DP_DEBUG_LOG("(%s) task excuting complete.", threadName.c_str());
+            MEDIA_DEBUG_LOG("(%s) task excuting complete.", threadName.c_str());
         } else {
-            DP_DEBUG_LOG("empty task.");
+            MEDIA_DEBUG_LOG("empty task.");
         }
     }
-    DP_DEBUG_LOG("(%s) exited.", threadName.c_str());
+    MEDIA_DEBUG_LOG("(%s) exited.", threadName.c_str());
 }
 
 void ThreadPool::BeginBackgroundTasks() const
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     for (auto& workerInfo : workers_) {
         SetThreadPriority(workerInfo.thread.native_handle(), PRIORITY_BACKGROUND);
     }
@@ -95,7 +97,7 @@ void ThreadPool::BeginBackgroundTasks() const
 
 void ThreadPool::EndBackgroundTasks() const
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     for (auto& workerInfo : workers_) {
         SetThreadPriority(workerInfo.thread.native_handle(), PRIORITY_NORMAL);
     }
@@ -103,7 +105,7 @@ void ThreadPool::EndBackgroundTasks() const
 
 void ThreadPool::SetThreadPoolPriority(int priority)
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     for (auto& workerInfo : workers_) {
         SetThreadPriority(workerInfo.thread.native_handle(), priority);
     }
@@ -121,10 +123,11 @@ void ThreadPool::PrintThreadInfo()
     for (auto& workerInfo : workers_) {
         int ret = pthread_getschedparam(workerInfo.thread.native_handle(), &policy, &sch);
         if (ret == 0) {
-            DP_DEBUG_LOG("thread (%s) priority: %{public}d, policy = %{public}d(0:OTHER, 1:FIFO, 2:RR)",
+            MEDIA_DEBUG_LOG("thread (%s) priority: %{public}d, policy = %{public}d(0:OTHER, 1:FIFO, 2:RR)",
                 workerInfo.name.c_str(), sch.sched_priority, policy);
         } else {
-            DP_DEBUG_LOG("thread (%s) pthread_getschedparam failed, ret = %{public}d.", workerInfo.name.c_str(), ret);
+            MEDIA_DEBUG_LOG("thread (%s) pthread_getschedparam failed, ret = %{public}d.",
+                workerInfo.name.c_str(), ret);
         }
     }
 }
@@ -149,7 +152,7 @@ bool ThreadPool::HasPendingTasks() const
 
 bool ThreadPool::Submit(Task func, bool isUrgent) const
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     if (!isStopped_.load()) {
         {
             std::unique_lock<std::mutex> lock(mutex_);
@@ -161,7 +164,7 @@ bool ThreadPool::Submit(Task func, bool isUrgent) const
         }
         taskCv_.notify_one();
     } else {
-        DP_ERR_LOG("failed due to thread pool has been stopped.");
+        MEDIA_ERR_LOG("failed due to thread pool has been stopped.");
         return false;
     }
     return true;
diff --git a/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp b/common/src/task_manager/thread_utils.cpp
similarity index 80%
rename from services/deferred_processing_service/src/base/task_manager/thread_utils.cpp
rename to common/src/task_manager/thread_utils.cpp
index 8a992eda4735da8826be68e274585a5224055a0e..790eee992df756224d486c6da2caf66b23cadf74 100644
--- a/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp
+++ b/common/src/task_manager/thread_utils.cpp
@@ -14,8 +14,10 @@
  */
 
 #include "thread_utils.h"
+
 #include <sys/resource.h>
-#include "dp_log.h"
+
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -27,10 +29,10 @@ void SetThreadName(pthread_t tid, const std::string& name)
     constexpr int threadNameMaxSize = 15;
     auto threadName = name.size() > threadNameMaxSize ? name.substr(0, threadNameMaxSize).c_str() : name;
     if (name.size() > threadNameMaxSize) {
-        DP_DEBUG_LOG("task name %s exceed max size: %{public}d", name.c_str(), threadNameMaxSize);
+        MEDIA_DEBUG_LOG("task name %s exceed max size: %{public}d", name.c_str(), threadNameMaxSize);
     }
     int ret = pthread_setname_np(tid, threadName.c_str());
-    DP_DEBUG_LOG("threadId: %{public}ld, threadName: %s, pthread_setname_np ret = %{public}d.",
+    MEDIA_DEBUG_LOG("threadId: %{public}ld, threadName: %s, pthread_setname_np ret = %{public}d.",
         static_cast<long>(pthread_gettid_np(tid)), threadName.c_str(), ret);
 }
 
@@ -43,9 +45,9 @@ void SetThreadPriority(pthread_t handle, int priority)
     }
     int ret = setpriority(PRIO_PROCESS, tid, priority);
     if (ret == 0) {
-        DP_DEBUG_LOG("succeed for tid (%ld) with priority (%{public}d).", static_cast<long>(tid), priority);
+        MEDIA_DEBUG_LOG("succeed for tid (%ld) with priority (%{public}d).", static_cast<long>(tid), priority);
     } else {
-        DP_DEBUG_LOG("failed for tid (%ld) with priority (%{public}d), ret = %{public}d.",
+        MEDIA_DEBUG_LOG("failed for tid (%ld) with priority (%{public}d), ret = %{public}d.",
             static_cast<long>(tid), priority, ret);
     }
 }
diff --git a/services/deferred_processing_service/src/base/timer/camera_deferred_timer.cpp b/common/src/timer/camera_deferred_timer.cpp
similarity index 100%
rename from services/deferred_processing_service/src/base/timer/camera_deferred_timer.cpp
rename to common/src/timer/camera_deferred_timer.cpp
diff --git a/services/deferred_processing_service/src/base/timer/core/timer_core.cpp b/common/src/timer/core/timer_core.cpp
similarity index 83%
rename from services/deferred_processing_service/src/base/timer/core/timer_core.cpp
rename to common/src/timer/core/timer_core.cpp
index d51a25eb50159cc6290a87fd69ab3299c4090094..1265d5745ae72e23ed3015fabf3c50f62af6aea4 100644
--- a/services/deferred_processing_service/src/base/timer/core/timer_core.cpp
+++ b/common/src/timer/core/timer_core.cpp
@@ -13,12 +13,11 @@
  * limitations under the License.
  */
 
-#include <securec.h>
-#include <algorithm>
+
 #include "timer/core/timer_core.h"
 #include "thread_utils.h"
 #include "timer/steady_clock.h"
-#include "dp_log.h"
+
 
 namespace OHOS {
 namespace CameraStandard {
@@ -35,12 +34,12 @@ TimerCore& TimerCore::GetInstance()
 
 TimerCore::TimerCore()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
 }
 
 TimerCore::~TimerCore()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     {
         std::unique_lock<std::mutex> lock(mutex_);
         registeredTimers_.clear();
@@ -50,12 +49,12 @@ TimerCore::~TimerCore()
     if (worker_.joinable()) {
         worker_.join();
     }
-    DP_DEBUG_LOG("exited.");
+    MEDIA_DEBUG_LOG("exited.");
 }
 
 bool TimerCore::Initialize()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     std::unique_lock<std::mutex> lock(mutex_);
     if (!active_) {
         active_ = true;
@@ -73,7 +72,7 @@ bool TimerCore::RegisterTimer(uint64_t timestampMs, const std::shared_ptr<Timer>
         return false;
     }
     if (timer == nullptr) {
-        DP_DEBUG_LOG("failed due to nullptr.");
+        MEDIA_DEBUG_LOG("failed due to nullptr.");
         return false;
     }
     std::unique_lock<std::mutex> lock(mutex_);
@@ -85,7 +84,7 @@ bool TimerCore::RegisterTimer(uint64_t timestampMs, const std::shared_ptr<Timer>
         }
     }
     registeredTimers_[timestampMs].push_back(timer);
-    DP_DEBUG_LOG("register timer (%s), timestamp: %{public}d, timeline.top: %{public}d", timer->GetName().c_str(),
+    MEDIA_DEBUG_LOG("register timer (%s), timestamp: %{public}d, timeline.top: %{public}d", timer->GetName().c_str(),
         static_cast<int>(timestampMs), static_cast<int>(timeline_.top()));
     return true;
 }
@@ -96,10 +95,10 @@ bool TimerCore::DeregisterTimer(uint64_t timestampMs, const std::shared_ptr<Time
         return true;
     }
     if (timer == nullptr) {
-        DP_ERR_LOG("failed due to nullptr.");
+        MEDIA_ERR_LOG("failed due to nullptr.");
         return false;
     }
-    DP_DEBUG_LOG("(%s, %{public}d) entered.", timer->GetName().c_str(), static_cast<int>(timestampMs));
+    MEDIA_DEBUG_LOG("(%s, %{public}d) entered.", timer->GetName().c_str(), static_cast<int>(timestampMs));
     std::unique_lock<std::mutex> lock(mutex_);
     if (registeredTimers_.count(timestampMs)) {
         auto& timers = registeredTimers_[timestampMs];
@@ -114,7 +113,7 @@ bool TimerCore::DeregisterTimer(uint64_t timestampMs, const std::shared_ptr<Time
 
 void TimerCore::TimerLoop(const std::string& threadName)
 {
-    DP_DEBUG_LOG("(%s) entered.", threadName.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", threadName.c_str());
     while (active_.load()) {
         {
             std::unique_lock<std::mutex> lock(mutex_);
@@ -129,7 +128,7 @@ void TimerCore::TimerLoop(const std::string& threadName)
         }
         DoTimeout();
     }
-    DP_DEBUG_LOG("(%s) exited.", threadName.c_str());
+    MEDIA_DEBUG_LOG("(%s) exited.", threadName.c_str());
 }
 
 std::chrono::milliseconds TimerCore::GetNextExpirationTimeUnlocked()
@@ -138,7 +137,7 @@ std::chrono::milliseconds TimerCore::GetNextExpirationTimeUnlocked()
     if (!timeline_.empty()) {
         expirationTime = SteadyClock::GetRemainingTimeMs(timeline_.top());
     }
-    DP_DEBUG_LOG("expiration time: %lld.", expirationTime.count());
+    MEDIA_DEBUG_LOG("expiration time: %lld.", expirationTime.count());
     return expirationTime;
 }
 
@@ -148,16 +147,16 @@ void TimerCore::DoTimeout()
     {
         std::unique_lock<std::mutex> lock(mutex_);
         if (timeline_.empty()) {
-            DP_DEBUG_LOG("no register timer.");
+            MEDIA_DEBUG_LOG("no register timer.");
             return;
         }
         auto timestamp = timeline_.top();
         timeline_.pop();
         if (registeredTimers_.count(timestamp) == 0) {
-            DP_DEBUG_LOG("timer for timestamp %{public}d hasn't been registered.", static_cast<int>(timestamp));
+            MEDIA_DEBUG_LOG("timer for timestamp %{public}d hasn't been registered.", static_cast<int>(timestamp));
             return;
         }
-        DP_DEBUG_LOG("expired timestamp: %{public}d", static_cast<int>(timestamp));
+        MEDIA_DEBUG_LOG("expired timestamp: %{public}d", static_cast<int>(timestamp));
         timers = std::move(registeredTimers_[timestamp]);
         registeredTimers_.erase(timestamp);
     }
diff --git a/services/deferred_processing_service/src/base/timer/steady_clock.cpp b/common/src/timer/steady_clock.cpp
similarity index 87%
rename from services/deferred_processing_service/src/base/timer/steady_clock.cpp
rename to common/src/timer/steady_clock.cpp
index b85de6cfb9374281ba46337d235272e15bfd12ae..74538ac02bf316cd3444aeca902d1d9b06ff533d 100644
--- a/services/deferred_processing_service/src/base/timer/steady_clock.cpp
+++ b/common/src/timer/steady_clock.cpp
@@ -14,7 +14,7 @@
  */
 
 #include "timer/steady_clock.h"
-#include "dp_log.h"
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -39,7 +39,7 @@ uint64_t SteadyClock::GetElapsedTimeMs(uint64_t startMs)
     if (currTime > startMs) {
         diff = currTime - startMs;
     } else {
-        DP_ERR_LOG("invalid parameter, startMs: %{public}d, currTime: %{public}d", static_cast<int>(startMs),
+        MEDIA_ERR_LOG("invalid parameter, startMs: %{public}d, currTime: %{public}d", static_cast<int>(startMs),
             static_cast<int>(currTime));
     }
     return diff;
@@ -49,26 +49,26 @@ std::chrono::milliseconds SteadyClock::GetRemainingTimeMs(uint64_t expirationTim
 {
     auto currTime = SteadyClock::GetTimestampMilli();
     uint64_t remainingTimeMs = (expirationTimeMs > currTime) ? (expirationTimeMs - currTime) : 0;
-    DP_DEBUG_LOG("expirationTimeMs: %{public}d, currTime: %{public}d, remainingTime: %{public}d",
+    MEDIA_DEBUG_LOG("expirationTimeMs: %{public}d, currTime: %{public}d, remainingTime: %{public}d",
         static_cast<int>(expirationTimeMs), static_cast<int>(currTime), static_cast<int>(remainingTimeMs));
     return std::chrono::milliseconds(remainingTimeMs);
 }
 
 SteadyClock::SteadyClock() : start_(std::chrono::steady_clock::now())
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
 }
 
 void SteadyClock::Reset()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     start_ = std::chrono::steady_clock::now();
     return;
 }
 
 uint64_t SteadyClock::GetElapsedTimeMs()
 {
-    DP_DEBUG_LOG("entered.");
+    MEDIA_DEBUG_LOG("entered.");
     constexpr int timescale = 1000;
     auto end = std::chrono::steady_clock::now();
     return static_cast<uint64_t>(std::chrono::duration<double>(end - start_).count() * timescale);
diff --git a/services/deferred_processing_service/src/base/timer/time_broker.cpp b/common/src/timer/time_broker.cpp
similarity index 81%
rename from services/deferred_processing_service/src/base/timer/time_broker.cpp
rename to common/src/timer/time_broker.cpp
index 2de4e794140ab9f017d0ccc2c2abbf80a3a7e3b3..65b8d611dd9d5a0c5b526848bc8169ec64afe3dc 100644
--- a/services/deferred_processing_service/src/base/timer/time_broker.cpp
+++ b/common/src/timer/time_broker.cpp
@@ -15,14 +15,14 @@
 
 #include "timer/time_broker.h"
 #include "timer/steady_clock.h"
-#include "dp_log.h"
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
 namespace DeferredProcessing {
 std::shared_ptr<TimeBroker> TimeBroker::Create(std::string name)
 {
-    DP_DEBUG_LOG("(%s) created.", name.c_str());
+    MEDIA_DEBUG_LOG("(%s) created.", name.c_str());
     auto timeBroker = std::make_shared<TimeBroker>(std::move(name));
     timeBroker->Initialize();
     return timeBroker;
@@ -31,13 +31,13 @@ std::shared_ptr<TimeBroker> TimeBroker::Create(std::string name)
 TimeBroker::TimeBroker(std::string name)
     : name_(std::move(name)), timer_(nullptr), timerInfos_(), expiringTimers_()
 {
-    DP_DEBUG_LOG("(%s) entered.", name_.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", name_.c_str());
 }
 
 TimeBroker::~TimeBroker()
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_DEBUG_LOG("(%s) entered.", name_.c_str());
+    MEDIA_DEBUG_LOG("(%s) entered.", name_.c_str());
     if (timer_) {
         timer_->Stop();
         timer_.reset();
@@ -60,7 +60,8 @@ bool TimeBroker::RegisterCallback(uint32_t delayTimeMs, std::function<void(uint3
     uint32_t& handle)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_DEBUG_LOG("(%s) register callback with delayTimeMs (%{public}d).", name_.c_str(), static_cast<int>(delayTimeMs));
+    MEDIA_DEBUG_LOG("(%s) register callback with delayTimeMs (%{public}d).",
+        name_.c_str(), static_cast<int>(delayTimeMs));
     auto ret = GetNextHandle(handle);
     if (ret) {
         auto timestamp = SteadyClock::GetTimestampMilli() + delayTimeMs;
@@ -78,7 +79,7 @@ void TimeBroker::DeregisterCallback(uint32_t handle)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (handle == 0) {
-        DP_DEBUG_LOG("(%s) invalid handle (%{public}d).", name_.c_str(), static_cast<int>(handle));
+        MEDIA_DEBUG_LOG("(%s) invalid handle (%{public}d).", name_.c_str(), static_cast<int>(handle));
         return;
     }
     timerInfos_.erase(handle);
@@ -91,7 +92,7 @@ std::function<void(uint32_t handle)> TimeBroker::GetExpiredFunc(uint32_t handle)
         return timerInfos_[handle]->timerCallback;
     }
     return [](uint32_t handle) {
-        DP_ERR_LOG("GetExpiredFunc invalid ExpiredFunc (%{public}d).", static_cast<int>(handle));
+        MEDIA_ERR_LOG("GetExpiredFunc invalid ExpiredFunc (%{public}d).", static_cast<int>(handle));
     };
 }
 
@@ -121,9 +122,9 @@ void TimeBroker::TimerExpired()
     std::vector<std::shared_ptr<TimerInfo>> timerInfos;
     {
         std::lock_guard<std::mutex> lock(mutex_);
-        DP_DEBUG_LOG("(%s) TimerExpired.", name_.c_str());
+        MEDIA_DEBUG_LOG("(%s) TimerExpired.", name_.c_str());
         if (timeline_.empty()) {
-            DP_DEBUG_LOG("(%s) unexpected TimerExpired", name_.c_str());
+            MEDIA_DEBUG_LOG("(%s) unexpected TimerExpired", name_.c_str());
             return;
         }
         auto timestamp = timeline_.top();
@@ -138,7 +139,7 @@ void TimeBroker::TimerExpired()
         expiringTimers_.erase(timestamp);
         auto ret = RestartTimer(timestamp);
         if (!ret) {
-            DP_DEBUG_LOG("(%s) RestartTimer failed (%{public}d)", name_.c_str(), ret);
+            MEDIA_DEBUG_LOG("(%s) RestartTimer failed (%{public}d)", name_.c_str(), ret);
         }
     }
     for (auto &timerInfo : timerInfos) {
@@ -149,11 +150,11 @@ void TimeBroker::TimerExpired()
 bool TimeBroker::RestartTimer(bool force)
 {
     if (timeline_.empty() || (timer_->IsActive() && force == false)) {
-        DP_DEBUG_LOG("(%s) RestartTimer unnecessary.", name_.c_str());
+        MEDIA_DEBUG_LOG("(%s) RestartTimer unnecessary.", name_.c_str());
         return true;
     }
     auto timestamp = timeline_.top();
-    DP_DEBUG_LOG("(%s) restart timer, expiring timestamp: %{public}d", name_.c_str(), static_cast<int>(timestamp));
+    MEDIA_DEBUG_LOG("(%s) restart timer, expiring timestamp: %{public}d", name_.c_str(), static_cast<int>(timestamp));
     return timer_->StartAt(timestamp);
 }
 } //namespace DeferredProcessing
diff --git a/services/deferred_processing_service/include/utils/watch_dog.h b/common/utils/watch_dog.h
similarity index 73%
rename from services/deferred_processing_service/include/utils/watch_dog.h
rename to common/utils/watch_dog.h
index 0aeaf622613d80e9399a919c9fe6cf1ea6ff3261..9e4bc7cfb20d78ae9455e5a3a46207453c88ec91 100644
--- a/services/deferred_processing_service/include/utils/watch_dog.h
+++ b/common/utils/watch_dog.h
@@ -16,24 +16,24 @@
 #ifndef OHOS_DEFERRED_PROCESSING_SERVICE_WATCH_DOG_H
 #define OHOS_DEFERRED_PROCESSING_SERVICE_WATCH_DOG_H
 
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
 #include "timer/time_broker.h"
-#include "dp_log.h"
+#include "camera_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
 namespace DeferredProcessing {
 class Watchdog {
 public:
+    static Watchdog& GetGlobalWatchdog()
+    {
+        static Watchdog instance("GlobalWatchdog");
+        return instance;
+    }
+
     explicit Watchdog(std::string name)
         : name_(std::move(name)), timeBroker_(TimeBroker::Create(name_))
     {
-        DP_INFO_LOG("(%{public}s) entered.", name_.c_str());
+        MEDIA_INFO_LOG("(%{public}s) entered.", name_.c_str());
     }
 
     Watchdog(const Watchdog& other) = delete;
@@ -48,15 +48,16 @@ public:
     {
         std::lock_guard<std::mutex> lock(mutex_);
         if (!timeBroker_) {
-            DP_ERR_LOG("(%{public}s) timerBroker_ nullptr.", name_.c_str());
+            MEDIA_ERR_LOG("(%{public}s) timerBroker_ nullptr.", name_.c_str());
             return;
         }
         bool ret = timeBroker_->RegisterCallback(durationMs,
         [callback = std::move(callback)](uint32_t handle) {callback(handle); }, handle);
         if (ret) {
-            DP_INFO_LOG("(%{public}s) handle = %{public}d", name_.c_str(), handle);
+            MEDIA_INFO_LOG("(%{public}s) handle = %{public}d", name_.c_str(), handle);
         } else {
-            DP_ERR_LOG("(%{public}s) timerBroker_ RegisterCallback failed, status = %{public}d.", name_.c_str(), ret);
+            MEDIA_ERR_LOG("(%{public}s) timerBroker_ RegisterCallback failed, status = %{public}d.",
+                name_.c_str(), ret);
         }
     }
 
@@ -64,10 +65,10 @@ public:
     {
         std::lock_guard<std::mutex> lock(mutex_);
         if (timeBroker_) {
-            DP_INFO_LOG("(%{public}s) handle = %{public}d", name_.c_str(), handle);
+            MEDIA_INFO_LOG("(%{public}s) handle = %{public}d", name_.c_str(), handle);
             timeBroker_->DeregisterCallback(handle);
         } else {
-            DP_ERR_LOG("(%{public}s) failed", name_.c_str());
+            MEDIA_ERR_LOG("(%{public}s) failed", name_.c_str());
         }
     }
 
@@ -76,9 +77,9 @@ public:
         std::lock_guard<std::mutex> lock(mutex_);
         if (timeBroker_) {
             timeBroker_->GetExpiredFunc(handle)(handle);
-            DP_INFO_LOG("(%s) handle = %{public}d", name_.c_str(), handle);
+            MEDIA_INFO_LOG("(%s) handle = %{public}d", name_.c_str(), handle);
         } else {
-            DP_ERR_LOG("(%s) failed", name_.c_str());
+            MEDIA_ERR_LOG("(%s) failed", name_.c_str());
         }
     }
 private:
diff --git a/dynamic_libs/BUILD.gn b/dynamic_libs/BUILD.gn
index 558dde985039c32f47bbc32b2d32efcbae257c58..abb7622f686b42ee852b49bb9b62422fa1012ff9 100644
--- a/dynamic_libs/BUILD.gn
+++ b/dynamic_libs/BUILD.gn
@@ -181,8 +181,6 @@ config("camera_dynamic_moving_photo_public_config") {
     "${multimedia_camera_framework_path}/services/camera_service/include",
     "${multimedia_camera_framework_path}/services/camera_service/include/camera_buffer_manager",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager/task_group",
   ]
 }
 
@@ -275,9 +273,6 @@ config("camera_dynamic_media_manager_public_config") {
     "${multimedia_camera_framework_path}/dynamic_libs/media_manager/include",
     "${multimedia_camera_framework_path}/dynamic_libs/media_manager/include/media_manager",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer/core",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/dfx",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/utils",
   ]
@@ -305,12 +300,6 @@ ohos_shared_library("camera_dynamic_media_manager") {
     "${multimedia_camera_framework_path}/dynamic_libs/media_manager/src/media_manager/track.cpp",
     "${multimedia_camera_framework_path}/dynamic_libs/media_manager/src/media_manager/writer.cpp",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/src/utils/dp_utils.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/core/timer_core.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/camera_deferred_timer.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/time_broker.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/timer/steady_clock.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/src/dfx/dps_event_report.cpp",
   ]
   cflags = [
diff --git a/frameworks/native/camera/base/src/output/photo_output.cpp b/frameworks/native/camera/base/src/output/photo_output.cpp
index 244a5abd990cff43d0ae1d75ddb76ea01e7160f3..6a6316342e459fe47cb711bbc4d722797ab8004a 100644
--- a/frameworks/native/camera/base/src/output/photo_output.cpp
+++ b/frameworks/native/camera/base/src/output/photo_output.cpp
@@ -29,7 +29,7 @@
 #include "session/capture_session.h"
 #include "picture_interface.h"
 #include "task_manager.h"
-#include "dp_utils.h"
+#include "watch_dog.h"
 #include "display/graphic/common/v1_0/cm_color_space.h"
 #include "display/graphic/common/v2_1/cm_color_space.h"
 #include <pixel_map.h>
@@ -236,7 +236,7 @@ int32_t HStreamCaptureCallbackImpl::OnCaptureEnded(const int32_t captureId, cons
     callback->OnCaptureEnded(captureId, frameCount);
     auto timeStartIter = photoOutput->captureIdToCaptureInfoMap_.find(captureId);
     if (timeStartIter != photoOutput->captureIdToCaptureInfoMap_.end()) {
-        DeferredProcessing::GetGlobalWatchdog().StopMonitor((timeStartIter->second).CaptureHandle);
+        DeferredProcessing::Watchdog::GetGlobalWatchdog().StopMonitor((timeStartIter->second).CaptureHandle);
     }
     return CAMERA_OK;
     // LCOV_EXCL_STOP
@@ -286,7 +286,7 @@ int32_t HStreamCaptureCallbackImpl::OnFrameShutterEnd(const int32_t captureId, c
     uint32_t startCaptureHandle;
     constexpr uint32_t delayMilli = 10 * 1000; // 10S 1000 is ms
     MEDIA_INFO_LOG("offline GetGlobalWatchdog StartMonitor, captureId=%{public}d", captureId);
-    DeferredProcessing::GetGlobalWatchdog().StartMonitor(
+    DeferredProcessing::Watchdog::GetGlobalWatchdog().StartMonitor(
         startCaptureHandle, delayMilli, [captureId, photoOutput](uint32_t handle) {
             MEDIA_INFO_LOG("offline Watchdog executed, handle: %{public}d, captureId= %{public}d",
                 static_cast<int>(handle), captureId);
diff --git a/frameworks/native/camera/test/unittest/camera_deferred_unittest/BUILD.gn b/frameworks/native/camera/test/unittest/camera_deferred_unittest/BUILD.gn
index e4d5ebf37595592058b4f96d85d9678e901a367a..437325745f66986852540b7613fce99f9ac0da1d 100644
--- a/frameworks/native/camera/test/unittest/camera_deferred_unittest/BUILD.gn
+++ b/frameworks/native/camera/test/unittest/camera_deferred_unittest/BUILD.gn
@@ -34,10 +34,6 @@ ohos_unittest("camera_deferred_unittest") {
     "${multimedia_camera_framework_path}/services/deferred_processing_service/binder/server/include",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/buffer_manager",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/command_server",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager/task_group",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer/core",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/dfx",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/event_monitor",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/event_monitor/base",
diff --git a/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_base_test/src/camera_deferred_base_unittest.cpp b/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_base_test/src/camera_deferred_base_unittest.cpp
index f1d0c6ba9fae09dcdfa20a14738facc04e1588db..ec8c4692bd5b6b074115a9a668d5a39a055ffe76 100644
--- a/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_base_test/src/camera_deferred_base_unittest.cpp
+++ b/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_base_test/src/camera_deferred_base_unittest.cpp
@@ -22,7 +22,7 @@
 
 #include "session_manager.h"
 #include "shared_buffer.h"
-#include "thread_pool.h"
+#include "task_manager/thread_pool.h"
 #include "timer/core/timer_core.h"
 #include "timer/steady_clock.h"
 #include "timer/time_broker.h"
diff --git a/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_utils_test/src/deferred_utils_unittest.cpp b/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_utils_test/src/deferred_utils_unittest.cpp
index 0310fac14199cad104f6f76eebf4f2bbec787a5b..44c87c29f076dfa365665a6ba24c339381724b3b 100644
--- a/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_utils_test/src/deferred_utils_unittest.cpp
+++ b/frameworks/native/camera/test/unittest/camera_deferred_unittest/camera_deferred_utils_test/src/deferred_utils_unittest.cpp
@@ -81,7 +81,7 @@ HWTEST_F(DeferredUtilsUnitTest, deferred_utils_unittest_002, TestSize.Level1)
  */
 HWTEST_F(DeferredUtilsUnitTest, deferred_utils_unittest_005, TestSize.Level1)
 {
-    EXPECT_EQ(GetGlobalWatchdog().name_, "DPSGlobalWatchdog");
+    EXPECT_EQ(Watchdog::GetGlobalWatchdog().name_, "DPSGlobalWatchdog");
 }
 
 /*
diff --git a/services/camera_service/BUILD.gn b/services/camera_service/BUILD.gn
index 002c7edcaad148e2a995945ffce979e72eba065c..4824a0c1b26d50b3c26aec85bf12a571c88db529 100644
--- a/services/camera_service/BUILD.gn
+++ b/services/camera_service/BUILD.gn
@@ -108,6 +108,7 @@ ohos_shared_library("camera_service") {
   }
 
   include_dirs = [
+    "${multimedia_camera_framework_path}/common/include/task_manager",
     "${multimedia_camera_framework_path}/services/camera_service/include",
     "${multimedia_camera_framework_path}/common/utils",
     "${multimedia_camera_framework_path}/dynamic_libs/moving_photo/include",
diff --git a/services/camera_service/src/camera_buffer_manager/photo_asset_auxiliary_consumer.cpp b/services/camera_service/src/camera_buffer_manager/photo_asset_auxiliary_consumer.cpp
index bd5bd3e9bbc6129e841231f3638019e399903087..4903771c7557f4e249e483b552c187873f056a6c 100644
--- a/services/camera_service/src/camera_buffer_manager/photo_asset_auxiliary_consumer.cpp
+++ b/services/camera_service/src/camera_buffer_manager/photo_asset_auxiliary_consumer.cpp
@@ -18,8 +18,8 @@
 #include "hstream_capture.h"
 #include "task_manager.h"
 #include "camera_surface_buffer_util.h"
-#include "dp_utils.h"
 #include "buffer_extra_data_impl.h"
+#include "watch_dog.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -125,8 +125,8 @@ void AuxiliaryBufferConsumer::ExecuteOnBufferAvailable()
             MEDIA_INFO_LOG("AuxiliaryBufferConsumer StopMonitor, surfaceName=%{public}s, pictureHandle = %{public}d, "
                            "captureId = %{public}d",
                 surfaceName_.c_str(), pictureHandle, captureId);
-            DeferredProcessing::GetGlobalWatchdog().DoTimeout(pictureHandle);
-            DeferredProcessing::GetGlobalWatchdog().StopMonitor(pictureHandle);
+            DeferredProcessing::Watchdog::GetGlobalWatchdog().DoTimeout(pictureHandle);
+            DeferredProcessing::Watchdog::GetGlobalWatchdog().StopMonitor(pictureHandle);
             streamCapture->captureIdAuxiliaryCountMap_[captureId] = -1;
             MEDIA_INFO_LOG("AuxiliaryBufferConsumer captureIdAuxiliaryCountMap_ = -1");
         }
diff --git a/services/camera_service/src/camera_buffer_manager/photo_asset_buffer_consumer.cpp b/services/camera_service/src/camera_buffer_manager/photo_asset_buffer_consumer.cpp
index 7d9a2ac87374ab507245647c27b724dfb2fec306..d0ecb40a531a9647559a0d84b68724854931eeb3 100644
--- a/services/camera_service/src/camera_buffer_manager/photo_asset_buffer_consumer.cpp
+++ b/services/camera_service/src/camera_buffer_manager/photo_asset_buffer_consumer.cpp
@@ -20,10 +20,10 @@
 #include "hstream_capture.h"
 #include "task_manager.h"
 #include "picture_assembler.h"
-#include "dp_utils.h"
 #include "camera_server_photo_proxy.h"
 #include "picture_proxy.h"
 #include "camera_report_dfx_uitls.h"
+#include "watch_dog.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -141,7 +141,7 @@ void PhotoAssetBufferConsumer::StartWaitAuxiliaryTask(
                 "PhotoAssetBufferConsumer StartWaitAuxiliaryTask GetGlobalWatchdog StartMonitor, captureId=%{public}d",
                 captureId);
             auto thisPtr = wptr<PhotoAssetBufferConsumer>(this);
-            DeferredProcessing::GetGlobalWatchdog().StartMonitor(
+            DeferredProcessing::Watchdog::GetGlobalWatchdog().StartMonitor(
                 pictureHandle, delayMilli, [thisPtr, captureId, timestamp](uint32_t handle) {
                     MEDIA_INFO_LOG(
                         "PhotoAssetBufferConsumer PhotoAssetBufferConsumer-Watchdog executed, handle: %{public}d, "
diff --git a/services/deferred_processing_service/include/base/command_server/command_server_impl.h b/services/deferred_processing_service/include/base/command_server/command_server_impl.h
index 7c1b63a34aaa02fba3294398de3478a79ef552cc..4c51ba79f6001462cced4be8d9cc055818046daf 100644
--- a/services/deferred_processing_service/include/base/command_server/command_server_impl.h
+++ b/services/deferred_processing_service/include/base/command_server/command_server_impl.h
@@ -17,7 +17,7 @@
 #define OHOS_CAMERA_DPS_COMMAND_SERVER_IMPL_H
 
 #include "command.h"
-#include "thread_pool.h"
+#include "include/task_manager/thread_pool.h"
 
 namespace OHOS {
 namespace CameraStandard {
diff --git a/services/deferred_processing_service/include/utils/dp_utils.h b/services/deferred_processing_service/include/utils/dp_utils.h
index e52a107be40923ba781a2af21893c93c4ebb0fdb..94fd513ac1c132101db111b2fabc4c1f3cd5d64d 100644
--- a/services/deferred_processing_service/include/utils/dp_utils.h
+++ b/services/deferred_processing_service/include/utils/dp_utils.h
@@ -16,10 +16,8 @@
 #ifndef OHOS_CAMERA_DPS_UTILS_H
 #define OHOS_CAMERA_DPS_UTILS_H
 
-#include <unistd.h>
-
-#include "watch_dog.h"
 #include "camera_hdi_const.h"
+#include "dp_log.h"
 
 namespace OHOS {
 namespace CameraStandard {
@@ -155,7 +153,6 @@ inline bool StrToI64(const std::string &str, int64_t &value)
     return isOK && (tmp >= INT64_MIN && tmp <= INT64_MAX);
 }
 
-Watchdog& GetGlobalWatchdog();
 struct DpsCallerInfo {
     int32_t pid;
     int32_t uid;
diff --git a/services/deferred_processing_service/src/dfx/dps_event_report.cpp b/services/deferred_processing_service/src/dfx/dps_event_report.cpp
index 333b0b615e6dfe5a58dac84d6ec7045e514d0575..cffaf32212af6b50b1e419a47b55ad3c1cd8cc5e 100644
--- a/services/deferred_processing_service/src/dfx/dps_event_report.cpp
+++ b/services/deferred_processing_service/src/dfx/dps_event_report.cpp
@@ -21,7 +21,7 @@
 #include "dps_event_report.h"
 #include "hisysevent.h"
 #include "dp_log.h"
-#include "timer/steady_clock.h"
+#include "dp_utils.h"
 #include "ideferred_photo_processing_session.h"
 
 namespace OHOS {
@@ -269,7 +269,7 @@ void DPSEventReport::UpdateProcessDoneTime(const std::string& imageId, int32_t u
     std::unique_lock<std::recursive_mutex> lock(mutex_);
     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
-        uint64_t currentTime = SteadyClock::GetTimestampMilli();
+        uint64_t currentTime = GetTimestampMilli();
         (imageIdToEventInfoTemp->second)[imageId].imageDoneTimeBeginTime = currentTime;
         (imageIdToEventInfoTemp->second)[imageId].processTimeEndTime = currentTime;
     }
@@ -330,7 +330,7 @@ void DPSEventReport::UpdateRemoveTime(const std::string& imageId, int32_t userId
     std::unique_lock<std::recursive_mutex> lock(mutex_);
     auto imageIdToEventInfoTemp = userIdToImageIdEventInfo.find(userId);
     if (imageIdToEventInfoTemp != userIdToImageIdEventInfo.end()) {
-        uint64_t currentTime = SteadyClock::GetTimestampMilli();
+        uint64_t currentTime = GetTimestampMilli();
         (imageIdToEventInfoTemp->second)[imageId].removeTimeEndTime = currentTime;
         ReportImageProcessResult(imageId, userId);
     }
diff --git a/services/deferred_processing_service/src/utils/dp_utils.cpp b/services/deferred_processing_service/src/utils/dp_utils.cpp
index a6e69a84a98036a0f797e3fdeea52d5292a4755a..301d3076c05296745df644340868603526c8459e 100644
--- a/services/deferred_processing_service/src/utils/dp_utils.cpp
+++ b/services/deferred_processing_service/src/utils/dp_utils.cpp
@@ -24,12 +24,6 @@
 namespace OHOS {
 namespace CameraStandard {
 namespace DeferredProcessing {
-Watchdog& GetGlobalWatchdog()
-{
-    static Watchdog instance("DPSGlobalWatchdog");
-    return instance;
-}
-
 std::string GetClientBundle(int uid)
 {
     std::string bundleName = "";
diff --git a/test/fuzztest/hstreamoperator_fuzzer/BUILD.gn b/test/fuzztest/hstreamoperator_fuzzer/BUILD.gn
index 43df9f83d34c0c7d3382a62cb0fc5ae1e4fb5b8e..7a9013c017b9d8864a8e8589757c87402e01380c 100644
--- a/test/fuzztest/hstreamoperator_fuzzer/BUILD.gn
+++ b/test/fuzztest/hstreamoperator_fuzzer/BUILD.gn
@@ -43,9 +43,6 @@ ohos_fuzztest("HStreamOperatorFuzzTest") {
     "${multimedia_camera_framework_path}/services/deferred_processing_service/binder/client/include",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/binder/server/include",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/buffer_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager/task_group",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer/core",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/dfx",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/event_monitor",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/post_processor",
@@ -71,6 +68,7 @@ ohos_fuzztest("HStreamOperatorFuzzTest") {
   sources = [ "hstream_operator_fuzzer.cpp" ]
 
   deps = [
+    "${multimedia_camera_framework_path}/common:camera_utils",
     "${multimedia_camera_framework_path}/frameworks/native/camera/base:camera_framework",
     "${multimedia_camera_framework_path}/services/camera_service:camera_service",
     "${multimedia_camera_framework_path}/dynamic_libs:camera_dynamic_moving_photo",
diff --git a/test/fuzztest/timercore_fuzzer/BUILD.gn b/test/fuzztest/timercore_fuzzer/BUILD.gn
index e05a16f012acfe8c970cda20932046a88bd22d0b..854d4de7da0bc92398087b3c79fde78863115894 100644
--- a/test/fuzztest/timercore_fuzzer/BUILD.gn
+++ b/test/fuzztest/timercore_fuzzer/BUILD.gn
@@ -28,9 +28,6 @@ ohos_fuzztest("TimerCoreFuzzTest") {
     "${multimedia_camera_framework_path}/interfaces/inner_api/native/camera/include/output/",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base",
     "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/command_server",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/task_manager",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer/core",
-    "${multimedia_camera_framework_path}/services/deferred_processing_service/include/base/timer",
   ]
 
   cflags = [