From 0ec590410c4bc0208dd6f3b6fe215e18f00ca3e5 Mon Sep 17 00:00:00 2001 From: xing-tai-zhang Date: Fri, 6 May 2022 17:41:59 +0800 Subject: [PATCH] Description: IPC switching interface IssueNo: https://gitee.com/openharmony/communication_ipc/issues/I52D5F Feature or Bugfix: Bugfix Binary Source:No Signed-off-by: xing-tai-zhang --- BUILD.gn | 2 +- frameworks/buffer_client_producer.cpp | 113 ++++++++------- frameworks/buffer_client_producer.h | 4 +- frameworks/buffer_queue_producer.cpp | 156 +++++++++------------ frameworks/buffer_queue_producer.h | 3 +- frameworks/surface.cpp | 2 +- frameworks/surface_buffer_impl.cpp | 54 +++---- frameworks/surface_impl.cpp | 50 +++---- interfaces/innerkits/surface_buffer_impl.h | 4 +- interfaces/innerkits/surface_impl.h | 7 +- test/BUILD.gn | 2 +- 11 files changed, 196 insertions(+), 201 deletions(-) diff --git a/BUILD.gn b/BUILD.gn index 0112f6d..e247773 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -43,7 +43,7 @@ shared_library("surface") { public_deps = [ "//foundation/graphic/utils:lite_graphic_utils" ] deps = [ "//drivers/peripheral/display/hal:hdi_display", - "//foundation/communication/ipc_lite:liteipc_adapter", + "//foundation/communication/ipc/interfaces/innerkits/c/ipc:ipc_single", "//third_party/bounds_checking_function:libsec_shared", ] ldflags = [ diff --git a/frameworks/buffer_client_producer.cpp b/frameworks/buffer_client_producer.cpp index 71159d4..33ef77a 100644 --- a/frameworks/buffer_client_producer.cpp +++ b/frameworks/buffer_client_producer.cpp @@ -14,10 +14,7 @@ */ #include "buffer_client_producer.h" - -#include "liteipc_adapter.h" -#include "liteipc_adapter.h" -#include "serializer.h" +#include "ipc_skeleton.h" #include "buffer_common.h" #include "buffer_manager.h" @@ -39,18 +36,20 @@ SurfaceBufferImpl* BufferClientProducer::RequestBuffer(uint8_t wait) IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushUint8(&requestIo, wait); + WriteUint8(&requestIo, wait); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, REQUEST_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, REQUEST_BUFFER, &requestIo, &reply, option, &ptr); if (ret != 0) { - GRAPHIC_LOGW("RequestBuffer Transact failed"); + GRAPHIC_LOGW("RequestBuffer SendRequest failed"); return nullptr; } - ret = IpcIoPopInt32(&reply); + ReadInt32(&reply, &ret); if (ret != 0) { GRAPHIC_LOGW("RequestBuffer generic failed code=%d", ret); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return nullptr; } @@ -60,16 +59,16 @@ SurfaceBufferImpl* BufferClientProducer::RequestBuffer(uint8_t wait) if (manager == nullptr) { GRAPHIC_LOGW("BufferManager is null, usage(%d)", buffer->GetUsage()); delete buffer; - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return nullptr; } if (!manager->MapBuffer(*buffer)) { Cancel(buffer); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return nullptr; } - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return buffer; } @@ -92,13 +91,15 @@ int32_t BufferClientProducer::FlushBuffer(SurfaceBufferImpl* buffer) buffer->WriteToIpcIo(requestIo); IpcIo reply; uintptr_t ptr; - ret = Transact(nullptr, sid_, FLUSH_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + ret = SendRequest(sid_, FLUSH_BUFFER, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("FlushBuffer failed"); return ret; } - ret = IpcIoPopInt32(&reply); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + ReadInt32(&reply, &ret); + FreeBuffer(reinterpret_cast(ptr)); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("FlushBuffer failed code=%d", ret); return -1; @@ -119,11 +120,13 @@ void BufferClientProducer::Cancel(SurfaceBufferImpl* buffer) buffer->WriteToIpcIo(requestIo); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, CANCEL_BUFFER, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, CANCEL_BUFFER, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("Cancel buffer failed"); } else { - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); } BufferManager* manager = BufferManager::GetInstance(); RETURN_IF_FAIL(manager); @@ -136,14 +139,16 @@ void BufferClientProducer::SetQueueSize(uint8_t queueSize) IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushUint8(&requestIo, queueSize); + WriteUint8(&requestIo, queueSize); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, SET_QUEUE_SIZE, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, SET_QUEUE_SIZE, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("Set Attr(%d:%u) failed", SET_QUEUE_SIZE, queueSize); } - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); } uint8_t BufferClientProducer::GetQueueSize() @@ -153,19 +158,22 @@ uint8_t BufferClientProducer::GetQueueSize() IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, GET_QUEUE_SIZE, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, GET_QUEUE_SIZE, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { - GRAPHIC_LOGW("GetAttr Transact failed, errno=%d", ret); + GRAPHIC_LOGW("GetAttr SendRequest failed, errno=%d", ret); return 0; } - ret = IpcIoPopInt32(&reply); + ReadInt32(&reply, &ret); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("GetAttr failed code=%d", GET_QUEUE_SIZE); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return 0; } - uint8_t queueSize = IpcIoPopUint8(&reply); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + uint8_t queueSize; + ReadUint8(&reply, &queueSize); + FreeBuffer(reinterpret_cast(ptr)); return queueSize; } @@ -174,15 +182,17 @@ void BufferClientProducer::SetWidthAndHeight(uint32_t width, uint32_t height) IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushUint32(&requestIo, width); - IpcIoPushUint32(&requestIo, height); + WriteUint32(&requestIo, width); + WriteUint32(&requestIo, height); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, SET_WIDTH_AND_HEIGHT, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, SET_WIDTH_AND_HEIGHT, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("SetWidthAndHeight failed"); } else { - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); } return; } @@ -248,15 +258,17 @@ void BufferClientProducer::SetUserData(const std::string& key, const std::string IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushString(&requestIo, key.c_str()); - IpcIoPushString(&requestIo, value.c_str()); + WriteString(&requestIo, key.c_str()); + WriteString(&requestIo, value.c_str()); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, SET_USER_DATA, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, SET_USER_DATA, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("Get user data(%s) failed", key.c_str()); } else { - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); } } @@ -266,21 +278,23 @@ std::string BufferClientProducer::GetUserData(const std::string& key) IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushString(&requestIo, key.c_str()); + WriteString(&requestIo, key.c_str()); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, GET_USER_DATA, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, GET_USER_DATA, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { return sValue; } else { size_t len = 0; - const char* value = reinterpret_cast(IpcIoPopString(&reply, &len)); + const char* value = reinterpret_cast(ReadString(&reply, &len)); if (value == nullptr || len == 0) { GRAPHIC_LOGW("Get user data failed"); } else { sValue = value; } - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return sValue; } } @@ -290,14 +304,16 @@ void BufferClientProducer::SetAttr(uint32_t code, uint32_t value) IpcIo requestIo; uint8_t requestIoData[DEFAULT_IPC_SIZE]; IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); - IpcIoPushUint32(&requestIo, value); + WriteUint32(&requestIo, value); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, code, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, code, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("Set Attr(%u:%u) failed", code, value); } else { - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); } } @@ -308,19 +324,22 @@ uint32_t BufferClientProducer::GetAttr(uint32_t code) IpcIoInit(&requestIo, requestIoData, DEFAULT_IPC_SIZE, 0); IpcIo reply; uintptr_t ptr; - int32_t ret = Transact(nullptr, sid_, code, &requestIo, &reply, LITEIPC_FLAG_DEFAULT, &ptr); + MessageOption option; + MessageOptionInit(&option); + int32_t ret = SendRequest(sid_, code, &requestIo, &reply, option, &ptr); if (ret != SURFACE_ERROR_OK) { - GRAPHIC_LOGW("GetAttr Transact failed, errno=%d", ret); + GRAPHIC_LOGW("GetAttr SendRequest failed, errno=%d", ret); return 0; } - ret = IpcIoPopInt32(&reply); + ReadInt32(&reply, &ret); if (ret != SURFACE_ERROR_OK) { GRAPHIC_LOGW("GetAttr failed code=%d", code); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + FreeBuffer(reinterpret_cast(ptr)); return 0; } - uint32_t attr = IpcIoPopUint32(&reply); - FreeBuffer(nullptr, reinterpret_cast(ptr)); + uint32_t attr; + ReadUint32(&reply, &attr); + FreeBuffer(reinterpret_cast(ptr)); return attr; } } // end namespace diff --git a/frameworks/buffer_client_producer.h b/frameworks/buffer_client_producer.h index 5b2b599..a5bacd3 100644 --- a/frameworks/buffer_client_producer.h +++ b/frameworks/buffer_client_producer.h @@ -16,9 +16,10 @@ #ifndef GRAPHIC_LITE_BUFFER_CLIENT_PRODUCER_H #define GRAPHIC_LITE_BUFFER_CLIENT_PRODUCER_H +#include #include "buffer_producer.h" #include "buffer_queue.h" -#include "liteipc_adapter.h" +#include "ipc_skeleton.h" #include "serializer.h" #include "surface_buffer.h" namespace OHOS { @@ -178,6 +179,7 @@ private: uint32_t GetAttr(uint32_t code); void SetAttr(uint32_t code, uint32_t value); SvcIdentity sid_; + IpcObjectStub objectStub_; }; } // end namespace diff --git a/frameworks/buffer_queue_producer.cpp b/frameworks/buffer_queue_producer.cpp index c8ef020..ca9523e 100644 --- a/frameworks/buffer_queue_producer.cpp +++ b/frameworks/buffer_queue_producer.cpp @@ -24,168 +24,156 @@ namespace OHOS { const int32_t DEFAULT_IPC_SIZE = 100; extern "C" { -typedef int32_t (*IpcMsgHandle)(BufferQueueProducer* product, void *ipcMsg, IpcIo *io); +typedef int32_t (*IpcMsgHandle)(BufferQueueProducer* product, IpcIo *io, IpcIo *reply); }; -static int32_t OnRequestBuffer(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnRequestBuffer(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint8_t isWaiting = IpcIoPopUint8(io); + uint8_t isWaiting; + ReadUint8(io, &isWaiting); SurfaceBufferImpl* buffer = product->RequestBuffer(isWaiting); - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1); uint32_t ret = -1; if (buffer == nullptr) { GRAPHIC_LOGW("get buffer failed"); - IpcIoPushInt32(&reply, -1); + WriteInt32(reply, -1); ret = -1; } else { - IpcIoPushInt32(&reply, 0); - buffer->WriteToIpcIo(reply); + WriteInt32(reply, 0); + buffer->WriteToIpcIo(*reply); ret = 0; } - SendReply(nullptr, ipcMsg, &reply); return ret; } -static int32_t OnFlushBuffer(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnFlushBuffer(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1); SurfaceBufferImpl buffer; buffer.ReadFromIpcIo(*io); - IpcIoPushInt32(&reply, product->EnqueueBuffer(buffer)); - SendReply(nullptr, ipcMsg, &reply); + WriteInt32(reply, product->EnqueueBuffer(buffer)); return 0; } -static int32_t OnCancelBuffer(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnCancelBuffer(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { SurfaceBufferImpl buffer; buffer.ReadFromIpcIo(*io); product->Cancel(&buffer); - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1); - IpcIoPushInt32(&reply, 0); - SendReply(nullptr, ipcMsg, &reply); + WriteInt32(reply, 0); return 0; } -static int32_t OnGetAttr(uint32_t attr, void *ipcMsg, IpcIo *io) +static int32_t OnGetAttr(uint32_t attr, IpcIo *io, IpcIo *reply) { - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1); - IpcIoPushInt32(&reply, 0); - IpcIoPushUint32(&reply, attr); - SendReply(nullptr, ipcMsg, &reply); + WriteInt32(reply, 0); + WriteUint32(reply, attr); return 0; } -static int32_t OnSendReply(void *ipcMsg, IpcIo *io) +static int32_t OnSendReply(IpcIo *io, IpcIo *reply) { - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 1); - IpcIoPushInt32(&reply, 0); - SendReply(nullptr, ipcMsg, &reply); + WriteInt32(reply, 0); return 0; } -static int32_t OnSetQueueSize(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetQueueSize(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t queueSize = IpcIoPopUint32(io); + uint32_t queueSize; + ReadUint32(io, &queueSize); product->SetQueueSize(queueSize); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t OnGetQueueSize(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetQueueSize(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetQueueSize(), ipcMsg, io); + return OnGetAttr(product->GetQueueSize(), io, reply); } -static int32_t OnSetWidthAndHeight(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetWidthAndHeight(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t width = IpcIoPopUint32(io); - uint32_t height = IpcIoPopUint32(io); + uint32_t width; + ReadUint32(io, &width); + uint32_t height; + ReadUint32(io, &height); product->SetWidthAndHeight(width, height); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t OnGetWidth(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetWidth(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetWidth(), ipcMsg, io); + return OnGetAttr(product->GetWidth(), io, reply); } -static int32_t OnGetHeight(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetHeight(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetHeight(), ipcMsg, io); + return OnGetAttr(product->GetHeight(), io, reply); } -static int32_t OnSetFormat(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetFormat(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t format = IpcIoPopUint32(io); + uint32_t format; + ReadUint32(io, &format); product->SetFormat(format); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t OnGetFormat(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetFormat(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetFormat(), ipcMsg, io); + return OnGetAttr(product->GetFormat(), io, reply); } -static int32_t OnSetStrideAlignment(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetStrideAlignment(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t strideAlignment = IpcIoPopUint32(io); + uint32_t strideAlignment; + ReadUint32(io, &strideAlignment); product->SetStrideAlignment(strideAlignment); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t GetStrideAlignment(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t GetStrideAlignment(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetStrideAlignment(), ipcMsg, io); + return OnGetAttr(product->GetStrideAlignment(), io, reply); } -static int32_t OnGetStride(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetStride(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetStride(), ipcMsg, io); + return OnGetAttr(product->GetStride(), io, reply); } -static int32_t OnSetSize(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetSize(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t size = IpcIoPopUint32(io); + uint32_t size; + ReadUint32(io, &size); product->SetSize(size); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t OnGetSize(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetSize(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetSize(), ipcMsg, io); + return OnGetAttr(product->GetSize(), io, reply); } -static int32_t OnSetUsage(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetUsage(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - uint32_t usage = IpcIoPopUint32(io); + uint32_t usage; + ReadUint32(io, &usage); product->SetUsage(usage); - return OnSendReply(ipcMsg, io); + return OnSendReply(io, reply); } -static int32_t OnGetUsage(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetUsage(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { - return OnGetAttr(product->GetUsage(), ipcMsg, io); + return OnGetAttr(product->GetUsage(), io, reply); } -static int32_t OnSetUserData(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnSetUserData(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { size_t len = 0; - const char* key = reinterpret_cast(IpcIoPopString(io, &len)); + const char* key = reinterpret_cast(ReadString(io, &len)); if (key == nullptr || len == 0) { GRAPHIC_LOGW("Get user data key failed"); return -1; } - const char* value = reinterpret_cast(IpcIoPopString(io, &len)); + const char* value = reinterpret_cast(ReadString(io, &len)); if (value == nullptr || len == 0) { GRAPHIC_LOGW("Get user data value failed"); return -1; @@ -193,25 +181,21 @@ static int32_t OnSetUserData(BufferQueueProducer* product, void *ipcMsg, IpcIo * std::string sKey = key; std::string sValue = value; product->SetUserData(sKey, sValue); - OnSendReply(ipcMsg, io); + OnSendReply(io, reply); return 0; } -static int32_t OnGetUserData(BufferQueueProducer* product, void *ipcMsg, IpcIo *io) +static int32_t OnGetUserData(BufferQueueProducer* product, IpcIo *io, IpcIo *reply) { size_t len = 0; - const char* key = reinterpret_cast(IpcIoPopString(io, &len)); + const char* key = reinterpret_cast(ReadString(io, &len)); if (key == nullptr || len == 0) { GRAPHIC_LOGW("Get user data key failed"); return -1; } std::string sKey = key; std::string value = product->GetUserData(sKey); - IpcIo reply; - uint8_t tmpData[DEFAULT_IPC_SIZE]; - IpcIoInit(&reply, tmpData, DEFAULT_IPC_SIZE, 0); - IpcIoPushString(&reply, value.c_str()); - SendReply(nullptr, ipcMsg, &reply); + WriteString(reply, value.c_str()); return 0; } @@ -386,20 +370,18 @@ void BufferQueueProducer::UnregisterConsumerListener() consumerListener_ = nullptr; } -int32_t BufferQueueProducer::OnIpcMsg(void *ipcMsg, IpcIo *io) +int32_t BufferQueueProducer::OnIpcMsg(uint32_t code, IpcIo *data, IpcIo *reply, MessageOption option) { - if (ipcMsg == nullptr || io == nullptr) { + if (data == NULL) { GRAPHIC_LOGW("Invalid parameter, null pointer"); return SURFACE_ERROR_INVALID_PARAM; } - uint32_t code; - (void)GetCode(ipcMsg, &code); + if (code >= MAX_REQUEST_CODE) { GRAPHIC_LOGW("Resquest code(%u) does not support.", code); - FreeBuffer(nullptr, ipcMsg); return SURFACE_ERROR_INVALID_REQUEST; } - return g_ipcMsgHandleList[code](this, ipcMsg, io); + return g_ipcMsgHandleList[code](this, data, reply); } void BufferQueueProducer::SetUserData(const std::string& key, const std::string& value) diff --git a/frameworks/buffer_queue_producer.h b/frameworks/buffer_queue_producer.h index 52b027f..5cee3ac 100644 --- a/frameworks/buffer_queue_producer.h +++ b/frameworks/buffer_queue_producer.h @@ -198,8 +198,7 @@ public: * @param [in] IpcIo pointer, ipc msg object, contains request attr... * @returns 0 is succeed; other is failed. */ - int32_t OnIpcMsg(void *ipcMsg, IpcIo *io); - + int32_t OnIpcMsg(uint32_t code, IpcIo *data, IpcIo *reply, MessageOption option); private: BufferQueue* bufferQueue_; IBufferConsumerListener* consumerListener_; diff --git a/frameworks/surface.cpp b/frameworks/surface.cpp index cb672a4..bd7c764 100644 --- a/frameworks/surface.cpp +++ b/frameworks/surface.cpp @@ -22,7 +22,7 @@ Surface* Surface::CreateSurface() SurfaceImpl* surface = new SurfaceImpl(); if (surface != nullptr) { if (surface->Init()) { - return surface; + return reinterpret_cast(surface); } else { GRAPHIC_LOGE("surface init failed"); delete surface; diff --git a/frameworks/surface_buffer_impl.cpp b/frameworks/surface_buffer_impl.cpp index 545b95f..18db45f 100644 --- a/frameworks/surface_buffer_impl.cpp +++ b/frameworks/surface_buffer_impl.cpp @@ -14,7 +14,6 @@ */ #include "surface_buffer_impl.h" - #include "securec.h" namespace OHOS { @@ -125,26 +124,31 @@ int32_t SurfaceBufferImpl::GetData(uint32_t key, uint8_t* type, void** data, uin void SurfaceBufferImpl::ReadFromIpcIo(IpcIo& io) { - bufferData_.handle.key = IpcIoPopInt32(&io); - bufferData_.handle.phyAddr = IpcIoPopUint64(&io); - bufferData_.handle.reserveFds = IpcIoPopUint32(&io); - bufferData_.handle.reserveInts = IpcIoPopUint32(&io); - bufferData_.size = IpcIoPopUint32(&io); - bufferData_.usage = IpcIoPopUint32(&io); - len_ = IpcIoPopUint32(&io); - uint32_t extDataSize = IpcIoPopUint32(&io); + ReadInt32(&io, &(bufferData_.handle.key)); + ReadUint64(&io, &(bufferData_.handle.phyAddr)); + ReadUint32(&io, &(bufferData_.handle.reserveFds)); + ReadUint32(&io, &(bufferData_.handle.reserveInts)); + ReadUint32(&io, &(bufferData_.size)); + ReadUint32(&io, &(bufferData_.usage)); + ReadUint32(&io, &len_); + uint32_t extDataSize; + ReadUint32(&io, &extDataSize); if (extDataSize > 0 && extDataSize < MAX_USER_DATA_COUNT) { for (uint32_t i = 0; i < extDataSize; i++) { - uint32_t key = IpcIoPopUint32(&io); - uint32_t type = IpcIoPopUint32(&io); + uint32_t key; + ReadUint32(&io, &key); + uint32_t type; + ReadUint32(&io, &type); switch (type) { case BUFFER_DATA_TYPE_INT_32: { - int32_t value = IpcIoPopInt32(&io); + int32_t value; + ReadInt32(&io, &value); SetInt32(key, value); break; } case BUFFER_DATA_TYPE_INT_64: { - int64_t value = IpcIoPopInt64(&io); + int64_t value; + ReadInt64(&io, &value); SetInt64(key, value); break; } @@ -156,27 +160,27 @@ void SurfaceBufferImpl::ReadFromIpcIo(IpcIo& io) } void SurfaceBufferImpl::WriteToIpcIo(IpcIo& io) { - IpcIoPushInt32(&io, bufferData_.handle.key); - IpcIoPushUint64(&io, bufferData_.handle.phyAddr); - IpcIoPushUint32(&io, bufferData_.handle.reserveFds); - IpcIoPushUint32(&io, bufferData_.handle.reserveInts); - IpcIoPushUint32(&io, bufferData_.size); - IpcIoPushUint32(&io, bufferData_.usage); - IpcIoPushUint32(&io, len_); - IpcIoPushUint32(&io, extDatas_.size()); + WriteInt32(&io, bufferData_.handle.key); + WriteUint64(&io, bufferData_.handle.phyAddr); + WriteUint32(&io, bufferData_.handle.reserveFds); + WriteUint32(&io, bufferData_.handle.reserveInts); + WriteUint32(&io, bufferData_.size); + WriteUint32(&io, bufferData_.usage); + WriteUint32(&io, len_); + WriteUint32(&io, extDatas_.size()); if (!extDatas_.empty()) { std::map::iterator iter; for (iter = extDatas_.begin(); iter != extDatas_.end(); ++iter) { uint32_t key = iter->first; ExtraData value = iter->second; - IpcIoPushUint32(&io, key); - IpcIoPushUint32(&io, value.type); + WriteUint32(&io, key); + WriteUint32(&io, value.type); switch (value.type) { case BUFFER_DATA_TYPE_INT_32: - IpcIoPushInt32(&io, *(reinterpret_cast(value.value))); + WriteInt32(&io, *(reinterpret_cast(value.value))); break; case BUFFER_DATA_TYPE_INT_64: - IpcIoPushInt64(&io, *(reinterpret_cast(value.value))); + WriteInt64(&io, *(reinterpret_cast(value.value))); break; default: break; diff --git a/frameworks/surface_impl.cpp b/frameworks/surface_impl.cpp index 3bf238c..03b8706 100644 --- a/frameworks/surface_impl.cpp +++ b/frameworks/surface_impl.cpp @@ -46,11 +46,9 @@ SurfaceImpl::~SurfaceImpl() delete producer_; producer_ = nullptr; } -#ifdef __LINUX__ if (sid_.handle != 0) { - BinderRelease(sid_.ipcContext, sid_.handle); + ReleaseSvc(sid_); } -#endif } bool SurfaceImpl::Init() @@ -85,17 +83,12 @@ bool SurfaceImpl::Init() producer_ = nullptr; return false; } - SvcIdentity svc; - int32_t ret = RegisterIpcCallback(IpcRequestHandler, 0, IPC_WAIT_FOREVER, &svc, producer_); - if (ret != LITEIPC_OK) { - GRAPHIC_LOGE("Surface RegisterIpcCallback failed."); - delete consumer_; - consumer_ = nullptr; - delete producer_; - producer_ = nullptr; - return false; - } - sid_ = svc; + objectStub_.func = IpcRequestHandler; + objectStub_.args = reinterpret_cast(producer_); + objectStub_.isRemote = false; + sid_.handle = IPC_INVALID_HANDLE; + sid_.token = SERVICE_TYPE_ANONYMOUS; + sid_.cookie = reinterpret_cast(&objectStub_); } else { producer_ = new BufferClientProducer(sid_); if (producer_ == nullptr) { @@ -260,37 +253,32 @@ void SurfaceImpl::UnregisterConsumerListener() void SurfaceImpl::WriteIoIpcIo(IpcIo& io) { - IpcIoPushSvc(&io, &sid_); + WriteRemoteObject(&io, &sid_); } -int32_t SurfaceImpl::IpcRequestHandler(const IpcContext* context, void* ipcMsg, IpcIo* io, void* arg) +int32_t SurfaceImpl::IpcRequestHandler(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option) { - BufferQueueProducer* product = reinterpret_cast(arg); - return product->OnIpcMsg(ipcMsg, io); + BufferQueueProducer* product = reinterpret_cast(option.args); + return product->OnIpcMsg(code, data, reply, option); } -int32_t SurfaceImpl::DoIpcMsg(void* ipcMsg, IpcIo* io) +int32_t SurfaceImpl::DoIpcMsg(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option) { RETURN_VAL_IF_FAIL(producer_, SURFACE_ERROR_INVALID_PARAM); - RETURN_VAL_IF_FAIL(ipcMsg != nullptr, SURFACE_ERROR_INVALID_PARAM); - RETURN_VAL_IF_FAIL(io != nullptr, SURFACE_ERROR_INVALID_PARAM); + RETURN_VAL_IF_FAIL(data != nullptr, SURFACE_ERROR_INVALID_PARAM); BufferQueueProducer* bufferQueueProducer = reinterpret_cast(producer_); - return bufferQueueProducer->OnIpcMsg(ipcMsg, io); + return bufferQueueProducer->OnIpcMsg(code, data, reply, option); } Surface* SurfaceImpl::GenericSurfaceByIpcIo(IpcIo& io) { - SvcIdentity* sid = IpcIoPopSvc(&io); - if (sid != nullptr) { - SurfaceImpl* surface = new SurfaceImpl(*sid); -#ifdef __LINUX__ - BinderAcquire(sid->ipcContext, sid->handle); - free(sid); - sid = nullptr; -#endif + SvcIdentity sid; + bool ret = ReadRemoteObject(&io, &sid); + if (ret) { + SurfaceImpl* surface = new SurfaceImpl(sid); if (surface != nullptr) { if (surface->Init()) { - return surface; + return reinterpret_cast(surface); } else { GRAPHIC_LOGE("surface init failed"); delete surface; diff --git a/interfaces/innerkits/surface_buffer_impl.h b/interfaces/innerkits/surface_buffer_impl.h index 037a886..81ae783 100644 --- a/interfaces/innerkits/surface_buffer_impl.h +++ b/interfaces/innerkits/surface_buffer_impl.h @@ -17,9 +17,9 @@ #define GRAPHIC_LITE_SURFACE_BUFFER_IMPL_H #include +#include #include "buffer_common.h" -#include "liteipc_adapter.h" -#include "serializer.h" +#include "ipc_skeleton.h" #include "surface_buffer.h" namespace OHOS { diff --git a/interfaces/innerkits/surface_impl.h b/interfaces/innerkits/surface_impl.h index 985447f..ea1aa59 100644 --- a/interfaces/innerkits/surface_impl.h +++ b/interfaces/innerkits/surface_impl.h @@ -216,7 +216,7 @@ public: * @param [in] IpcIo pointer, ipc msg object, constains request attr... * @returns 0 is succeed; other is failed. */ - int32_t DoIpcMsg(void* ipcMsg, IpcIo* io); + int32_t DoIpcMsg(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option); /** * @brief Surface init succeed or not @@ -230,9 +230,10 @@ private: * @param [in] SvcIdentity. Consumer sid, ipc sending request param. * @returns Surface pointer. */ - explicit SurfaceImpl(const SvcIdentity& sid); - static int32_t IpcRequestHandler(const IpcContext* context, void* ipcMsg, IpcIo* io, void* arg); + SurfaceImpl(const SvcIdentity& sid); + static int32_t IpcRequestHandler(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option); SvcIdentity sid_; + IpcObjectStub objectStub_; BufferQueueConsumer* consumer_; BufferProducer* producer_; bool IsConsumer_; diff --git a/test/BUILD.gn b/test/BUILD.gn index 5893dde..7f80a76 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -23,7 +23,7 @@ if (ohos_build_type == "debug") { output_dir = "$root_out_dir/test/unittest/graphic" sources = [ "unittest/graphic_surface_test.cpp" ] deps = [ - "//foundation/communication/ipc_lite:liteipc_adapter", + "//foundation/communication/ipc/interfaces/innerkits/c/ipc:ipc_single", "//foundation/graphic/surface:surface", ] }