diff --git a/frameworks/buffer_client_producer.cpp b/frameworks/buffer_client_producer.cpp
index 71159d4..a9193da 100755
--- a/frameworks/buffer_client_producer.cpp
+++ b/frameworks/buffer_client_producer.cpp
@@ -44,12 +44,12 @@ SurfaceBufferImpl* BufferClientProducer::RequestBuffer(uint8_t wait)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, REQUEST_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != 0) {
-        GRAPHIC_LOGW("RequestBuffer Transact failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "RequestBuffer Transact failed");
         return nullptr;
     }
     ret = IpcIoPopInt32(&reply);
     if (ret != 0) {
-        GRAPHIC_LOGW("RequestBuffer generic failed code=%d", ret);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "RequestBuffer generic failed code=%d", ret);
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
         return nullptr;
     }
@@ -58,7 +58,7 @@ SurfaceBufferImpl* BufferClientProducer::RequestBuffer(uint8_t wait)
     buffer->ReadFromIpcIo(reply);
     BufferManager* manager = BufferManager::GetInstance();
     if (manager == nullptr) {
-        GRAPHIC_LOGW("BufferManager is null, usage(%d)", buffer->GetUsage());
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "BufferManager is null, usage(%d)", buffer->GetUsage());
         delete buffer;
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
         return nullptr;
@@ -82,7 +82,7 @@ int32_t BufferClientProducer::FlushBuffer(SurfaceBufferImpl* buffer)
     if (buffer->GetUsage() == BUFFER_CONSUMER_USAGE_HARDWARE_PRODUCER_CACHE) {
         ret = manager->FlushCache(*buffer);
         if (ret != SURFACE_ERROR_OK) {
-            GRAPHIC_LOGW("Flush buffer failed, ret=%d", ret);
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Flush buffer failed, ret=%d", ret);
             return ret;
         }
     }
@@ -94,13 +94,13 @@ int32_t BufferClientProducer::FlushBuffer(SurfaceBufferImpl* buffer)
     uintptr_t ptr;
     ret = Transact(nullptr, sid_, FLUSH_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("FlushBuffer failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "FlushBuffer failed");
         return ret;
     }
     ret = IpcIoPopInt32(&reply);
     FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("FlushBuffer failed code=%d", ret);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "FlushBuffer failed code=%d", ret);
         return -1;
     }
     manager->UnmapBuffer(*buffer);
@@ -121,7 +121,7 @@ void BufferClientProducer::Cancel(SurfaceBufferImpl* buffer)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, CANCEL_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("Cancel buffer failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Cancel buffer failed");
     } else {
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
     }
@@ -141,7 +141,7 @@ void BufferClientProducer::SetQueueSize(uint8_t queueSize)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, SET_QUEUE_SIZE, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("Set Attr(%d:%u) failed", SET_QUEUE_SIZE, queueSize);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Set Attr(%d:%u) failed", SET_QUEUE_SIZE, queueSize);
     }
     FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
 }
@@ -155,12 +155,12 @@ uint8_t BufferClientProducer::GetQueueSize()
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, GET_QUEUE_SIZE, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("GetAttr Transact failed, errno=%d", ret);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "GetAttr Transact failed, errno=%d", ret);
         return 0;
     }
     ret = IpcIoPopInt32(&reply);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("GetAttr failed code=%d", GET_QUEUE_SIZE);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "GetAttr failed code=%d", GET_QUEUE_SIZE);
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
         return 0;
     }
@@ -180,7 +180,7 @@ void BufferClientProducer::SetWidthAndHeight(uint32_t width, uint32_t height)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, SET_WIDTH_AND_HEIGHT, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("SetWidthAndHeight failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "SetWidthAndHeight failed");
     } else {
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
     }
@@ -254,7 +254,7 @@ void BufferClientProducer::SetUserData(const std::string& key, const std::string
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, SET_USER_DATA, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("Get user data(%s) failed", key.c_str());
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Get user data(%s) failed", key.c_str());
     } else {
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
     }
@@ -276,7 +276,7 @@ std::string BufferClientProducer::GetUserData(const std::string& key)
         size_t len = 0;
         const char* value = reinterpret_cast<char *>(IpcIoPopString(&reply, &len));
         if (value == nullptr || len == 0) {
-            GRAPHIC_LOGW("Get user data failed");
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Get user data failed");
         } else {
             sValue = value;
         }
@@ -295,7 +295,7 @@ void BufferClientProducer::SetAttr(uint32_t code, uint32_t value)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, code, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("Set Attr(%u:%u) failed", code, value);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Set Attr(%u:%u) failed", code, value);
     } else {
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
     }
@@ -310,12 +310,12 @@ uint32_t BufferClientProducer::GetAttr(uint32_t code)
     uintptr_t ptr;
     int32_t ret = Transact(nullptr, sid_, code, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("GetAttr Transact failed, errno=%d", ret);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "GetAttr Transact failed, errno=%d", ret);
         return 0;
     }
     ret = IpcIoPopInt32(&reply);
     if (ret != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGW("GetAttr failed code=%d", code);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "GetAttr failed code=%d", code);
         FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
         return 0;
     }
diff --git a/frameworks/buffer_manager.cpp b/frameworks/buffer_manager.cpp
index 53cca50..1ef4500 100755
--- a/frameworks/buffer_manager.cpp
+++ b/frameworks/buffer_manager.cpp
@@ -29,7 +29,7 @@ BufferManager* BufferManager::GetInstance()
 bool BufferManager::Init()
 {
     if (grallocFucs_ != nullptr) {
-        GRAPHIC_LOGI("BufferManager has init succeed.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "BufferManager has init succeed.");
         return true;
     }
     if (GrallocInitialize(&grallocFucs_) != DISPLAY_SUCCESS) {
@@ -52,7 +52,7 @@ bool BufferManager::ConversionUsage(uint64_t& destUsage, uint32_t srcUsage)
             destUsage = HBM_USE_MEM_MMZ_CACHE;
             break;
         default:
-            GRAPHIC_LOGW("Conversion usage failed.");
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Conversion usage failed.");
             return false;
     }
     return true;
@@ -104,7 +104,7 @@ bool BufferManager::ConversionFormat(PixelFormat& destFormat, uint32_t srcFormat
         case IMAGE_PIXEL_FORMAT_NV16:
         case IMAGE_PIXEL_FORMAT_NV61:
         default:
-            GRAPHIC_LOGW("Conversion format failed.");
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Conversion format failed.");
             return false;
     }
     return true;
@@ -124,11 +124,11 @@ SurfaceBufferImpl* BufferManager::AllocBuffer(uint32_t width, uint32_t height, u
     uint64_t tempUsage;
     PixelFormat tempFormat;
     if (!ConversionUsage(tempUsage, usage)) {
-        GRAPHIC_LOGW("Alloc graphic buffer failed --- conversion usage.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Alloc graphic buffer failed --- conversion usage.");
         return nullptr;
     }
     if (!ConversionFormat(tempFormat, format)) {
-        GRAPHIC_LOGW("Alloc graphic buffer failed --- conversion format.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Alloc graphic buffer failed --- conversion format.");
         return nullptr;
     }
     AllocInfo info = {
@@ -139,7 +139,7 @@ SurfaceBufferImpl* BufferManager::AllocBuffer(uint32_t width, uint32_t height, u
     };
     BufferHandle* bufferHandle = nullptr;
     if ((grallocFucs_->AllocMem == nullptr) || (grallocFucs_->AllocMem(&info, &bufferHandle) != DISPLAY_SUCCESS)) {
-        GRAPHIC_LOGW("Alloc graphic buffer failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Alloc graphic buffer failed");
         return nullptr;
     }
     SurfaceBufferImpl* buffer = new SurfaceBufferImpl();
@@ -150,10 +150,10 @@ SurfaceBufferImpl* BufferManager::AllocBuffer(uint32_t width, uint32_t height, u
         buffer->SetKey(bufferHandle->key);
         buffer->SetPhyAddr(bufferHandle->phyAddr);
         bufferHandleMap_.insert(std::make_pair(bufferHandle->phyAddr, bufferHandle));
-        GRAPHIC_LOGI("Alloc buffer succeed to shared memory segment.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Alloc buffer succeed to shared memory segment.");
     } else {
         grallocFucs_->FreeMem(bufferHandle);
-        GRAPHIC_LOGW("Alloc buffer failed to shared memory segment.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Alloc buffer failed to shared memory segment.");
     }
     return buffer;
 }
@@ -162,7 +162,7 @@ void BufferManager::FreeBuffer(SurfaceBufferImpl** buffer)
 {
     RETURN_IF_FAIL((grallocFucs_ != nullptr));
     if ((*buffer) == nullptr) {
-        GRAPHIC_LOGW("Input param buffer is null.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Input param buffer is null.");
         return;
     }
     auto iter = bufferHandleMap_.find((*buffer)->GetPhyAddr());
@@ -175,7 +175,7 @@ void BufferManager::FreeBuffer(SurfaceBufferImpl** buffer)
         bufferHandleMap_.erase((*buffer)->GetPhyAddr());
         delete *buffer;
         *buffer = nullptr;
-        GRAPHIC_LOGI("Free buffer succeed.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Free buffer succeed.");
     }
 }
 
@@ -185,7 +185,7 @@ bool BufferManager::MapBuffer(SurfaceBufferImpl& buffer)
     void* virAddr = NULL;
     BufferHandle bufferHandle;
     if (!ConversionUsage(bufferHandle.usage, buffer.GetUsage())) {
-        GRAPHIC_LOGW("Conversion usage failed.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Conversion usage failed.");
         return false;
     }
     SurfaceBufferToBufferHandle(buffer, bufferHandle);
@@ -200,15 +200,15 @@ bool BufferManager::MapBuffer(SurfaceBufferImpl& buffer)
             virAddr = grallocFucs_->MmapCache(&bufferHandle);
         }
     } else {
-        GRAPHIC_LOGW("No Suport usage.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "No Suport usage.");
         return false;
     }
     if (virAddr == NULL) {
-        GRAPHIC_LOGW("Map Buffer error.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Map Buffer error.");
         return false;
     }
     buffer.SetVirAddr(virAddr);
-    GRAPHIC_LOGW("Map Buffer succeed.");
+    HILOG_WARN(HILOG_MODULE_GRAPHIC, "Map Buffer succeed.");
     return true;
 }
 
@@ -217,12 +217,12 @@ void BufferManager::UnmapBuffer(SurfaceBufferImpl& buffer)
     RETURN_IF_FAIL((grallocFucs_ != nullptr));
     BufferHandle bufferHandle;
     if (!ConversionUsage(bufferHandle.usage, buffer.GetUsage())) {
-        GRAPHIC_LOGW("Conversion usage failed.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Conversion usage failed.");
         return;
     }
     SurfaceBufferToBufferHandle(buffer, bufferHandle);
     if ((grallocFucs_->Unmap == nullptr) || (grallocFucs_->Unmap(&bufferHandle) != DISPLAY_SUCCESS)) {
-        GRAPHIC_LOGW("Umap buffer failed.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Umap buffer failed.");
     }
 }
 
@@ -231,19 +231,19 @@ int32_t BufferManager::FlushCache(const SurfaceBufferImpl& buffer)
     RETURN_VAL_IF_FAIL((grallocFucs_ != nullptr), SURFACE_ERROR_NOT_READY);
     BufferHandle bufferHandle;
     if (!ConversionUsage(bufferHandle.usage, buffer.GetUsage())) {
-        GRAPHIC_LOGW("Conversion usage failed.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Conversion usage failed.");
         return false;
     }
     SurfaceBufferToBufferHandle(buffer, bufferHandle);
     if (buffer.GetUsage() == BUFFER_CONSUMER_USAGE_HARDWARE_CONSUMER_CACHE) {
         if ((grallocFucs_->FlushCache == nullptr) || (grallocFucs_->FlushCache(&bufferHandle) != DISPLAY_SUCCESS)) {
-            GRAPHIC_LOGW("Flush cache buffer failed.");
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Flush cache buffer failed.");
         }
     } else if (buffer.GetUsage() == BUFFER_CONSUMER_USAGE_HARDWARE_PRODUCER_CACHE) {
         if ((grallocFucs_->FlushMCache == nullptr) || (grallocFucs_->FlushMCache(&bufferHandle) != DISPLAY_SUCCESS)) {
-            GRAPHIC_LOGW("Flush M cache buffer failed.");
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Flush M cache buffer failed.");
         }
     }
     return SURFACE_ERROR_OK;
 }
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
diff --git a/frameworks/buffer_queue.cpp b/frameworks/buffer_queue.cpp
index 40c0780..7047b97 100755
--- a/frameworks/buffer_queue.cpp
+++ b/frameworks/buffer_queue.cpp
@@ -65,11 +65,11 @@ BufferQueue::~BufferQueue()
 bool BufferQueue::Init()
 {
     if (pthread_mutex_init(&lock_, NULL)) {
-        GRAPHIC_LOGE("Failed init mutex");
+        HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Failed init mutex");
         return false;
     }
     if (pthread_cond_init(&freeCond_, NULL)) {
-        GRAPHIC_LOGE("Failed init cond");
+        HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Failed init cond");
         pthread_mutex_destroy(&lock_);
         return false;
     }
@@ -84,7 +84,7 @@ void BufferQueue::InitParam()
 void BufferQueue::UpdatePlaneInfo()
 {
     if (!IsFormatSupported(format_)) {
-        GRAPHIC_LOGW("The format is not suppored");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "The format is not suppored");
         return;
     }
     uint8_t planeCount = GetPlaneCount(format_);
@@ -136,7 +136,7 @@ uint8_t BufferQueue::GetPlaneCount(uint32_t format)
             count = IMAGE_PIXEL_FORMAT_PLANE_COUNT_YUV4XX;
             break;
         default:
-            GRAPHIC_LOGI("The format is not supported.");
+            HILOG_INFO(HILOG_MODULE_GRAPHIC, "The format is not supported.");
             break;
     }
     return count;
@@ -213,11 +213,11 @@ void BufferQueue::QueryEachPlaneInfo(uint32_t planeIndex, uint32_t& size, uint32
 void BufferQueue::NeedAttach()
 {
     if (queueSize_ == attachCount_) {
-        GRAPHIC_LOGI("has alloced %d buffer, could not alloc more.", allBuffers_.size());
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "has alloced %d buffer, could not alloc more.", allBuffers_.size());
         return;
     }
     if (size_ == 0 && isValidAttr(width_, height_, format_, strideAlignment_) != SURFACE_ERROR_OK) {
-        GRAPHIC_LOGI("Invalid Attr.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Invalid Attr.");
         return;
     }
     if (size_ == 0) {
@@ -227,7 +227,7 @@ void BufferQueue::NeedAttach()
     RETURN_IF_FAIL(bufferManager);
     SurfaceBufferImpl *buffer = bufferManager->AllocBuffer(width_, height_, format_, usage_);
     if (buffer == nullptr) {
-        GRAPHIC_LOGI("BufferManager alloc memory failed ");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "BufferManager alloc memory failed ");
         return;
     }
     attachCount_++;
@@ -246,7 +246,7 @@ bool BufferQueue::CanRequest(uint8_t wait)
         NeedAttach();
         res = true;
         if (freeList_.empty()) {
-            GRAPHIC_LOGI("no buffer in freeQueue for dequeue.");
+            HILOG_INFO(HILOG_MODULE_GRAPHIC, "no buffer in freeQueue for dequeue.");
             res = false;
         }
         goto ERROR;
@@ -264,12 +264,12 @@ SurfaceBufferImpl* BufferQueue::RequestBuffer(uint8_t wait)
     SurfaceBufferImpl *buffer = nullptr;
     pthread_mutex_lock(&lock_);
     if (!CanRequest(wait)) {
-        GRAPHIC_LOGI("No buffer can request now.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "No buffer can request now.");
         goto ERROR;
     }
     buffer = freeList_.front();
     if (buffer == nullptr) {
-        GRAPHIC_LOGI("freeQueue pop buffer failed.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "freeQueue pop buffer failed.");
         goto ERROR;
     }
     freeList_.pop_front();
@@ -296,7 +296,7 @@ int32_t BufferQueue::FlushBuffer(SurfaceBufferImpl& buffer)
     pthread_mutex_lock(&lock_);
     SurfaceBufferImpl *tmpBuffer = GetBuffer(buffer);
     if (tmpBuffer == nullptr || tmpBuffer->GetState() != BUFFER_STATE_REQUEST) {
-        GRAPHIC_LOGI("Buffer is not existed or state invailed.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Buffer is not existed or state invailed.");
         pthread_mutex_unlock(&lock_);
         return SURFACE_ERROR_BUFFER_NOT_EXISTED;
     }
@@ -314,13 +314,13 @@ SurfaceBufferImpl* BufferQueue::AcquireBuffer()
     pthread_mutex_lock(&lock_);
     if (dirtyList_.empty()) {
         pthread_mutex_unlock(&lock_);
-        GRAPHIC_LOGD("dirty queue is empty.");
+        HILOG_DEBUG(HILOG_MODULE_GRAPHIC, "dirty queue is empty.");
         return nullptr;
     }
     SurfaceBufferImpl *buffer = dirtyList_.front();
     if (buffer == nullptr) {
         pthread_mutex_unlock(&lock_);
-        GRAPHIC_LOGW("dirty queue pop buffer failed.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "dirty queue pop buffer failed.");
         return nullptr;
     }
     buffer->SetState(BUFFER_STATE_ACQUIRE);
@@ -331,7 +331,7 @@ SurfaceBufferImpl* BufferQueue::AcquireBuffer()
 void BufferQueue::Detach(SurfaceBufferImpl *buffer)
 {
     if (buffer == nullptr) {
-        GRAPHIC_LOGW("Detach buffer failed, buffer is null.");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Detach buffer failed, buffer is null.");
         return;
     }
     freeList_.remove(buffer);
@@ -359,20 +359,20 @@ int32_t BufferQueue::ReleaseBuffer(const SurfaceBufferImpl& buffer, BufferState
     pthread_mutex_lock(&lock_);
     SurfaceBufferImpl *tmpBuffer = GetBuffer(buffer);
     if (tmpBuffer == nullptr || tmpBuffer->GetState() != state) {
-        GRAPHIC_LOGI("Buffer is not existed or state invailed.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Buffer is not existed or state invailed.");
         ret = SURFACE_ERROR_BUFFER_NOT_EXISTED;
         goto ERROR;
     }
 
     if (tmpBuffer->GetDeletePending() == 1) {
-        GRAPHIC_LOGI("Release the buffer which state is deletePending.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Release the buffer which state is deletePending.");
         Detach(tmpBuffer);
         ret = SURFACE_ERROR_OK;
         goto ERROR;
     }
 
     if (allBuffers_.size() > queueSize_) {
-        GRAPHIC_LOGI("Release the buffer: alloc buffer count is more than max queue count.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Release the buffer: alloc buffer count is more than max queue count.");
         attachCount_--;
         Detach(tmpBuffer);
         ret = SURFACE_ERROR_OK;
@@ -401,7 +401,7 @@ int32_t BufferQueue::Reset(uint32_t size)
 {
     if (size == 0) {
         if (isValidAttr(width_, height_, format_, strideAlignment_) != SURFACE_ERROR_OK) {
-            GRAPHIC_LOGI("Invalid Attr.");
+            HILOG_INFO(HILOG_MODULE_GRAPHIC, "Invalid Attr.");
             return SURFACE_ERROR_INVAILD_PARAM;
         } else {
             InitParam();
@@ -431,7 +431,7 @@ int32_t BufferQueue::Reset(uint32_t size)
 void BufferQueue::SetQueueSize(uint8_t queueSize)
 {
     if (queueSize > BUFFER_QUEUE_SIZE_MAX || queueSize == queueSize_) {
-        GRAPHIC_LOGI("The queue count(%u) is invaild", queueSize);
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "The queue count(%u) is invaild", queueSize);
         return;
     }
     pthread_mutex_lock(&lock_);
@@ -523,7 +523,7 @@ std::string BufferQueue::GetUserData(const std::string& key)
 void BufferQueue::SetFormat(uint32_t format)
 {
     if (format == IMAGE_PIXEL_FORMAT_NONE || !IsFormatSupported(format)) {
-        GRAPHIC_LOGI("Format is invailed or not supported %u", format);
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Format is invailed or not supported %u", format);
         return;
     }
     pthread_mutex_lock(&lock_);
diff --git a/frameworks/buffer_queue_producer.cpp b/frameworks/buffer_queue_producer.cpp
index 10dd02f..8e163c9 100755
--- a/frameworks/buffer_queue_producer.cpp
+++ b/frameworks/buffer_queue_producer.cpp
@@ -36,7 +36,7 @@ static int32_t OnRequestBuffer(BufferQueueProducer* product, void *ipcMsg, IpcIo
     IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1);
     uint32_t ret = -1;
     if (buffer == nullptr) {
-        GRAPHIC_LOGW("get buffer failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "get buffer failed");
         IpcIoPushInt32(&reply, -1);
         ret = -1;
     } else {
@@ -182,12 +182,12 @@ static int32_t OnSetUserData(BufferQueueProducer* product, void *ipcMsg, IpcIo *
     size_t len = 0;
     const char* key = reinterpret_cast<char *>(IpcIoPopString(io, &len));
     if (key == nullptr || len == 0) {
-        GRAPHIC_LOGW("Get user data key failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Get user data key failed");
         return -1;
     }
     const char* value = reinterpret_cast<char *>(IpcIoPopString(io, &len));
     if (value == nullptr || len == 0) {
-        GRAPHIC_LOGW("Get user data value failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Get user data value failed");
         return -1;
     }
     std::string sKey = key;
@@ -202,7 +202,7 @@ static int32_t OnGetUserData(BufferQueueProducer* product, void *ipcMsg, IpcIo *
     size_t len = 0;
     const char* key = reinterpret_cast<char *>(IpcIoPopString(io, &len));
     if (key == nullptr || len == 0) {
-        GRAPHIC_LOGW("Get user data key failed");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Get user data key failed");
         return -1;
     }
     std::string sKey = key;
@@ -279,7 +279,7 @@ int32_t BufferQueueProducer::FlushBuffer(SurfaceBufferImpl* buffer)
     if (buffer->GetUsage() == BUFFER_CONSUMER_USAGE_HARDWARE_CONSUMER_CACHE) {
         int32_t ret = manager->FlushCache(*buffer);
         if (ret != 0) {
-            GRAPHIC_LOGW("Flush buffer failed, ret=%d", ret);
+            HILOG_WARN(HILOG_MODULE_GRAPHIC, "Flush buffer failed, ret=%d", ret);
             return ret;
         }
     }
@@ -389,13 +389,13 @@ void BufferQueueProducer::UnregisterConsumerListener()
 int32_t BufferQueueProducer::OnIpcMsg(void *ipcMsg, IpcIo *io)
 {
     if (ipcMsg == NULL || io == NULL) {
-        GRAPHIC_LOGW("Invalid parameter, null pointer");
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Invalid parameter, null pointer");
         return SURFACE_ERROR_INVAILD_PARAM;
     }
     uint32_t code;
     (void)GetCode(ipcMsg, &code);
     if (code >= MAX_REQUEST_CODE) {
-        GRAPHIC_LOGW("Resquest code(%u) does not support.", code);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Resquest code(%u) does not support.", code);
         FreeBuffer(nullptr, ipcMsg);
         return SURFACE_ERROR_INVAILD_REQUEST;
     }
diff --git a/frameworks/surface.cpp b/frameworks/surface.cpp
index 9a61859..96e52c1 100755
--- a/frameworks/surface.cpp
+++ b/frameworks/surface.cpp
@@ -24,11 +24,11 @@ Surface* Surface::CreateSurface()
         if (surface->Init()) {
             return surface;
         } else {
-            GRAPHIC_LOGE("surface init failed");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "surface init failed");
             delete surface;
         }
     }
-    GRAPHIC_LOGE("Create surface failed");
+    HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Create surface failed");
     return nullptr;
 }
 
diff --git a/frameworks/surface_buffer_impl.cpp b/frameworks/surface_buffer_impl.cpp
index 15e68a2..f990ec6 100755
--- a/frameworks/surface_buffer_impl.cpp
+++ b/frameworks/surface_buffer_impl.cpp
@@ -72,11 +72,11 @@ int32_t SurfaceBufferImpl::SetData(uint32_t key, uint8_t type, const void* data,
         type >= BUFFER_DATA_TYPE_MAX ||
         size <= 0 ||
         size > sizeof(int64_t)) {
-        GRAPHIC_LOGI("Invaild Param");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "Invaild Param");
         return SURFACE_ERROR_INVAILD_PARAM;
     }
     if (extDatas_.size() > MAX_USER_DATA_COUNT) {
-        GRAPHIC_LOGI("No more data can be saved because the storage space is full.");
+        HILOG_INFO(HILOG_MODULE_GRAPHIC, "No more data can be saved because the storage space is full.");
         return SURFACE_ERROR_SYSTEM_ERROR;
     }
     ExtraData extData = {0};
@@ -91,13 +91,13 @@ int32_t SurfaceBufferImpl::SetData(uint32_t key, uint8_t type, const void* data,
     if (extData.value == NULL) {
         extData.value = malloc(size);
         if (extData.value == NULL) {
-            GRAPHIC_LOGE("Couldn't allocate %zu bytes for ext data", size);
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Couldn't allocate %zu bytes for ext data", size);
             return SURFACE_ERROR_SYSTEM_ERROR;
         }
     }
     if (memcpy_s(extData.value, size, data, size) != EOK) {
         free(extData.value);
-        GRAPHIC_LOGW("Couldn't copy %zu bytes for ext data", size);
+        HILOG_WARN(HILOG_MODULE_GRAPHIC, "Couldn't copy %zu bytes for ext data", size);
         return SURFACE_ERROR_SYSTEM_ERROR;
     }
     extData.size = size;
diff --git a/frameworks/surface_impl.cpp b/frameworks/surface_impl.cpp
index b4d8424..4b49bd6 100755
--- a/frameworks/surface_impl.cpp
+++ b/frameworks/surface_impl.cpp
@@ -56,31 +56,31 @@ SurfaceImpl::~SurfaceImpl()
 bool SurfaceImpl::Init()
 {
     if (!BufferManager::GetInstance()->Init()) {
-        GRAPHIC_LOGE("Failed init buffer manager");
+        HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Failed init buffer manager");
         return false;
     }
     if (IsConsumer_) {
         BufferQueue* bufferQueue = new BufferQueue();
         if (bufferQueue == nullptr) {
-            GRAPHIC_LOGE("Surface consumer(buffer queue) init failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Surface consumer(buffer queue) init failed.");
             return false;
         }
 
         if (!bufferQueue->Init()) {
-            GRAPHIC_LOGE("Buffer queue init failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Buffer queue init failed.");
             delete bufferQueue;
             return false;
         }
 
         producer_ = new BufferQueueProducer(bufferQueue);
         if (producer_ == nullptr) {
-            GRAPHIC_LOGE("Surface consumer(producer) init failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Surface consumer(producer) init failed.");
             delete bufferQueue;
             return false;
         }
         consumer_ = new BufferQueueConsumer(*bufferQueue);
         if (consumer_ == nullptr) {
-            GRAPHIC_LOGE("Surface consumer(consumer) init failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Surface consumer(consumer) init failed.");
             delete producer_;
             producer_ = nullptr;
             return false;
@@ -88,7 +88,7 @@ bool SurfaceImpl::Init()
         SvcIdentity svc;
         int32_t ret = RegisterIpcCallback(IpcRequestHandler, 0, IPC_WAIT_FOREVER, &svc, producer_);
         if (ret != LITEIPC_OK) {
-            GRAPHIC_LOGE("Surface RegisterIpcCallback failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Surface RegisterIpcCallback failed.");
             delete consumer_;
             consumer_ = nullptr;
             delete producer_;
@@ -99,7 +99,7 @@ bool SurfaceImpl::Init()
     } else {
         producer_ = new BufferClientProducer(sid_);
         if (producer_ == nullptr) {
-            GRAPHIC_LOGE("Surface producer init failed.");
+            HILOG_ERROR(HILOG_MODULE_GRAPHIC, "Surface producer init failed.");
             return false;
         }
     }
@@ -292,7 +292,7 @@ Surface* SurfaceImpl::GenericSurfaceByIpcIo(IpcIo& io)
             if (surface->Init()) {
                 return surface;
             } else {
-                GRAPHIC_LOGE("surface init failed");
+                HILOG_ERROR(HILOG_MODULE_GRAPHIC, "surface init failed");
                 delete surface;
             }
         }
diff --git a/interfaces/innerkits/buffer_common.h b/interfaces/innerkits/buffer_common.h
index bd95091..f0b7229 100755
--- a/interfaces/innerkits/buffer_common.h
+++ b/interfaces/innerkits/buffer_common.h
@@ -21,14 +21,14 @@
 namespace OHOS {
 #define RETURN_VAL_IF_FAIL(cond, val) { \
     if (!(cond)) {                      \
-        GRAPHIC_LOGD("'%s' failed.", #cond);    \
+        HILOG_DEBUG(HILOG_MODULE_GRAPHIC, "'%s' failed.", #cond);    \
         return val;                     \
     }                                   \
 }
 
 #define RETURN_IF_FAIL(cond) {          \
     if (!(cond)) {                      \
-        GRAPHIC_LOGD("'%s' failed.", #cond);    \
+        HILOG_DEBUG(HILOG_MODULE_GRAPHIC, "'%s' failed.", #cond);    \
         return;                         \
     }                                   \
 }
diff --git a/interfaces/innerkits/surface_buffer_impl.h b/interfaces/innerkits/surface_buffer_impl.h
index 3483d32..955b818 100755
--- a/interfaces/innerkits/surface_buffer_impl.h
+++ b/interfaces/innerkits/surface_buffer_impl.h
@@ -173,7 +173,7 @@ public:
     void SetSize(uint32_t size) override
     {
         if (size > bufferData_.size) {
-            GRAPHIC_LOGI("Input param is invaild");
+            HILOG_INFO(HILOG_MODULE_GRAPHIC, "Input param is invaild");
             return;
         }
         len_ = size;