diff --git a/frameworks/native/ndk/impl/capture_session_impl.cpp b/frameworks/native/ndk/impl/capture_session_impl.cpp
index 322c3283da5b1a3132d4d493f327df88feb440bb..6978b89a45920985bef2d54ffd55094d2b2d34e2 100644
--- a/frameworks/native/ndk/impl/capture_session_impl.cpp
+++ b/frameworks/native/ndk/impl/capture_session_impl.cpp
@@ -107,6 +107,7 @@ Camera_ErrorCode Camera_CaptureSession::AddSecureOutput(Camera_PreviewOutput* pr
 Camera_ErrorCode Camera_CaptureSession::BeginConfig()
 {
     int32_t ret = innerCaptureSession_->BeginConfig();
+    innerCaptureSession_->EnableDeferredType(DELIVERY_NONE, true);
     return FrameworkToNdkCameraError(ret);
 }
 
diff --git a/services/deferred_processing_service/include/utils/watch_dog.h b/services/deferred_processing_service/include/utils/watch_dog.h
index 5e074a7c3a4e69938bcb8baece35fa2290cf406d..25d12385a25d821af6cdc796c702307aa7dcbcec 100644
--- a/services/deferred_processing_service/include/utils/watch_dog.h
+++ b/services/deferred_processing_service/include/utils/watch_dog.h
@@ -54,9 +54,9 @@ public:
         bool ret = timeBroker_->RegisterCallback(durationMs,
         [callback = std::move(callback)](uint32_t handle) {callback(handle); }, handle);
         if (ret) {
-            DP_INFO_LOG("(%s) handle = %d", name_.c_str(), handle);
+            DP_INFO_LOG("(%s) handle = %{public}d", name_.c_str(), handle);
         } else {
-            DP_ERR_LOG("(%s) timerBroker_ RegisterCallback failed, status = %d.", name_.c_str(), ret);
+            DP_ERR_LOG("(%s) timerBroker_ RegisterCallback failed, status = %{public}d.", name_.c_str(), ret);
         }
     }
 
@@ -64,7 +64,7 @@ public:
     {
         std::lock_guard<std::mutex> lock(mutex_);
         if (timeBroker_) {
-            DP_INFO_LOG("(%s) handle = %d", name_.c_str(), handle);
+            DP_INFO_LOG("(%s) handle = %{public}d", name_.c_str(), handle);
             timeBroker_->DeregisterCallback(handle);
         } else {
             DP_ERR_LOG("(%s) failed", name_.c_str());
diff --git a/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp b/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp
index f2d3028004db3c25aaf6bf5bc54eb6725c76cc31..6def9f4ec73ee2ae3cb0666512b97f750c18f7bc 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/task_group/base_task_group.cpp
@@ -33,7 +33,7 @@ BaseTaskGroup::BaseTaskGroup(const std::string& name, TaskFunc func, bool serial
 
 BaseTaskGroup::~BaseTaskGroup()
 {
-    DP_DEBUG_LOG("task group name: %s, handle: %d", name_.c_str(), static_cast<int>(handle_));
+    DP_DEBUG_LOG("task group name: %s, handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
     que_.SetActive(false);
     que_.Clear();
 }
@@ -42,7 +42,7 @@ void BaseTaskGroup::Initialize()
 {
     handle_ = GenerateHandle();
     que_.SetActive(true);
-    DP_DEBUG_LOG("task group (%s), handle: %d", name_.c_str(), static_cast<int>(handle_));
+    DP_DEBUG_LOG("task group (%s), handle: %{public}d", name_.c_str(), static_cast<int>(handle_));
 }
 
 const std::string& BaseTaskGroup::GetName()
@@ -59,9 +59,9 @@ bool BaseTaskGroup::SubmitTask(std::any param)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (que_.Full()) {
-        DP_WARNING_LOG("Submit task (%s), handle: %d, que is full!", name_.c_str(), static_cast<int>(handle_));
+        DP_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: %d, size: %zu.", name_.c_str(),
+        DP_DEBUG_LOG("Submit task (%s), handle: %{public}d, size: %zu.", name_.c_str(),
             static_cast<int>(handle_), que_.Size());
     }
     que_.Push(std::move(param));
@@ -83,7 +83,8 @@ std::function<void()> BaseTaskGroup::GetTaskUnlocked()
             thiz->OnTaskComplete();
         }
     };
-    DP_DEBUG_LOG("return one task %s, handle:%d, size: %zu.", name_.c_str(), static_cast<int>(handle_), que_.Size());
+    DP_DEBUG_LOG("return one task %s, handle:%{public}d, size: %zu.", name_.c_str(), static_cast<int>(handle_),
+        que_.Size());
     return task;
 }
 
@@ -108,7 +109,7 @@ void BaseTaskGroup::DispatchTaskUnlocked()
         inflight_ = true;
         threadPool_->Submit([task = std::move(task)] { task(); });
     } else {
-        DP_DEBUG_LOG("all tasks have completed for %s handle:%d.", name_.c_str(), static_cast<int>(handle_));
+        DP_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/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp
index 83f290e18440b1bbbc0bdbddfdeb241b1efce4a1..3eb9dd78d5d68754fbf858dfbf9ee77ba6cadff1 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/task_group/delayed_task_group.cpp
@@ -52,7 +52,7 @@ bool DelayedTaskGroup::SubmitTask(std::any param)
     }
     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 %d ,expiring timestamp: %d",
+    DP_DEBUG_LOG("(%s) SubmitTask, delayTimeMs %{public}d ,expiring timestamp: %{public}d",
         GetName().c_str(),
         static_cast<int>(delayTimeMs),
         static_cast<int>(SteadyClock::GetTimestampMilli() + delayTimeMs));
@@ -68,10 +68,10 @@ bool DelayedTaskGroup::SubmitTask(std::any param)
     
 void DelayedTaskGroup::TimerExpired(uint32_t handle)
 {
-    DP_DEBUG_LOG("(%s) TimerExpired, handle = %d", GetName().c_str(), static_cast<int>(handle));
+    DP_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 = %d", GetName().c_str(), static_cast<int>(handle));
+        DP_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_manager.cpp b/services/deferred_processing_service/src/base/task_manager/task_manager.cpp
index 8f96052a27eda827bc65e7de99953d5322991ef5..b90f68d6a28696b7d1d118577b353b8d46d2bd02 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_manager.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/task_manager.cpp
@@ -30,7 +30,7 @@ TaskManager::TaskManager(const std::string& name, uint32_t  numThreads, bool ser
       defaultTaskHandle_(INVALID_TASK_GROUP_HANDLE),
       delayedTaskHandle_(INVALID_TASK_GROUP_HANDLE)
 {
-    DP_INFO_LOG("name: %s, maxThreads: %d.", name.c_str(), numThreads);
+    DP_INFO_LOG("name: %s, maxThreads: %{public}d.", name.c_str(), numThreads);
     Initialize();
 }
 
@@ -41,7 +41,8 @@ void TaskManager::Initialize()
     taskRegistry_ = std::make_unique<TaskRegistry>(name_, pool_.get());
     auto ret = RegisterTaskGroup("defaultTaskGroup",
         [this](std::any param) { DoDefaultWorks(std::move(param)); }, serial_, false, defaultTaskHandle_);
-    DP_INFO_LOG("register default task group: %d, handle: %d", ret, static_cast<int>(defaultTaskHandle_));
+    DP_INFO_LOG("register default task group: %{public}d, handle: %{public}d", ret,
+        static_cast<int>(defaultTaskHandle_));
     (void)(ret);
     return;
 }
@@ -90,7 +91,7 @@ bool TaskManager::DeregisterTaskGroup(const std::string& name, TaskGroupHandle&
     bool ret = false;
     if (taskRegistry_) {
         ret = taskRegistry_->DeregisterTaskGroup(name, handle);
-        DP_INFO_LOG("deregister task group: %s, ret: %d", name.c_str(), ret);
+        DP_INFO_LOG("deregister task group: %s, ret: %{public}d", name.c_str(), ret);
     } else {
         DP_INFO_LOG("invalid ptr");
     }
@@ -110,7 +111,7 @@ 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: %d", static_cast<int>(handle));
+    DP_INFO_LOG("submit task to handle: %{public}d", static_cast<int>(handle));
     if (taskRegistry_ == nullptr) {
         DP_ERR_LOG("invalid ptr");
         return false;
diff --git a/services/deferred_processing_service/src/base/task_manager/task_registry.cpp b/services/deferred_processing_service/src/base/task_manager/task_registry.cpp
index 5ec0a0d04c3f57b1620b1e09a216076b1c760337..226b831ad26121ba438283af09a160db6d015b71 100644
--- a/services/deferred_processing_service/src/base/task_manager/task_registry.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/task_registry.cpp
@@ -37,7 +37,7 @@ TaskRegistry::~TaskRegistry()
 bool TaskRegistry::RegisterTaskGroup(const std::string& name, TaskFunc func, bool serial, bool delayTask,
     TaskGroupHandle& handle)
 {
-    DP_DEBUG_LOG("name: %s, serial: %d, delayTask: %d.", name.c_str(), serial, delayTask);
+    DP_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());
         return false;
@@ -61,14 +61,14 @@ bool TaskRegistry::DeregisterTaskGroup(const std::string& name, TaskGroupHandle&
 {
     DP_DEBUG_LOG("name: %s.", name.c_str());
     if (!IsTaskGroupAlreadyRegistered(name)) {
-        DP_DEBUG_LOG("name: %s, with handle:%d, failed due to non exist task group!",
+        DP_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:%d failed due to non-existent task group!",
+        DP_DEBUG_LOG("name: %s, handle:%{public}d failed due to non-existent task group!",
             name.c_str(), static_cast<int>(handle));
         return false;
     }
@@ -78,11 +78,11 @@ bool TaskRegistry::DeregisterTaskGroup(const std::string& name, TaskGroupHandle&
 
 bool TaskRegistry::SubmitTask(TaskGroupHandle handle, std::any param)
 {
-    DP_DEBUG_LOG("submit one task to %d", static_cast<int>(handle));
+    DP_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 %d non-exist!", static_cast<int>(handle));
+        DP_DEBUG_LOG("failed due to task group %{public}d non-exist!", static_cast<int>(handle));
         return false;
     }
     return it->second->SubmitTask(std::move(param));
diff --git a/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp b/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp
index 9970f60fe32e1d388dbcdfb06229d9ea813ba87b..c5769ff06e2a1886535899fe83e5d5bfe8cc9ad6 100644
--- a/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/thread_pool.cpp
@@ -106,10 +106,10 @@ 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: %d, policy = %d(0:OTHER, 1:FIFO, 2:RR)", workerInfo.name.c_str(),
-                         sch.sched_priority, policy);
+            DP_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 = %d.", workerInfo.name.c_str(), ret);
+            DP_DEBUG_LOG("thread (%s) pthread_getschedparam failed, ret = %{public}d.", workerInfo.name.c_str(), ret);
         }
     }
 }
diff --git a/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp b/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp
index b9d8342f0801036b0e4e08dcb3191f7ad28c3920..804968287c66d4450f21069ca16e2b66a674a9d5 100644
--- a/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp
+++ b/services/deferred_processing_service/src/base/task_manager/thread_utils.cpp
@@ -27,10 +27,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: %d", name.c_str(), threadNameMaxSize);
+        DP_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: %ld, threadName: %s, pthread_setname_np ret = %d.",
+    DP_DEBUG_LOG("threadId: %ld, threadName: %s, pthread_setname_np ret = %{public}d.",
         static_cast<long>(pthread_gettid_np(tid)), threadName.c_str(), ret);
 }
 
@@ -43,9 +43,10 @@ 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 (%d).", static_cast<long>(tid), priority);
+        DP_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 (%d), ret = %d.", static_cast<long>(tid), priority, ret);
+        DP_DEBUG_LOG("failed for tid (%ld) with priority (%{public}d), ret = %{public}d.",
+            static_cast<long>(tid), priority, ret);
     }
 }
 } //namespace DeferredProcessing
diff --git a/services/deferred_processing_service/src/base/timer/core/timer_core.cpp b/services/deferred_processing_service/src/base/timer/core/timer_core.cpp
index 893b6c400b7a73c9689fbd36562f609d6397a856..39aa9b84695d775595657f36c506bbeb51931600 100644
--- a/services/deferred_processing_service/src/base/timer/core/timer_core.cpp
+++ b/services/deferred_processing_service/src/base/timer/core/timer_core.cpp
@@ -85,7 +85,7 @@ bool TimerCore::RegisterTimer(uint64_t timestampMs, const std::shared_ptr<Timer>
         }
     }
     registeredTimers_[timestampMs].push_back(timer);
-    DP_DEBUG_LOG("register timer (%s), timestamp: %d, timeline.top: %d", timer->GetName().c_str(),
+    DP_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;
 }
@@ -99,7 +99,7 @@ bool TimerCore::DeregisterTimer(uint64_t timestampMs, const std::shared_ptr<Time
         DP_ERR_LOG("failed due to nullptr.");
         return false;
     }
-    DP_DEBUG_LOG("(%s, %d) entered.", timer->GetName().c_str(), static_cast<int>(timestampMs));
+    DP_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];
@@ -154,10 +154,10 @@ void TimerCore::DoTimeout()
         auto timestamp = timeline_.top();
         timeline_.pop();
         if (registeredTimers_.count(timestamp) == 0) {
-            DP_DEBUG_LOG("timer for timestamp %d hasn't been registered.", static_cast<int>(timestamp));
+            DP_DEBUG_LOG("timer for timestamp %{public}d hasn't been registered.", static_cast<int>(timestamp));
             return;
         }
-        DP_DEBUG_LOG("expired timestamp: %d", static_cast<int>(timestamp));
+        DP_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/services/deferred_processing_service/src/base/timer/steady_clock.cpp
index f04468db794d14110da5ee23dc8e6a15fe625f3c..440cca9792073e8ba3de62fc598138d56776ac97 100644
--- a/services/deferred_processing_service/src/base/timer/steady_clock.cpp
+++ b/services/deferred_processing_service/src/base/timer/steady_clock.cpp
@@ -39,7 +39,7 @@ uint64_t SteadyClock::GetElapsedTimeMs(uint64_t startMs)
     if (currTime > startMs) {
         diff = currTime - startMs;
     } else {
-        DP_ERR_LOG("invalid parameter, startMs: %d, currTime: %d", static_cast<int>(startMs),
+        DP_ERR_LOG("invalid parameter, startMs: %{public}d, currTime: %{public}d", static_cast<int>(startMs),
             static_cast<int>(currTime));
     }
     return diff;
@@ -49,7 +49,7 @@ std::chrono::milliseconds SteadyClock::GetRemainingTimeMs(uint64_t expirationTim
 {
     auto currTime = SteadyClock::GetTimestampMilli();
     uint64_t remainingTimeMs = (expirationTimeMs > currTime) ? (expirationTimeMs - currTime) : 0;
-    DP_DEBUG_LOG("expirationTimeMs: %d, currTime: %d, remainingTime: %d",
+    DP_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);
 }
diff --git a/services/deferred_processing_service/src/base/timer/time_broker.cpp b/services/deferred_processing_service/src/base/timer/time_broker.cpp
index 0e09a4da19e56f9968b5b6697348c94168f90cba..9c69cf2e8314016688157252cb1abe167b69da01 100644
--- a/services/deferred_processing_service/src/base/timer/time_broker.cpp
+++ b/services/deferred_processing_service/src/base/timer/time_broker.cpp
@@ -62,7 +62,7 @@ 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 (%d).", name_.c_str(), static_cast<int>(delayTimeMs));
+    DP_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;
@@ -80,7 +80,7 @@ void TimeBroker::DeregisterCallback(uint32_t handle)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (handle == 0) {
-        DP_DEBUG_LOG("(%s) invalid handle (%d).", name_.c_str(), static_cast<int>(handle));
+        DP_DEBUG_LOG("(%s) invalid handle (%{public}d).", name_.c_str(), static_cast<int>(handle));
         return;
     }
     timerInfos_.erase(handle);
@@ -129,7 +129,7 @@ void TimeBroker::TimerExpired()
         expiringTimers_.erase(timestamp);
         auto ret = RestartTimer(timestamp);
         if (!ret) {
-            DP_DEBUG_LOG("(%s) RestartTimer failed (%d)", name_.c_str(), ret);
+            DP_DEBUG_LOG("(%s) RestartTimer failed (%{public}d)", name_.c_str(), ret);
         }
     }
     for (auto &timerInfo : timerInfos) {
@@ -144,7 +144,7 @@ bool TimeBroker::RestartTimer(bool force)
         return true;
     }
     auto timestamp = timeline_.top();
-    DP_DEBUG_LOG("(%s) restart timer, expiring timestamp: %d", name_.c_str(), static_cast<int>(timestamp));
+    DP_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/src/base/timer/timer.cpp b/services/deferred_processing_service/src/base/timer/timer.cpp
index fa83faf66ddf30f1fc5adb269bd174fee23e309a..eae196b840c672e42dbbf24cc651f703e28347be 100644
--- a/services/deferred_processing_service/src/base/timer/timer.cpp
+++ b/services/deferred_processing_service/src/base/timer/timer.cpp
@@ -25,7 +25,8 @@ namespace DeferredProcessing {
 std::shared_ptr<Timer> Timer::Create(const std::string& name, TimerType timerType,
     uint32_t intervalMs, TimerCallback callback)
 {
-    DP_DEBUG_LOG("name: %s, timer type: %d(0: once, 1: periodic), intervalMs: %u", name.c_str(), timerType, intervalMs);
+    DP_DEBUG_LOG("name: %s, timer type: %{public}d(0: once, 1: periodic), intervalMs: %u",
+        name.c_str(), timerType, intervalMs);
     struct MakeSharedHelper : public Timer {
         MakeSharedHelper(const std::string& name, TimerType timerType, uint32_t intervalMs, TimerCallback callback)
             : Timer(name, timerType, intervalMs, std::move(callback))
@@ -42,13 +43,13 @@ std::shared_ptr<Timer> Timer::Create(const std::string& name, TimerType timerTyp
 Timer::Timer(const std::string& name, TimerType timerType, uint32_t intervalMs, TimerCallback callback)
     : name_(name), timerType_(timerType), intervalMs_(intervalMs), callback_(std::move(callback)), expiredTimeMs_(0)
 {
-    DP_DEBUG_LOG("name: %s, timer type: %d(0: once, 1: periodic), intervalMs: %u",
+    DP_DEBUG_LOG("name: %s, timer type: %{public}d(0: once, 1: periodic), intervalMs: %u",
         name_.c_str(), timerType, intervalMs);
 }
 
 Timer::~Timer()
 {
-    DP_DEBUG_LOG("name: %s, timer type: %d(0: once, 1: periodic), intervalMs: %u",
+    DP_DEBUG_LOG("name: %s, timer type: %{public}d(0: once, 1: periodic), intervalMs: %u",
         name_.c_str(), timerType_, intervalMs_);
     std::lock_guard<std::mutex> lock(mutex_);
     active_ = false;
@@ -79,7 +80,7 @@ bool Timer::StartAt(uint64_t timestampMs)
 bool Timer::Stop()
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_DEBUG_LOG("stop timer (%s), timer type: %d(0: once, 1: periodic), intervalMs: %u",
+    DP_DEBUG_LOG("stop timer (%s), timer type: %{public}d(0: once, 1: periodic), intervalMs: %u",
         name_.c_str(), timerType_, intervalMs_);
     if (!active_) {
         return true;
@@ -92,7 +93,7 @@ bool Timer::StartUnlocked(uint32_t delayTimeMs)
 {
     auto curTimeMs = SteadyClock::GetTimestampMilli();
     auto timestampMs = curTimeMs + (delayTimeMs == 0 ? intervalMs_ : delayTimeMs);
-    DP_DEBUG_LOG("timer (%s), type: %d(0: once, 1: periodic), curTime: %d, expiredTime: %d",
+    DP_DEBUG_LOG("timer (%s), type: %{public}d(0: once, 1: periodic), curTime: %{public}d, expiredTime: %{public}d",
         name_.c_str(), timerType_, static_cast<int>(curTimeMs), static_cast<int>(timestampMs));
     return StartAtUnlocked(timestampMs);
 }
@@ -118,8 +119,8 @@ void Timer::TimerExpired()
     {
         std::lock_guard<std::mutex> lock(mutex_);
         if (!active_) {
-            DP_DEBUG_LOG("inactive timer (%s) expired, type: %d(0: once, 1: periodic), intervalMs: %u", name_.c_str(),
-                timerType_, intervalMs_);
+            DP_DEBUG_LOG("inactive timer (%s) expired, type: %{public}d(0: once, 1: periodic), intervalMs: %u",
+                name_.c_str(), timerType_, intervalMs_);
             return;
         }
         if (timerType_ == TimerType::PERIODIC) {
@@ -128,8 +129,8 @@ void Timer::TimerExpired()
             active_ = false;
         }
     }
-    DP_DEBUG_LOG("timer (%s) expired, type: %d(0: once, 1: periodic), expiredTimeMs at %d", name_.c_str(),
-        timerType_, static_cast<int>(expiredTimeMs_));
+    DP_DEBUG_LOG("timer (%s) expired, type: %{public}d(0: once, 1: periodic), expiredTimeMs at %{public}d",
+        name_.c_str(), timerType_, static_cast<int>(expiredTimeMs_));
     if (callback_) {
         callback_();
     }
diff --git a/services/deferred_processing_service/src/deferred_processing_service.cpp b/services/deferred_processing_service/src/deferred_processing_service.cpp
index 2f056837b69c16e4a0a9fc1dc22171ce7f8b4b75..6d48df2a7111bdd95f00388662c94b850a47b214 100644
--- a/services/deferred_processing_service/src/deferred_processing_service.cpp
+++ b/services/deferred_processing_service/src/deferred_processing_service.cpp
@@ -76,7 +76,8 @@ void DeferredProcessingService::Stop()
 sptr<IDeferredPhotoProcessingSession> DeferredProcessingService::CreateDeferredPhotoProcessingSession(
     int userId, const sptr<IDeferredPhotoProcessingSessionCallback> callbacks)
 {
-    DP_INFO_LOG("DeferredProcessingService::CreateDeferredPhotoProcessingSession create session, userId: %d", userId);
+    DP_INFO_LOG("DeferredProcessingService::CreateDeferredPhotoProcessingSession create session, userId: %{public}d",
+        userId);
     TaskManager* taskManager = GetPhotoTaskManager(userId);
     std::shared_ptr<IImageProcessCallbacks> sessionImageProcCallbacks = sessionManager_->GetImageProcCallbacks();
     auto processor = schedulerManager_->GetPhotoProcessor(userId, taskManager, sessionImageProcCallbacks);
@@ -87,7 +88,7 @@ sptr<IDeferredPhotoProcessingSession> DeferredProcessingService::CreateDeferredP
 
 TaskManager* DeferredProcessingService::GetPhotoTaskManager(int userId)
 {
-    DP_INFO_LOG("entered, userId: %d", userId);
+    DP_INFO_LOG("entered, userId: %{public}d", userId);
     if (photoTaskManagerMap_.count(userId) == 0) {
         constexpr uint32_t numThreads = 1;
         std::shared_ptr<TaskManager> taskManager =
@@ -102,7 +103,7 @@ TaskManager* DeferredProcessingService::GetPhotoTaskManager(int userId)
 void DeferredProcessingService::NotifyCameraSessionStatus(int userId, const std::string& cameraId,
     bool running, bool isSystemCamera)
 {
-    DP_INFO_LOG("entered, userId: %d, cameraId: %s, running: %d, isSystemCamera: %d: ",
+    DP_INFO_LOG("entered, userId: %{public}d, cameraId: %s, running: %{public}d, isSystemCamera: %{public}d: ",
         userId, cameraId.c_str(), running, isSystemCamera);
     EventsMonitor::GetInstance().NotifyCameraSessionStatus(userId, cameraId, running, isSystemCamera);
 }
diff --git a/services/deferred_processing_service/src/event_monitor/events_monitor.cpp b/services/deferred_processing_service/src/event_monitor/events_monitor.cpp
index 0d872a33998a170caec2e3ecc5b06a30d296e833..fe2f69b183d624eb8460fac342335e9705b1307c 100644
--- a/services/deferred_processing_service/src/event_monitor/events_monitor.cpp
+++ b/services/deferred_processing_service/src/event_monitor/events_monitor.cpp
@@ -142,7 +142,7 @@ void EventsMonitor::UnRegisterListener(int userId, TaskManager *taskManager)
 void EventsMonitor::NotifyThermalLevel(int level)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_INFO_LOG("notify : %d.", level);
+    DP_INFO_LOG("notify : %{public}d.", level);
     if (!initialized_) {
         DP_INFO_LOG("uninitialized events monitor!");
         return;
@@ -155,7 +155,7 @@ void EventsMonitor::NotifyThermalLevel(int level)
 void EventsMonitor::NotifyCameraSessionStatus(int userId,
     const std::string &cameraId, bool running, bool isSystemCamera)
 {
-    DP_INFO_LOG("entered, userId: %d, cameraId: %s, running: %d, isSystemCamera: %d: ",
+    DP_INFO_LOG("entered, userId: %{public}d, cameraId: %s, running: %{public}d, isSystemCamera: %{public}d: ",
         userId, cameraId.c_str(), running, isSystemCamera);
     std::lock_guard<std::mutex> lock(mutex_);
     if (!initialized_) {
@@ -163,7 +163,7 @@ void EventsMonitor::NotifyCameraSessionStatus(int userId,
     }
     CameraSessionStatus cameraSessionStatus;
     running ? numActiveSessions_++ : numActiveSessions_--;
-    DP_INFO_LOG("numActiveSessions_: %d", static_cast<int>(numActiveSessions_.load()));
+    DP_INFO_LOG("numActiveSessions_: %{public}d", static_cast<int>(numActiveSessions_.load()));
     bool currSessionRunning = running;
     if (currSessionRunning) {
         cameraSessionStatus = isSystemCamera ?
@@ -181,7 +181,7 @@ void EventsMonitor::NotifyCameraSessionStatus(int userId,
 void EventsMonitor::NotifyMediaLibraryStatus(bool available)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_INFO_LOG("mediaLibrary available: %d.", available);
+    DP_INFO_LOG("mediaLibrary available: %{public}d.", available);
     if (!initialized_) {
         DP_INFO_LOG("uninitialized events monitor!");
         return;
@@ -193,7 +193,7 @@ void EventsMonitor::NotifyMediaLibraryStatus(bool available)
 
 void EventsMonitor::NotifyImageEnhanceStatus(int32_t status)
 {
-    DP_INFO_LOG("entered: %d.", status);
+    DP_INFO_LOG("entered: %{public}d.", status);
     std::lock_guard<std::mutex> lock(mutex_);
     if (!initialized_) {
         DP_INFO_LOG("uninitialized events monitor!");
@@ -207,7 +207,7 @@ void EventsMonitor::NotifyImageEnhanceStatus(int32_t status)
 
 void EventsMonitor::NotifySystemPressureLevel(SystemPressureLevel level)
 {
-    DP_INFO_LOG("entered: %d.", level);
+    DP_INFO_LOG("entered: %{public}d.", level);
     std::lock_guard<std::mutex> lock(mutex_);
     if (!initialized_) {
         DP_INFO_LOG("uninitialized events monitor!");
@@ -262,7 +262,7 @@ void EventsMonitor::ScheduleRegisterThermalListener()
     uint32_t callbackHandle;
     constexpr uint32_t delayMilli = 10 * 1000;
     GetGlobalWatchdog().StartMonitor(callbackHandle, delayMilli, [this](uint32_t handle) {
-        DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog executed, handle: %d", static_cast<int>(handle));
+        DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog executed, handle: %{public}d", static_cast<int>(handle));
         this->RegisterThermalLevel();
     });
 }
@@ -337,7 +337,7 @@ void ThermalLevelSubscriber::OnReceiveEvent(const OHOS::EventFwk::CommonEventDat
         static const std::string THERMAL_EVENT_ID = "0";
         int level = data.GetWant().GetIntParam(THERMAL_EVENT_ID, 0);
         DPSEventReport::GetInstance().SetTemperatureLevel(level);
-        DP_INFO_LOG("OnThermalLevelChanged level:%d", static_cast<int>(level));
+        DP_INFO_LOG("OnThermalLevelChanged level:%{public}d", static_cast<int>(level));
         EventsMonitor::GetInstance().NotifySystemPressureLevel(MapEventLevel(level));
         DP_INFO_LOG("ThermalLevelSubscriber SetThermalLevel: %{public}d.", level);
     }
diff --git a/services/deferred_processing_service/src/post_processor/photo_post_processor.cpp b/services/deferred_processing_service/src/post_processor/photo_post_processor.cpp
index 87364ad57c39298bbd3582a3257f91997fb3ee69..30bdf6f85d8048b635b57d0cb748897bc47ef92f 100644
--- a/services/deferred_processing_service/src/post_processor/photo_post_processor.cpp
+++ b/services/deferred_processing_service/src/post_processor/photo_post_processor.cpp
@@ -56,7 +56,7 @@ DpsError MapHdiError(OHOS::HDI::Camera::V1_2::ErrorCode errorCode)
             code = DpsError::DPS_ERROR_IMAGE_PROC_INTERRUPTED;
             break;
         default:
-            DP_ERR_LOG("unexpected error code: %d.", errorCode);
+            DP_ERR_LOG("unexpected error code: %{public}d.", errorCode);
             break;
     }
     return code;
@@ -82,7 +82,7 @@ HdiStatus MapHdiStatus(OHOS::HDI::Camera::V1_2::SessionStatus statusCode)
             code = HdiStatus::HDI_NOT_READY_PREEMPTED;
             break;
         default:
-            DP_ERR_LOG("unexpected error code: %d.", statusCode);
+            DP_ERR_LOG("unexpected error code: %{public}d.", statusCode);
             break;
     }
     return code;
@@ -102,7 +102,7 @@ OHOS::HDI::Camera::V1_2::ExecutionMode MapToHdiExecutionMode(ExecutionMode execu
             mode = OHOS::HDI::Camera::V1_2::ExecutionMode::LOW_POWER;
             break;
         default:
-            DP_ERR_LOG("unexpected error code: %d.", executionMode);
+            DP_ERR_LOG("unexpected error code: %{public}d.", executionMode);
             break;
     }
     return mode;
@@ -137,9 +137,9 @@ int32_t PhotoPostProcessor::PhotoProcessListener::OnProcessDone(const std::strin
     DP_INFO_LOG("entered");
     auto bufferHandle = buffer.imageHandle->GetBufferHandle();
     int hdiFd = bufferHandle->fd;
-    DP_DEBUG_LOG("entered, hdiFd: %d", hdiFd);
+    DP_DEBUG_LOG("entered, hdiFd: %{public}d", hdiFd);
     int fd = dup(hdiFd);
-    DP_DEBUG_LOG("entered, dup fd: %d", fd);
+    DP_DEBUG_LOG("entered, dup fd: %{public}d", fd);
     close(hdiFd);
     int size = bufferHandle->size;
     int32_t isDegradedImage = 0;
@@ -147,11 +147,11 @@ int32_t PhotoPostProcessor::PhotoProcessListener::OnProcessDone(const std::strin
     if (buffer.metadata) {
         int32_t retImageQuality = buffer.metadata->Get("isDegradedImage", isDegradedImage);
         int32_t retDataSize = buffer.metadata->Get("dataSize", dataSize);
-        DP_INFO_LOG("retImageQuality: %d, retDataSize: %d", static_cast<int>(retImageQuality),
+        DP_INFO_LOG("retImageQuality: %{public}d, retDataSize: %{public}d", static_cast<int>(retImageQuality),
             static_cast<int>(retDataSize));
     }
-    DP_INFO_LOG("bufferHandle param, size: %d, dataSize: %d, isDegradedImage: %d", size, static_cast<int>(dataSize),
-        isDegradedImage);
+    DP_INFO_LOG("bufferHandle param, size: %{public}d, dataSize: %{public}d, isDegradedImage: %{public}d",
+        size, static_cast<int>(dataSize), isDegradedImage);
     sptr<IPCFileDescriptor> ipcFileDescriptor = sptr<IPCFileDescriptor>::MakeSptr(fd);
     std::shared_ptr<BufferInfo> bufferInfo = std::make_shared<BufferInfo>(ipcFileDescriptor, dataSize,
         isDegradedImage == 0);
@@ -253,9 +253,9 @@ int PhotoPostProcessor::GetConcurrency(ExecutionMode mode)
     int count = 1;
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->GetCoucurrency(OHOS::HDI::Camera::V1_2::ExecutionMode::BALANCED, count);
-        DP_INFO_LOG("getConcurrency, ret: %d", ret);
+        DP_INFO_LOG("getConcurrency, ret: %{public}d", ret);
     }
-    DP_INFO_LOG("entered, count: %d", count);
+    DP_INFO_LOG("entered, count: %{public}d", count);
     return count;
 }
 
@@ -265,7 +265,7 @@ bool PhotoPostProcessor::GetPendingImages(std::vector<std::string>& pendingImage
     DP_INFO_LOG("entered");
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->GetPendingImages(pendingImages);
-        DP_INFO_LOG("getPendingImages, ret: %d", ret);
+        DP_INFO_LOG("getPendingImages, ret: %{public}d", ret);
         if (ret == 0) {
         return true;
         }
@@ -276,10 +276,10 @@ bool PhotoPostProcessor::GetPendingImages(std::vector<std::string>& pendingImage
 void PhotoPostProcessor::SetExecutionMode(ExecutionMode executionMode)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    DP_INFO_LOG("entered, executionMode: %d", executionMode);
+    DP_INFO_LOG("entered, executionMode: %{public}d", executionMode);
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->SetExecutionMode(MapToHdiExecutionMode(executionMode));
-        DP_INFO_LOG("setExecutionMode, ret: %d", ret);
+        DP_INFO_LOG("setExecutionMode, ret: %{public}d", ret);
     }
 }
 
@@ -293,16 +293,16 @@ void PhotoPostProcessor::ProcessImage(std::string imageId)
     }
     std::lock_guard<std::mutex> lock(mutex_);
     int32_t ret = imageProcessSession_->ProcessImage(imageId);
-    DP_INFO_LOG("processImage, ret: %d", ret);
+    DP_INFO_LOG("processImage, ret: %{public}d", ret);
     uint32_t callbackHandle;
     int userId = userId_;
     constexpr uint32_t maxProcessingTimeMs = 11 * 1000;
     GetGlobalWatchdog().StartMonitor(callbackHandle, maxProcessingTimeMs, [this, &userId, imageId](uint32_t handle) {
-        DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog executed, userId: %d, handle: %d",
+        DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog executed, userId: %{public}d, handle: %{public}d",
             userId, static_cast<int>(handle));
         OnError(imageId, DpsError::DPS_ERROR_IMAGE_PROC_TIMEOUT);
     });
-    DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog registered, userId: %d, handle: %d",
+    DP_INFO_LOG("PhotoPostProcessor-ProcessImage-Watchdog registered, userId: %{public}d, handle: %{public}d",
         userId, static_cast<int>(callbackHandle));
     imageId2Handle_.emplace(imageId, callbackHandle);
 }
@@ -313,7 +313,7 @@ void PhotoPostProcessor::RemoveImage(std::string imageId)
     DP_INFO_LOG("entered, imageId: %s", imageId.c_str());
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->RemoveImage(imageId);
-        DP_INFO_LOG("removeImage, imageId: %s, ret: %d", imageId.c_str(), ret);
+        DP_INFO_LOG("removeImage, imageId: %s, ret: %{public}d", imageId.c_str(), ret);
         DPSEventReport::GetInstance().UpdateRemoveTime(imageId, userId_);
     }
 }
@@ -324,7 +324,7 @@ void PhotoPostProcessor::Interrupt()
     DP_INFO_LOG("entered");
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->Interrupt();
-        DP_INFO_LOG("interrupt, ret: %d", ret);
+        DP_INFO_LOG("interrupt, ret: %{public}d", ret);
     }
 }
 
@@ -334,7 +334,7 @@ void PhotoPostProcessor::Reset()
     DP_INFO_LOG("entered");
     if (imageProcessSession_) {
         int32_t ret = imageProcessSession_->Reset();
-        DP_INFO_LOG("reset, ret: %d", ret);
+        DP_INFO_LOG("reset, ret: %{public}d", ret);
     }
 }
 
@@ -380,7 +380,7 @@ void PhotoPostProcessor::OnError(const std::string& imageId, DpsError errorCode)
 
 void PhotoPostProcessor::OnStateChanged(HdiStatus hdiStatus)
 {
-    DP_INFO_LOG("entered, HdiStatus: %d", hdiStatus);
+    DP_INFO_LOG("entered, HdiStatus: %{public}d", hdiStatus);
     EventsMonitor::GetInstance().NotifyImageEnhanceStatus(hdiStatus);
 }
 
@@ -446,10 +446,10 @@ void PhotoPostProcessor::ScheduleConnectService()
         constexpr uint32_t delayMilli = 10 * 1000;
         uint32_t callbackHandle;
         GetGlobalWatchdog().StartMonitor(callbackHandle, delayMilli, [this](uint32_t handle) {
-            DP_INFO_LOG("PhotoPostProcessor Watchdog executed, handle: %d", static_cast<int>(handle));
+            DP_INFO_LOG("PhotoPostProcessor Watchdog executed, handle: %{public}d", static_cast<int>(handle));
             ConnectServiceIfNecessary();
         });
-        DP_INFO_LOG("PhotoPostProcessor Watchdog registered, handle: %d", static_cast<int>(callbackHandle));
+        DP_INFO_LOG("PhotoPostProcessor Watchdog registered, handle: %{public}d", static_cast<int>(callbackHandle));
     } else {
         DP_INFO_LOG("already connected.");
     }
diff --git a/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_controller.cpp b/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_controller.cpp
index 07eec5f5bb80ee31f9d8da21f9a217f914539b59..db57012ab117d32cd5a303272eab0b4d49d41cc1 100644
--- a/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_controller.cpp
+++ b/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_controller.cpp
@@ -43,7 +43,7 @@ public:
 
     void OnEventChange(EventType event, int value) override
     {
-        DP_INFO_LOG("entered, event: %d", event);
+        DP_INFO_LOG("entered, event: %{public}d", event);
         switch (event) {
             case EventType::CAMERA_SESSION_STATUS_EVENT:
                 controller_->NotifyCameraStatusChanged(static_cast<CameraSessionStatus>(value));
@@ -102,7 +102,7 @@ DeferredPhotoController::DeferredPhotoController(int userId, std::shared_ptr<Pho
       eventsListener_(nullptr),
       photoJobRepositoryListener_(nullptr)
 {
-    DP_DEBUG_LOG("entered, userid: %d", userId_);
+    DP_DEBUG_LOG("entered, userid: %{public}d", userId_);
     //创建策略
     userInitiatedStrategy_ = std::make_unique<UserInitiatedStrategy>(repository);
     backgroundStrategy_ = std::make_unique<BackgroundStrategy>(repository);
@@ -118,7 +118,7 @@ DeferredPhotoController::DeferredPhotoController(int userId, std::shared_ptr<Pho
 
 DeferredPhotoController::~DeferredPhotoController()
 {
-    DP_DEBUG_LOG("entered, userid: %d", userId_);
+    DP_DEBUG_LOG("entered, userid: %{public}d", userId_);
     photoProcessor_ = nullptr;
     photoJobRepository_ = nullptr;
     userInitiatedStrategy_ = nullptr;
@@ -128,7 +128,7 @@ DeferredPhotoController::~DeferredPhotoController()
 
 void DeferredPhotoController::Initialize()
 {
-    DP_DEBUG_LOG("entered, userid: %d", userId_);
+    DP_DEBUG_LOG("entered, userid: %{public}d", userId_);
 }
 
 void DeferredPhotoController::TryDoSchedule()
@@ -136,15 +136,15 @@ void DeferredPhotoController::TryDoSchedule()
     DP_INFO_LOG("entered");
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     auto work = userInitiatedStrategy_->GetWork();
-    DP_INFO_LOG("userInitiatedStrategy_ get work: %d", work != nullptr);
+    DP_INFO_LOG("userInitiatedStrategy_ get work: %{public}d", work != nullptr);
     if (work != nullptr) {
         StopWaitForUser();
     }
     if (work == nullptr && !isWaitForUser_) {
         work = backgroundStrategy_->GetWork();
-        DP_INFO_LOG("backgroundStrategy_ get work: %d", work != nullptr);
+        DP_INFO_LOG("backgroundStrategy_ get work: %{public}d", work != nullptr);
     }
-    DP_INFO_LOG("all strategy get work: %d", work != nullptr);
+    DP_INFO_LOG("all strategy get work: %{public}d", work != nullptr);
     NotifyScheduleState(work != nullptr);
     if (work == nullptr) {
         return;
@@ -199,7 +199,7 @@ void DeferredPhotoController::NotifyCameraStatusChanged(CameraSessionStatus stat
 //来自任务仓库的事件
 void DeferredPhotoController::OnPhotoJobChanged(bool priorityChanged, bool statusChanged, DeferredPhotoJobPtr jobPtr)
 {
-    DP_INFO_LOG("entered, priorityChanged: %d, statusChanged: %d , imageId: %s",
+    DP_INFO_LOG("entered, priorityChanged: %{public}d, statusChanged: %{public}d , imageId: %s",
         priorityChanged, statusChanged, jobPtr->GetImageId().c_str());
     if (priorityChanged && statusChanged) {
         if (jobPtr->GetPrePriority() == PhotoJobPriority::HIGH && jobPtr->GetPreStatus() == PhotoJobStatus::RUNNING) {
@@ -216,11 +216,12 @@ void DeferredPhotoController::StartWaitForUser()
     isWaitForUser_ = true;
     GetGlobalWatchdog().StartMonitor(callbackHandle_, DURATIONMS_500, [this](uint32_t handle) {
         isWaitForUser_ = false;
-        DP_INFO_LOG("DeferredPhotoController, wait for user ended, handle: %d, try do schedule",
+        DP_INFO_LOG("DeferredPhotoController, wait for user ended, handle: %{public}d, try do schedule",
             static_cast<int>(handle));
         TryDoSchedule();
     });
-    DP_INFO_LOG("DeferredPhotoController, wait for user started, handle: %d", static_cast<int>(callbackHandle_));
+    DP_INFO_LOG("DeferredPhotoController, wait for user started, handle: %{public}d",
+        static_cast<int>(callbackHandle_));
 }
 
 void DeferredPhotoController::StopWaitForUser()
@@ -232,7 +233,7 @@ void DeferredPhotoController::StopWaitForUser()
 
 void DeferredPhotoController::NotifyScheduleState(bool workAvailable)
 {
-    DP_INFO_LOG("entered, workAvailable: %d", workAvailable);
+    DP_INFO_LOG("entered, workAvailable: %{public}d", workAvailable);
     DpsStatus scheduleState = DpsStatus::DPS_SESSION_STATE_IDLE;
     if (workAvailable || photoJobRepository_->GetRunningJobCounts() > 0) {
         scheduleState =  DpsStatus::DPS_SESSION_STATE_RUNNING;
@@ -247,7 +248,7 @@ void DeferredPhotoController::NotifyScheduleState(bool workAvailable)
             }
         }
     }
-    DP_INFO_LOG("entered, scheduleState_: %d, scheduleState: %d", scheduleState_, scheduleState);
+    DP_INFO_LOG("entered, scheduleState_: %{public}d, scheduleState: %{public}d", scheduleState_, scheduleState);
     if (scheduleState != scheduleState_) {
         scheduleState_ = scheduleState;
         photoProcessor_->NotifyScheduleState(scheduleState_);
diff --git a/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_processor.cpp b/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_processor.cpp
index 5dd3c21bf2099d556cf7ce037cfc2fc1fa23f5b8..9c3a0350615b4b315d8bbd1e381cc6c83423de78 100644
--- a/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_processor.cpp
+++ b/services/deferred_processing_service/src/schedule/photo_processor/deferred_photo_processor.cpp
@@ -81,6 +81,10 @@ void DeferredPhotoProcessor::RestoreImage(const std::string& imageId)
 void DeferredPhotoProcessor::ProcessImage(const std::string& appName, const std::string& imageId)
 {
     DP_INFO_LOG("entered");
+    if (!repository_->IsOfflineJob(imageId)) {
+        DP_INFO_LOG("imageId is not offlineJob %{public}s", imageId.c_str());
+        return;
+    }
     requestedImages_.insert(imageId);
     bool isImageIdValid = repository_->RequestJob(imageId);
     if (!isImageIdValid) {
@@ -211,7 +215,7 @@ bool DeferredPhotoProcessor::GetPendingImages(std::vector<std::string>& pendingI
 
 bool DeferredPhotoProcessor::IsFatalError(DpsError errorCode)
 {
-    DP_INFO_LOG("entered, code: %d", errorCode);
+    DP_INFO_LOG("entered, code: %{public}d", errorCode);
     if (errorCode == DpsError::DPS_ERROR_IMAGE_PROC_FAILED ||
         errorCode == DpsError::DPS_ERROR_IMAGE_PROC_INVALID_PHOTO_ID) {
         return true;
diff --git a/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/deferred_photo_job.cpp b/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/deferred_photo_job.cpp
index fb24a6a2a8f5005b25b6507d538de47e791dcf1f..aaa7ca1d4efe1897dfa4da70914aff0f5256b41a 100644
--- a/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/deferred_photo_job.cpp
+++ b/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/deferred_photo_job.cpp
@@ -64,35 +64,35 @@ DeferredPhotoJob::~DeferredPhotoJob()
 
 PhotoJobPriority DeferredPhotoJob::GetCurPriority()
 {
-    DP_INFO_LOG("imageId: %s, current priority: %d, previous priority: %d",
+    DP_INFO_LOG("imageId: %s, current priority: %{public}d, previous priority: %{public}d",
         imageId_.c_str(), curPriority_, prePriority_);
     return curPriority_;
 }
 
 PhotoJobPriority DeferredPhotoJob::GetPrePriority()
 {
-    DP_INFO_LOG("imageId: %s, current priority: %d, previous priority: %d",
+    DP_INFO_LOG("imageId: %s, current priority: %{public}d, previous priority: %{public}d",
         imageId_.c_str(), curPriority_, prePriority_);
     return prePriority_;
 }
 
 PhotoJobPriority DeferredPhotoJob::GetRunningPriority()
 {
-    DP_INFO_LOG("imageId: %s, current priority: %d, previous priority: %d, running priority: %d",
-        imageId_.c_str(), curPriority_, prePriority_, runningPriority_);
+    DP_INFO_LOG("imageId: %s, current priority: %{public}d, previous priority: %{public}d,"
+        "running priority: %{public}d", imageId_.c_str(), curPriority_, prePriority_, runningPriority_);
     return runningPriority_;
 }
 
 PhotoJobStatus DeferredPhotoJob::GetCurStatus()
 {
-    DP_INFO_LOG("imageId: %s, current status: %d, previous status: %d",
+    DP_INFO_LOG("imageId: %s, current status: %{public}d, previous status: %{public}d",
         imageId_.c_str(), curStatus_, preStatus_);
     return curStatus_;
 }
 
 PhotoJobStatus DeferredPhotoJob::GetPreStatus()
 {
-    DP_INFO_LOG("imageId: %s, current status: %d, previous status: %d",
+    DP_INFO_LOG("imageId: %s, current status: %{public}d, previous status: %{public}d",
         imageId_.c_str(), curStatus_, preStatus_);
     return preStatus_;
 }
@@ -107,7 +107,7 @@ int DeferredPhotoJob::GetDeferredProcType()
 {
     int type;
     metadata_.Get(DEFERRED_PROCESSING_TYPE_KEY, type);
-    DP_INFO_LOG("imageId: %s, deferred proc type: %d", imageId_.c_str(), type);
+    DP_INFO_LOG("imageId: %s, deferred proc type: %{public}d", imageId_.c_str(), type);
     return type;
 }
 
@@ -128,7 +128,7 @@ int DeferredPhotoJob::GetPhotoJobType()
 
 bool DeferredPhotoJob::SetJobStatus(PhotoJobStatus status)
 {
-    DP_INFO_LOG("imageId: %s, current status: %d, previous status: %d, status to set: %d",
+    DP_INFO_LOG("imageId: %s, current status: %{public}d, previous status: %{public}d, status to set: %{public}d",
         imageId_.c_str(), curStatus_, preStatus_, status);
     if (curStatus_ == status) {
         return false;
@@ -141,7 +141,7 @@ bool DeferredPhotoJob::SetJobStatus(PhotoJobStatus status)
 
 bool DeferredPhotoJob::SetJobPriority(PhotoJobPriority priority)
 {
-    DP_INFO_LOG("imageId: %s, current priority: %d, previous priority: %d, priority to set: %d",
+    DP_INFO_LOG("imageId: %s, current priority: %{public}d, previous priority: %{public}d, priority to set: %{public}d",
         imageId_.c_str(), curPriority_, prePriority_, priority);
     if (curPriority_ == priority) {
         return false;
@@ -154,8 +154,8 @@ bool DeferredPhotoJob::SetJobPriority(PhotoJobPriority priority)
 
 void DeferredPhotoJob::RecordJobRunningPriority()
 {
-    DP_INFO_LOG("imageId: %s, priority recorded: %d, current priority: %d, previous priority: %d",
-        imageId_.c_str(), curPriority_, prePriority_, curPriority_);
+    DP_INFO_LOG("imageId: %s, priority recorded: %{public}d, current priority: %{public}d,"
+        "previous priority: %{public}d", imageId_.c_str(), curPriority_, prePriority_, curPriority_);
     runningPriority_ = curPriority_;
     return;
 }
diff --git a/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/photo_job_repository.cpp b/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/photo_job_repository.cpp
index 7e9a64778785675594a368cae5cef3fc901daacb..67d7dff76ed75e2a7a328e12b2cf74b8ff218047 100644
--- a/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/photo_job_repository.cpp
+++ b/services/deferred_processing_service/src/schedule/photo_processor/photo_job_repository/photo_job_repository.cpp
@@ -32,12 +32,12 @@ PhotoJobRepository::PhotoJobRepository(int userId)
       jobQueue_(),
       jobListeners_()
 {
-    DP_DEBUG_LOG("entered, userid: %d", userId_);
+    DP_DEBUG_LOG("entered, userid: %{public}d", userId_);
 }
 
 PhotoJobRepository::~PhotoJobRepository()
 {
-    DP_DEBUG_LOG("entered, userid: %d", userId_);
+    DP_DEBUG_LOG("entered, userid: %{public}d", userId_);
     offlineJobMap_.clear();
     backgroundJobMap_.clear();
     offlineJobList_.clear();
@@ -76,7 +76,7 @@ void PhotoJobRepository::AddDeferredJob(const std::string& imageId, bool discard
 
 void PhotoJobRepository::RemoveDeferredJob(const std::string& imageId, bool restorable)
 {
-    DP_INFO_LOG("entered, imageId: %s, restorable: %d", imageId.c_str(), restorable);
+    DP_INFO_LOG("entered, imageId: %s, restorable: %{public}d", imageId.c_str(), restorable);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     DeferredPhotoJobPtr jobPtr = GetJobUnLocked(imageId);
     if (jobPtr == nullptr) {
@@ -123,9 +123,6 @@ bool PhotoJobRepository::RequestJob(const std::string& imageId)
         DP_INFO_LOG("does not existed, imageId: %s: ", imageId.c_str());
         return false;
     }
-    if (jobPtr->GetDeferredProcType() == DeferredProcessingType::DPS_BACKGROUND) {
-        return false;
-    }
     bool priorityChanged = false;
     bool statusChanged = false;
 
@@ -269,7 +266,8 @@ PhotoJobStatus PhotoJobRepository::GetJobStatus(const std::string& imageId)
 
 DeferredPhotoJobPtr PhotoJobRepository::GetLowPriorityJob()
 {
-    DP_INFO_LOG("entered, job queue size: %d, offline job list size: %d, background job size: %d, running num: %d",
+    DP_INFO_LOG("entered, job queue size: %{public}d, offline job list size: %{public}d,"
+        "background job size: %{public}d, running num: %{public}d",
         static_cast<int>(jobQueue_.size()), static_cast<int>(offlineJobList_.size()),
         static_cast<int>(backgroundJobMap_.size()), runningNum_);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -289,7 +287,8 @@ DeferredPhotoJobPtr PhotoJobRepository::GetLowPriorityJob()
 
 DeferredPhotoJobPtr PhotoJobRepository::GetNormalPriorityJob()
 {
-    DP_INFO_LOG("entered, job queue size: %d, offline job list size: %d, background job size: %d, running num: %d",
+    DP_INFO_LOG("entered, job queue size: %{public}d, offline job list size: %{public}d,"
+        "background job size: %{public}d, running num: %{public}d",
         static_cast<int>(jobQueue_.size()), static_cast<int>(offlineJobList_.size()),
         static_cast<int>(backgroundJobMap_.size()), runningNum_);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -316,7 +315,8 @@ DeferredPhotoJobPtr PhotoJobRepository::GetNormalPriorityJob()
 
 DeferredPhotoJobPtr PhotoJobRepository::GetHighPriorityJob()
 {
-    DP_INFO_LOG("entered, job queue size: %d, offline job list size: %d, background job size: %d, running num: %d",
+    DP_INFO_LOG("entered, job queue size: %{public}d, offline job list size: %{public}d,"
+        "background job size: %{public}d, running num: %{public}d",
         static_cast<int>(jobQueue_.size()), static_cast<int>(offlineJobList_.size()),
         static_cast<int>(backgroundJobMap_.size()), runningNum_);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -329,7 +329,7 @@ DeferredPhotoJobPtr PhotoJobRepository::GetHighPriorityJob()
 int PhotoJobRepository::GetRunningJobCounts()
 {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    DP_DEBUG_LOG("running jobs num: %d", runningNum_);
+    DP_DEBUG_LOG("running jobs num: %{public}d", runningNum_);
     return runningNum_;
 }
 
@@ -361,7 +361,7 @@ PhotoJobPriority PhotoJobRepository::GetJobRunningPriority(std::string imageId)
 
 void PhotoJobRepository::NotifyJobChangedUnLocked(bool priorityChanged, bool statusChanged, DeferredPhotoJobPtr jobPtr)
 {
-    DP_INFO_LOG("entered, priorityChanged: %d, statusChanged: %d, imageId: %s: ",
+    DP_INFO_LOG("entered, priorityChanged: %{public}d, statusChanged: %{public}d, imageId: %s: ",
         priorityChanged, statusChanged, jobPtr->GetImageId().c_str());
     for (auto& listenerWptr : jobListeners_) {
         if (auto listenerSptr = listenerWptr.lock()) {
@@ -388,7 +388,7 @@ void PhotoJobRepository::UpdateRunningCountUnLocked(bool statusChanged, Deferred
     if (statusChanged && (jobPtr->GetCurStatus() == PhotoJobStatus::RUNNING)) {
         runningNum_ = runningNum_ + 1;
     }
-    DP_INFO_LOG("running jobs num: %d, imageId: %s", runningNum_, jobPtr->GetImageId().c_str());
+    DP_INFO_LOG("running jobs num: %{public}d, imageId: %s", runningNum_, jobPtr->GetImageId().c_str());
     return;
 }
 
@@ -438,7 +438,7 @@ int PhotoJobRepository::GetBackgroundJobSize()
 {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     int size = static_cast<int>(backgroundJobMap_.size());
-    DP_DEBUG_LOG("background job size: %d", size);
+    DP_DEBUG_LOG("background job size: %{public}d", size);
     return size;
 }
 
@@ -446,7 +446,7 @@ int PhotoJobRepository::GetOfflineJobSize()
 {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     int size = static_cast<int>(offlineJobMap_.size());
-    DP_DEBUG_LOG("offline job size: %d", size);
+    DP_DEBUG_LOG("offline job size: %{public}d", size);
     return size;
 }
 
diff --git a/services/deferred_processing_service/src/schedule/photo_processor/strategy/background_strategy.cpp b/services/deferred_processing_service/src/schedule/photo_processor/strategy/background_strategy.cpp
index d160c273185d2e0778f06e2dfd53af147114d5e2..4822630164f6ec3364cac1721718c9a9c18ac2e9 100644
--- a/services/deferred_processing_service/src/schedule/photo_processor/strategy/background_strategy.cpp
+++ b/services/deferred_processing_service/src/schedule/photo_processor/strategy/background_strategy.cpp
@@ -76,16 +76,16 @@ ExecutionMode BackgroundStrategy::GetExecutionMode()
         || cameraSessionStatus_ == CameraSessionStatus::NORMAL_CAMERA_OPEN
         || !(hdiStatus_ == HdiStatus::HDI_READY || hdiStatus_ == HdiStatus::HDI_READY_SPACE_LIMIT_REACHED)
         || mediaLibraryStatus_ != MediaLibraryStatus::MEDIA_LIBRARY_AVAILABLE) {
-        DP_INFO_LOG("cameraSessionStatus_: %d, hdiStatus_: %d, mediaLibraryStatus_: %d, ",
+        DP_INFO_LOG("cameraSessionStatus_: %{public}d, hdiStatus_: %{public}d, mediaLibraryStatus_: %{public}d, ",
             cameraSessionStatus_, hdiStatus_, mediaLibraryStatus_);
         return ExecutionMode::DUMMY;
     }
     FlashTrailingState();
-    DP_INFO_LOG("isInTrailing_: %d", isInTrailing_);
+    DP_INFO_LOG("isInTrailing_: %{public}d", isInTrailing_);
     if (isInTrailing_) {
         return ExecutionMode::LOAD_BALANCE;
     }
-    DP_INFO_LOG("systemPressureLevel_: %d", systemPressureLevel_);
+    DP_INFO_LOG("systemPressureLevel_: %{public}d", systemPressureLevel_);
     if (systemPressureLevel_ == SystemPressureLevel::NOMINAL) {
         return ExecutionMode::LOAD_BALANCE;
     }
@@ -94,34 +94,34 @@ ExecutionMode BackgroundStrategy::GetExecutionMode()
 
 HdiStatus BackgroundStrategy::GetHdiStatus()
 {
-    DP_INFO_LOG("hdiStatus_: %d", hdiStatus_);
+    DP_INFO_LOG("hdiStatus_: %{public}d", hdiStatus_);
     return hdiStatus_;
 }
 
 void BackgroundStrategy::NotifyPressureLevelChanged(SystemPressureLevel level)
 {
-    DP_INFO_LOG("previous system pressure level: %d, new level: %d", systemPressureLevel_, level);
+    DP_INFO_LOG("previous system pressure level: %{public}d, new level: %{public}d", systemPressureLevel_, level);
     systemPressureLevel_ = level;
     return;
 }
 
 void BackgroundStrategy::NotifyHdiStatusChanged(HdiStatus status)
 {
-    DP_INFO_LOG("previous hdi status %d, new status: %d", hdiStatus_, status);
+    DP_INFO_LOG("previous hdi status %{public}d, new status: %{public}d", hdiStatus_, status);
     hdiStatus_ = status;
     return;
 }
 
 void BackgroundStrategy::NotifyMediaLibStatusChanged(MediaLibraryStatus status)
 {
-    DP_INFO_LOG("previous media lib status %d, new status: %d", mediaLibraryStatus_, status);
+    DP_INFO_LOG("previous media lib status %{public}d, new status: %{public}d", mediaLibraryStatus_, status);
     mediaLibraryStatus_ = status;
     return;
 }
 
 void BackgroundStrategy::NotifyCameraStatusChanged(CameraSessionStatus status)
 {
-    DP_INFO_LOG("previous camera session status %d, new status: %d", cameraSessionStatus_, status);
+    DP_INFO_LOG("previous camera session status %{public}d, new status: %{public}d", cameraSessionStatus_, status);
     cameraSessionStatus_ = status;
     switch (status) {
         case CameraSessionStatus::SYSTEM_CAMERA_CLOSED:
@@ -142,7 +142,7 @@ void BackgroundStrategy::NotifyCameraStatusChanged(CameraSessionStatus status)
 
 void BackgroundStrategy::StartTrailing(uint64_t duration)
 {
-    DP_INFO_LOG("entered, is in trailing: %d", isInTrailing_);
+    DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
     if (duration <= 0) {
         return;
     }
@@ -162,7 +162,7 @@ void BackgroundStrategy::StartTrailing(uint64_t duration)
 
 void BackgroundStrategy::StopTrailing()
 {
-    DP_INFO_LOG("entered, is in trailing: %d", isInTrailing_);
+    DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
     if (isInTrailing_) {
         auto passedTime = SteadyClock::GetTimestampMilli() - trailingStartTimeStamp_;
         if (passedTime >= remainingTrailingTime_) {
@@ -177,7 +177,7 @@ void BackgroundStrategy::StopTrailing()
 
 void BackgroundStrategy::FlashTrailingState()
 {
-    DP_INFO_LOG("entered, is in trailing: %d", isInTrailing_);
+    DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
     if (isInTrailing_) {
         auto passedTime = SteadyClock::GetTimestampMilli() - trailingStartTimeStamp_;
         if (passedTime >= remainingTrailingTime_) {
diff --git a/services/deferred_processing_service/src/session/session_coordinator.cpp b/services/deferred_processing_service/src/session/session_coordinator.cpp
index 6bb165a46aacfedaceca6394d200c82644433543..083bc58b31f010fabbed33f59ceba1853479f8d9 100644
--- a/services/deferred_processing_service/src/session/session_coordinator.cpp
+++ b/services/deferred_processing_service/src/session/session_coordinator.cpp
@@ -51,7 +51,7 @@ ErrorCode MapDpsErrorCode(DpsError errorCode)
             code = ErrorCode::ERROR_IMAGE_PROC_INTERRUPTED;
             break;
         default:
-            DP_WARNING_LOG("unexpected error code: %d.", errorCode);
+            DP_WARNING_LOG("unexpected error code: %{public}d.", errorCode);
             break;
     }
     return code;
@@ -74,7 +74,7 @@ StatusCode MapDpsStatus(DpsStatus statusCode)
             code = StatusCode::SESSION_STATE_SUSPENDED;
             break;
         default:
-            DP_WARNING_LOG("unexpected error code: %d.", statusCode);
+            DP_WARNING_LOG("unexpected error code: %{public}d.", statusCode);
             break;
     }
     return code;
@@ -174,10 +174,10 @@ void SessionCoordinator::OnError(int userId, const std::string& imageId, DpsErro
     if (iter != remoteImageCallbacksMap_.end()) {
         auto wpCallback = iter->second;
         sptr<IDeferredPhotoProcessingSessionCallback> spCallback = wpCallback.promote();
-        DP_INFO_LOG("entered, userId: %d", userId);
+        DP_INFO_LOG("entered, userId: %{public}d", userId);
         spCallback->OnError(imageId, MapDpsErrorCode(errorCode));
     } else {
-        DP_INFO_LOG("callback is null, cache request, imageId: %s, errorCode: %d.", imageId.c_str(), errorCode);
+        DP_INFO_LOG("callback is null, cache request, imageId: %s, errorCode: %{public}d.", imageId.c_str(), errorCode);
         pendingImageResults_.push_back({CallbackType::ON_ERROR, userId, imageId, nullptr, 0, errorCode});
     }
 }
@@ -188,10 +188,10 @@ void SessionCoordinator::OnStateChanged(int userId, DpsStatus statusCode)
     if (iter != remoteImageCallbacksMap_.end()) {
         auto wpCallback = iter->second;
         sptr<IDeferredPhotoProcessingSessionCallback> spCallback = wpCallback.promote();
-        DP_INFO_LOG("entered, userId: %d", userId);
+        DP_INFO_LOG("entered, userId: %{public}d", userId);
         spCallback->OnStateChanged(MapDpsStatus(statusCode));
     } else {
-        DP_INFO_LOG("cache request, statusCode: %d.", statusCode);
+        DP_INFO_LOG("cache request, statusCode: %{public}d.", statusCode);
         pendingImageResults_.push_back({CallbackType::ON_STATE_CHANGED, userId, "", nullptr, 0,
             DpsError::DPS_ERROR_IMAGE_PROC_ABNORMAL, statusCode});
     }
@@ -229,7 +229,7 @@ void SessionCoordinator::ProcessPendingResults(sptr<IDeferredPhotoProcessingSess
 void SessionCoordinator::NotifyCallbackDestroyed(int userId)
 {
     if (remoteImageCallbacksMap_.count(userId) != 0) {
-        DP_INFO_LOG("session userId: %d destroyed.", userId);
+        DP_INFO_LOG("session userId: %{public}d destroyed.", userId);
         remoteImageCallbacksMap_.erase(userId);
     }
 }
diff --git a/services/deferred_processing_service/src/session/session_info.cpp b/services/deferred_processing_service/src/session/session_info.cpp
index a4cdf4b157e2ba13242397db67e3ea43ceaabcad..83eb2e767981d77549051ee358b0fd06756c13ad 100644
--- a/services/deferred_processing_service/src/session/session_info.cpp
+++ b/services/deferred_processing_service/src/session/session_info.cpp
@@ -58,7 +58,7 @@ SessionInfo::SessionInfo(int userId, const sptr<IDeferredPhotoProcessingSessionC
       callback_(callback),
       sessionManager_(sessionManager)
 {
-    DP_DEBUG_LOG("userId: %d.", userId_);
+    DP_DEBUG_LOG("userId: %{public}d.", userId_);
     callbackDeathRecipient_ = sptr<CallbackDeathRecipient>::MakeSptr(this);
     SetCallback(callback);
 }
diff --git a/services/deferred_processing_service/src/session/session_manager.cpp b/services/deferred_processing_service/src/session/session_manager.cpp
index 119806fbfb1ed6718bcb243013ec7854842832a2..0e54b9db327eb0bbdce74444b00e6df4f01f6bf0 100644
--- a/services/deferred_processing_service/src/session/session_manager.cpp
+++ b/services/deferred_processing_service/src/session/session_manager.cpp
@@ -75,7 +75,7 @@ sptr<IDeferredPhotoProcessingSession> SessionManager::CreateDeferredPhotoProcess
     const sptr<IDeferredPhotoProcessingSessionCallback> callback, std::shared_ptr<DeferredPhotoProcessor> processor,
     TaskManager* taskManager)
 {
-    DP_INFO_LOG("SessionManager::CreateDeferredPhotoProcessingSession create session for userId: %d", userId);
+    DP_INFO_LOG("SessionManager::CreateDeferredPhotoProcessingSession create session for userId: %{public}d", userId);
     if (initialized_.load() == false) {
         DP_ERR_LOG("failed due to uninitialized.");
         return nullptr;