From c65787176a9116216de5e999b02f96fd3da89f85 Mon Sep 17 00:00:00 2001 From: xinking129 Date: Tue, 28 Nov 2023 09:26:01 +0800 Subject: [PATCH] =?UTF-8?q?emitter=E8=83=BD=E5=8A=9B=E5=A2=9E=E5=BC=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xinking129 --- .../include/event_handler_utils.h | 17 +- frameworks/eventhandler/src/event_handler.cpp | 7 +- frameworks/eventhandler/src/event_queue.cpp | 17 +- frameworks/eventhandler/src/event_runner.cpp | 15 +- frameworks/eventhandler/src/inner_event.cpp | 26 +- frameworks/napi/src/events_emitter.cpp | 276 +++++++++++++++--- interfaces/inner_api/event_queue.h | 5 +- interfaces/inner_api/inner_event.h | 173 ++++++++++- 8 files changed, 476 insertions(+), 60 deletions(-) diff --git a/frameworks/eventhandler/include/event_handler_utils.h b/frameworks/eventhandler/include/event_handler_utils.h index e5a97f2..446f402 100644 --- a/frameworks/eventhandler/include/event_handler_utils.h +++ b/frameworks/eventhandler/include/event_handler_utils.h @@ -70,11 +70,26 @@ static inline bool AllowHiTraceOutPut(const std::shared_ptr& traceId, return true; } +static inline void HiTracePointerOutPutEventId(const std::shared_ptr &spanId, const char *action, + HiTraceTracepointType type, const InnerEvent::EventId &innerEventId) +{ + if (spanId == nullptr || action == nullptr) { + return; + } + if (innerEventId.index() == TYPE_U32_INDEX) { + HiTraceChain::Tracepoint(type, *spanId, "%s event, event id: %u", action, std::get(innerEventId)); + } else { + HiTraceChain::Tracepoint( + type, *spanId, "%s event, event id: %s", action, std::get(innerEventId).c_str()); + } +} + static inline void HiTracePointerOutPut(const std::shared_ptr& spanId, const InnerEvent::Pointer& event, const char* action, HiTraceTracepointType type) { if (!event->HasTask()) { - HiTraceChain::Tracepoint(type, *spanId, "%s event, event id: %d", action, event->GetInnerEventId()); + auto eventId = event->GetInnerEventIdEx(); + HiTracePointerOutPutEventId(spanId, action, type, eventId); } else if (!event->GetTaskName().empty()) { HiTraceChain::Tracepoint(type, *spanId, "%s task with name, name: %s", action, event->GetTaskName().c_str()); } else { diff --git a/frameworks/eventhandler/src/event_handler.cpp b/frameworks/eventhandler/src/event_handler.cpp index 412a4fa..3da688e 100644 --- a/frameworks/eventhandler/src/event_handler.cpp +++ b/frameworks/eventhandler/src/event_handler.cpp @@ -400,7 +400,12 @@ std::string EventHandler::GetEventName(const InnerEvent::Pointer &event) if (event->HasTask()) { eventName = event->GetTaskName(); } else { - eventName = std::to_string(event->GetInnerEventId()); + InnerEvent::EventId eventId = event->GetInnerEventIdEx(); + if (eventId.index() == TYPE_U32_INDEX) { + eventName = std::to_string(std::get(eventId)); + } else { + eventName = std::get(eventId); + } } return eventName; } diff --git a/frameworks/eventhandler/src/event_queue.cpp b/frameworks/eventhandler/src/event_queue.cpp index 7e638f2..a73953c 100644 --- a/frameworks/eventhandler/src/event_queue.cpp +++ b/frameworks/eventhandler/src/event_queue.cpp @@ -579,6 +579,15 @@ bool EventQueue::EnsureIoWaiterSupportListerningFileDescriptorLocked() return true; } +void EventQueue::DumpCurrentRunningEventId(const InnerEvent::EventId &innerEventId, std::string &content) +{ + if (innerEventId.index() == TYPE_U32_INDEX) { + content.append(", id = " + std::to_string(std::get(innerEventId))); + } else { + content.append(", id = " + std::get(innerEventId)); + } +} + std::string EventQueue::DumpCurrentRunning() { std::string content; @@ -594,7 +603,7 @@ std::string EventQueue::DumpCurrentRunning() if (currentRunningEvent_.hasTask_) { content.append(", task name = " + currentRunningEvent_.taskName_); } else { - content.append(", id = " + std::to_string(currentRunningEvent_.innerEventId_)); + DumpCurrentRunningEventId(currentRunningEvent_.innerEventId_, content); } if (currentRunningEvent_.param_ != 0) { content.append(", param = " + std::to_string(currentRunningEvent_.param_)); @@ -722,7 +731,7 @@ void EventQueue::PushHistoryQueueBeforeDistribute(const InnerEvent::Pointer &eve historyEvents_[historyEventIndex_].hasTask = true; historyEvents_[historyEventIndex_].taskName = event->GetTaskName(); } else { - historyEvents_[historyEventIndex_].innerEventId = event->GetInnerEventId(); + historyEvents_[historyEventIndex_].innerEventId = event->GetInnerEventIdEx(); } } @@ -746,7 +755,7 @@ std::string EventQueue::HistoryQueueDump(const HistoryEvent &historyEvent) if (historyEvent.hasTask) { content.append(", task name = " + historyEvent.taskName); } else { - content.append(", id = " + std::to_string(historyEvent.innerEventId)); + DumpCurrentRunningEventId(historyEvent.innerEventId, content); } content.append(" }" + LINE_SEPARATOR); @@ -770,7 +779,7 @@ CurrentRunningEvent::CurrentRunningEvent(InnerEvent::TimePoint time, InnerEvent: hasTask_ = true; taskName_ = event->GetTaskName(); } else { - innerEventId_ = event->GetInnerEventId(); + innerEventId_ = event->GetInnerEventIdEx(); } } diff --git a/frameworks/eventhandler/src/event_runner.cpp b/frameworks/eventhandler/src/event_runner.cpp index 2244c19..dacbd72 100644 --- a/frameworks/eventhandler/src/event_runner.cpp +++ b/frameworks/eventhandler/src/event_runner.cpp @@ -350,7 +350,13 @@ public: std::shared_ptr logging = logger_; if (logging != nullptr) { if (!event->HasTask()) { - logging->Log("Dispatching to handler event id = " + std::to_string(event->GetInnerEventId())); + InnerEvent::EventId eventId = event->GetInnerEventIdEx(); + if (eventId.index() == TYPE_U32_INDEX) { + logging->Log( + "Dispatching to handler event id = " + std::to_string(std::get(eventId))); + } else { + logging->Log("Dispatching to handler event id = " + std::get(eventId)); + } } else { logging->Log("Dispatching to handler event task name = " + event->GetTaskName()); } @@ -407,7 +413,12 @@ private: if (event->HasTask()) { g_currentEventName = event->GetTaskName(); } else { - g_currentEventName = std::to_string(event->GetInnerEventId()); + InnerEvent::EventId eventId = event->GetInnerEventIdEx(); + if (eventId.index() == TYPE_U32_INDEX) { + g_currentEventName = std::to_string(std::get(eventId)); + } else { + g_currentEventName = std::get(eventId); + } } } diff --git a/frameworks/eventhandler/src/inner_event.cpp b/frameworks/eventhandler/src/inner_event.cpp index 5b1c746..2b22ebc 100644 --- a/frameworks/eventhandler/src/inner_event.cpp +++ b/frameworks/eventhandler/src/inner_event.cpp @@ -179,6 +179,26 @@ InnerEvent::Pointer InnerEvent::Get(uint32_t innerEventId, int64_t param, const return event; } +InnerEvent::Pointer InnerEvent::Get(const EventId &innerEventId, int64_t param, const Caller &caller) +{ + auto event = InnerEventPool::GetInstance().Get(); + if (event != nullptr) { + event->innerEventId_ = innerEventId; + event->param_ = param; + event->caller_ = caller; + if (innerEventId.index() == TYPE_U32_INDEX) { + HILOGD("innerEventId is %{public}u, caller is %{public}s", + std::get(innerEventId), + caller.ToString().c_str()); + } else { + HILOGD("innerEventId is %{public}s, caller is %{public}s", + std::get(innerEventId).c_str(), + caller.ToString().c_str()); + } + } + return event; +} + InnerEvent::Pointer InnerEvent::Get(const Callback &callback, const std::string &name, const Caller &caller) { // Returns nullptr while callback is invalid. @@ -299,7 +319,11 @@ std::string InnerEvent::Dump() if (HasTask()) { content.append(", task name = " + taskName_); } else { - content.append(", id = " + std::to_string(innerEventId_)); + if (innerEventId_.index() == TYPE_U32_INDEX) { + content.append(", id = " + std::to_string(std::get(innerEventId_))); + } else { + content.append(", id = " + std::get(innerEventId_)); + } } if (param_ != 0) { content.append(", param = " + std::to_string(param_)); diff --git a/frameworks/napi/src/events_emitter.cpp b/frameworks/napi/src/events_emitter.cpp index 0207056..0cf1ba1 100644 --- a/frameworks/napi/src/events_emitter.cpp +++ b/frameworks/napi/src/events_emitter.cpp @@ -24,9 +24,10 @@ namespace OHOS { namespace AppExecFwk { namespace { DEFINE_EH_HILOG_LABEL("EventsEmitter"); + constexpr static uint32_t ARGC_ONE = 1u; } static std::mutex emitterInsMutex; - static map> emitterInstances; + static map> emitterInstances; std::shared_ptr eventHandler; EventHandlerInstance::EventHandlerInstance(const std::shared_ptr& runner): EventHandler(runner) { @@ -38,7 +39,7 @@ namespace { } std::shared_ptr EventHandlerInstance::GetInstance() { - static auto runner = EventRunner::Create("OS_eventsEmtr"); + static auto runner = EventRunner::Create("events_emitter"); if (runner.get() == nullptr) { HILOGE("failed to create EventRunner events_emitter"); return nullptr; @@ -112,10 +113,19 @@ namespace { callbackInner->processed = true; } + void OutPutEventIdLog(const InnerEvent::EventId &eventId) + { + if (eventId.index() == TYPE_U32_INDEX) { + HILOGD("Event id value:%{public}u", std::get(eventId)); + } else { + HILOGD("Event id value:%{public}s", std::get(eventId).c_str()); + } + } + void EventHandlerInstance::ProcessEvent([[maybe_unused]] const InnerEvent::Pointer& event) { - uint32_t eventId = event->GetInnerEventId(); - HILOGD("eventId = %{public}d", eventId); + InnerEvent::EventId eventId = event->GetInnerEventIdEx(); + OutPutEventIdLog(eventId); std::lock_guard lock(emitterInsMutex); auto subscribe = emitterInstances.find(eventId); if (subscribe == emitterInstances.end()) { @@ -199,7 +209,7 @@ namespace { } } - AsyncCallbackInfo* SearchCallbackInfo(napi_env env, uint32_t eventIdValue, napi_value argv) + AsyncCallbackInfo *SearchCallbackInfo(napi_env env, const InnerEvent::EventId &eventIdValue, napi_value argv) { auto subscribe = emitterInstances.find(eventIdValue); if (subscribe == emitterInstances.end()) { @@ -224,6 +234,40 @@ namespace { return nullptr; } + bool GetEventIdWithObjectOrString( + napi_env env, napi_value argv, napi_valuetype eventValueType, InnerEvent::EventId &eventId) + { + if (eventValueType == napi_string) { + size_t valueStrBufLength = 0; + napi_get_value_string_utf8(env, argv, nullptr, NAPI_VALUE_STRING_LEN, &valueStrBufLength); + auto valueCStr = std::make_unique(NAPI_VALUE_STRING_LEN + 1); + size_t valueStrLength = 0; + napi_get_value_string_utf8(env, argv, valueCStr.get(), NAPI_VALUE_STRING_LEN, &valueStrLength); + std::string id(valueCStr.get(), valueStrLength); + if (id.empty()) { + HILOGE("Event id is empty for argument 1."); + return false; + } + eventId = id; + HILOGD("Event id value:%{public}s", id.c_str()); + } else { + bool hasEventId = false; + napi_has_named_property(env, argv, "eventId", &hasEventId); + if (!hasEventId) { + HILOGE("Argument 1 does not have event id."); + return false; + } + + napi_value eventIdValue = nullptr; + napi_get_named_property(env, argv, "eventId", &eventIdValue); + uint32_t id = 0u; + napi_get_value_uint32(env, eventIdValue, &id); + eventId = id; + HILOGD("Event id value:%{public}u", id); + } + return true; + } + napi_value OnOrOnce(napi_env env, napi_callback_info cbinfo, bool once) { size_t argc = ARGC_NUM; @@ -236,7 +280,7 @@ namespace { napi_valuetype eventValueType; napi_typeof(env, argv[0], &eventValueType); - if (eventValueType != napi_object) { + if (eventValueType != napi_object && eventValueType != napi_string) { HILOGE("type mismatch for parameter 1"); return nullptr; } @@ -248,18 +292,11 @@ namespace { return nullptr; } - bool hasEventId = false; - napi_value eventId; - napi_has_named_property(env, argv[0], "eventId", &hasEventId); - if (hasEventId == false) { - HILOGE("Wrong argument 1"); + InnerEvent::EventId eventIdValue = 0u; + bool ret = GetEventIdWithObjectOrString(env, argv[0], eventValueType, eventIdValue); + if (!ret) { return nullptr; } - - napi_get_named_property(env, argv[0], "eventId", &eventId); - uint32_t eventIdValue; - napi_get_value_uint32(env, eventId, &eventIdValue); - HILOGD("OnOrOnce eventIdValue:%{public}d", eventIdValue); std::lock_guard lock(emitterInsMutex); auto callbackInfo = SearchCallbackInfo(env, eventIdValue, argv[1]); if (callbackInfo != nullptr) { @@ -278,6 +315,30 @@ namespace { return nullptr; } + bool GetEventIdWithNumberOrString( + napi_env env, napi_value argv, napi_valuetype eventValueType, InnerEvent::EventId &eventId) + { + if (eventValueType == napi_string) { + size_t valueStrBufLength = 0; + napi_get_value_string_utf8(env, argv, nullptr, NAPI_VALUE_STRING_LEN, &valueStrBufLength); + auto valueCStr = std::make_unique(NAPI_VALUE_STRING_LEN + 1); + size_t valueStrLength = 0; + napi_get_value_string_utf8(env, argv, valueCStr.get(), NAPI_VALUE_STRING_LEN, &valueStrLength); + std::string id(valueCStr.get(), valueStrLength); + if (id.empty()) { + return false; + } + eventId = id; + HILOGD("Event id value:%{public}s", id.c_str()); + } else { + uint32_t id = 0u; + napi_get_value_uint32(env, argv, &id); + eventId = id; + HILOGD("Event id value:%{public}u", id); + } + return true; + } + napi_value JS_On(napi_env env, napi_callback_info cbinfo) { HILOGD("enter"); @@ -303,13 +364,17 @@ namespace { napi_valuetype eventValueType; napi_typeof(env, argv[0], &eventValueType); - if (eventValueType != napi_number) { + if (eventValueType != napi_number && eventValueType != napi_string) { HILOGE("type mismatch for parameter 1"); return nullptr; } - uint32_t eventId; - napi_get_value_uint32(env, argv[0], &eventId); + InnerEvent::EventId eventId = 0u; + bool ret = GetEventIdWithNumberOrString(env, argv[0], eventValueType, eventId); + if (!ret) { + HILOGE("Event id is empty for parameter 1."); + return nullptr; + } std::lock_guard lock(emitterInsMutex); if (argc == ARGC_NUM) { @@ -369,7 +434,7 @@ namespace { return true; } - bool EmitWithEventData(napi_env env, napi_value argv, uint32_t eventId, Priority priority) + bool EmitWithEventData(napi_env env, napi_value argv, const InnerEvent::EventId &eventId, Priority priority) { HILOGD("enter"); napi_valuetype dataType; @@ -418,7 +483,7 @@ namespace { } if (hasEventData) { - HILOGD("sendevent with eventData id:%{public}d", eventId); + OutPutEventIdLog(eventId); auto event = InnerEvent::Get(eventId, make_unique(eventData)); eventHandler->SendEvent(event, 0, priority); return true; @@ -427,7 +492,7 @@ namespace { return false; } - bool IsExistValidCallback(napi_env env, uint32_t eventId) + bool IsExistValidCallback(napi_env env, const InnerEvent::EventId &eventId) { std::lock_guard lock(emitterInsMutex); auto subscribe = emitterInstances.find(eventId); @@ -445,39 +510,25 @@ namespace { return false; } - napi_value JS_Emit(napi_env env, napi_callback_info cbinfo) + napi_value EmitWithEventIdUint32(napi_env env, size_t argc, napi_value argv[]) { - HILOGD("enter"); - size_t argc = ARGC_NUM; - napi_value argv[ARGC_NUM] = {0}; - NAPI_CALL(env, napi_get_cb_info(env, cbinfo, &argc, argv, NULL, NULL)); - if (argc < 1) { - HILOGE("requires more than 1 parameter"); - return nullptr; - } - - napi_valuetype eventValueType; - napi_typeof(env, argv[0], &eventValueType); - if (eventValueType != napi_object) { - HILOGE("type mismatch for parameter 1"); - return nullptr; - } - + InnerEvent::EventId eventId = 0u; bool hasEventId = false; - napi_value value; + napi_value value = nullptr; napi_has_named_property(env, argv[0], "eventId", &hasEventId); if (hasEventId == false) { - HILOGE("Wrong argument 1"); + HILOGE("Wrong argument 1 does not have event id."); return nullptr; } napi_get_named_property(env, argv[0], "eventId", &value); - uint32_t eventId; - napi_get_value_uint32(env, value, &eventId); - HILOGD("JS_Emit eventIdValue:%{public}d", eventId); + uint32_t id = 0u; + napi_get_value_uint32(env, value, &id); + eventId = id; + HILOGD("Event id value:%{public}u", id); if (!IsExistValidCallback(env, eventId)) { - HILOGE("JS_Emit has no valid callback"); + HILOGE("Invalid callback"); return nullptr; } @@ -486,20 +537,97 @@ namespace { Priority priority = Priority::LOW; if (hasPriority) { napi_get_named_property(env, argv[0], "priority", &value); - uint32_t priorityValue; + uint32_t priorityValue = 0u; napi_get_value_uint32(env, value, &priorityValue); - HILOGD("JS_Emit priority:%{public}d", priorityValue); + HILOGD("Event priority:%{public}d", priorityValue); priority = static_cast(priorityValue); } if (argc == ARGC_NUM && EmitWithEventData(env, argv[1], eventId, priority)) { return nullptr; } else { - HILOGD("JS_Emit sendevent without id:%{public}d", eventId); auto event = InnerEvent::Get(eventId, make_unique()); eventHandler->SendEvent(event, 0, priority); + } + return nullptr; + } + + napi_value EmitWithEventIdString(napi_env env, size_t argc, napi_value argv[]) + { + InnerEvent::EventId eventId = 0u; + size_t valueStrBufLength = 0; + napi_get_value_string_utf8(env, argv[0], nullptr, NAPI_VALUE_STRING_LEN, &valueStrBufLength); + auto valueCStr = std::make_unique(NAPI_VALUE_STRING_LEN + 1); + size_t valueStrLength = 0; + napi_get_value_string_utf8(env, argv[0], valueCStr.get(), NAPI_VALUE_STRING_LEN, &valueStrLength); + std::string id(valueCStr.get(), valueStrLength); + if (id.empty()) { + HILOGE("Invalid event id:%{public}s", id.c_str()); return nullptr; } + eventId = id; + HILOGD("Event id value:%{public}s", id.c_str()); + + if (!IsExistValidCallback(env, eventId)) { + HILOGE("Invalid callback"); + return nullptr; + } + + Priority priority = Priority::LOW; + if (argc < ARGC_NUM) { + auto event = InnerEvent::Get(eventId, make_unique()); + eventHandler->SendEvent(event, 0, priority); + return nullptr; + } + + bool hasPriority = false; + napi_value value = nullptr; + napi_has_named_property(env, argv[1], "priority", &hasPriority); + if (!hasPriority) { + if (!EmitWithEventData(env, argv[1], eventId, priority)) { + auto event = InnerEvent::Get(eventId, make_unique()); + eventHandler->SendEvent(event, 0, priority); + } + return nullptr; + } + + napi_get_named_property(env, argv[1], "priority", &value); + uint32_t priorityValue = 0u; + napi_get_value_uint32(env, value, &priorityValue); + HILOGD("Event priority:%{public}d", priorityValue); + priority = static_cast(priorityValue); + + if (argc > ARGC_NUM && EmitWithEventData(env, argv[ARGC_NUM], eventId, priority)) { + return nullptr; + } else { + auto event = InnerEvent::Get(eventId, make_unique()); + eventHandler->SendEvent(event, 0, priority); + } + return nullptr; + } + + napi_value JS_Emit(napi_env env, napi_callback_info cbinfo) + { + HILOGD("enter"); + size_t argc = ARGC_NUM + ARGC_ONE; + napi_value argv[ARGC_NUM + ARGC_ONE] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, cbinfo, &argc, argv, NULL, NULL)); + if (argc < ARGC_ONE) { + HILOGE("Requires more than 1 parameter"); + return nullptr; + } + + napi_valuetype eventValueType; + napi_typeof(env, argv[0], &eventValueType); + if (eventValueType != napi_object && eventValueType != napi_string) { + HILOGE("Type mismatch for parameter 1"); + return nullptr; + } + + if (eventValueType == napi_string) { + return EmitWithEventIdString(env, argc, argv); + } + return EmitWithEventIdUint32(env, argc, argv); } napi_value EnumEventClassConstructor(napi_env env, napi_callback_info info) @@ -542,6 +670,57 @@ namespace { return exports; } + napi_value CreateJsUndefined(napi_env env) + { + napi_value result = nullptr; + napi_get_undefined(env, &result); + return result; + } + + napi_value CreateJsNumber(napi_env env, uint32_t value) + { + napi_value result = nullptr; + napi_create_uint32(env, value, &result); + return result; + } + + napi_value JS_GetListenerCount(napi_env env, napi_callback_info cbinfo) + { + HILOGD("enter"); + size_t argc = ARGC_NUM; + napi_value argv[ARGC_NUM] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, cbinfo, &argc, argv, NULL, NULL)); + if (argc < ARGC_ONE) { + HILOGE("Requires more than 1 parameter"); + return CreateJsUndefined(env); + } + + napi_valuetype eventValueType; + napi_typeof(env, argv[0], &eventValueType); + if (eventValueType != napi_number && eventValueType != napi_string) { + HILOGE("Type mismatch for parameter 1"); + return CreateJsUndefined(env); + } + + uint32_t cnt = 0u; + InnerEvent::EventId eventId = 0u; + bool ret = GetEventIdWithNumberOrString(env, argv[0], eventValueType, eventId); + if (!ret) { + HILOGE("Event id is empty for parameter 1."); + return CreateJsUndefined(env); + } + std::lock_guard lock(emitterInsMutex); + auto subscribe = emitterInstances.find(eventId); + if (subscribe != emitterInstances.end()) { + for (auto callbackInfo : subscribe->second) { + if (!callbackInfo->isDeleted) { + ++cnt; + } + } + } + return CreateJsNumber(env, cnt); + } + napi_value EmitterInit(napi_env env, napi_value exports) { HILOGD("enter"); @@ -550,6 +729,7 @@ namespace { DECLARE_NAPI_FUNCTION("once", JS_Once), DECLARE_NAPI_FUNCTION("off", JS_Off), DECLARE_NAPI_FUNCTION("emit", JS_Emit), + DECLARE_NAPI_FUNCTION("getListenerCount", JS_GetListenerCount), }; NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); diff --git a/interfaces/inner_api/event_queue.h b/interfaces/inner_api/event_queue.h index 176072d..bf31394 100644 --- a/interfaces/inner_api/event_queue.h +++ b/interfaces/inner_api/event_queue.h @@ -40,7 +40,7 @@ struct CurrentRunningEvent { int64_t param_{0}; bool hasTask_{false}; std::string taskName_; - uint32_t innerEventId_{0}; + InnerEvent::EventId innerEventId_ = 0u; CurrentRunningEvent(); CurrentRunningEvent(InnerEvent::TimePoint time, InnerEvent::Pointer &event); }; @@ -232,7 +232,7 @@ private: struct HistoryEvent { uint64_t senderKernelThreadId{0}; std::string taskName; - uint32_t innerEventId{0}; + InnerEvent::EventId innerEventId = 0u; bool hasTask{false}; InnerEvent::TimePoint sendTime; InnerEvent::TimePoint handleTime; @@ -264,6 +264,7 @@ private: bool EnsureIoWaiterSupportListerningFileDescriptorLocked(); std::string HistoryQueueDump(const HistoryEvent &historyEvent); std::string DumpCurrentRunning(); + void DumpCurrentRunningEventId(const InnerEvent::EventId &innerEventId, std::string &content); std::mutex queueLock_; std::atomic_bool usable_ {true}; diff --git a/interfaces/inner_api/inner_event.h b/interfaces/inner_api/inner_event.h index b8814e9..b12ef2f 100644 --- a/interfaces/inner_api/inner_event.h +++ b/interfaces/inner_api/inner_event.h @@ -22,6 +22,7 @@ #include #include #include +#include #include "nocopyable.h" @@ -31,6 +32,7 @@ class HiTraceId; } namespace AppExecFwk { +constexpr static uint32_t TYPE_U32_INDEX = 0u; using HiTraceId = OHOS::HiviewDFX::HiTraceId; class EventHandler; @@ -68,6 +70,7 @@ public: using TimePoint = std::chrono::time_point; using Callback = std::function; using Pointer = std::unique_ptr; + using EventId = std::variant; class Waiter { public: Waiter() = default; @@ -90,6 +93,16 @@ public: */ static Pointer Get(uint32_t innerEventId, int64_t param = 0, const Caller &caller = {}); + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param param Basic parameter of the event, default is 0. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + static Pointer Get(const EventId &innerEventId, int64_t param = 0, const Caller &caller = {}); + /** * Get InnerEvent instance from pool. * @@ -108,6 +121,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param object Shared pointer of the object. + * @param param Basic parameter of the event, default is 0. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, const std::shared_ptr &object, + int64_t param = 0, const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveSharedPtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -126,6 +157,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param object Weak pointer of the object. + * @param param Basic parameter of the event, default is 0. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, const std::weak_ptr &object, + int64_t param = 0, const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveSharedPtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -144,6 +193,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param object Unique pointer of the object. + * @param param Basic parameter of the event, default is 0. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, std::unique_ptr &&object, + int64_t param = 0, const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveUniquePtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -162,6 +229,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param object Unique pointer of the object. + * @param param Basic parameter of the event, default is 0. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, std::unique_ptr &object, + int64_t param = 0, const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveUniquePtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -180,6 +265,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param param Basic parameter of the event. + * @param object Shared pointer of the object. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, int64_t param, const std::shared_ptr &object, + const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveSharedPtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -198,6 +301,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param param Basic parameter of the event. + * @param object Weak pointer of the object. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, int64_t param, const std::weak_ptr &object, + const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveSharedPtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -216,6 +337,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param param Basic parameter of the event. + * @param object Unique pointer of the object. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, int64_t param, std::unique_ptr &&object, + const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveUniquePtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -234,6 +373,24 @@ public: return event; } + /** + * Get InnerEvent instance from pool. + * + * @param innerEventId The id of the event. + * @param param Basic parameter of the event. + * @param object Unique pointer of the object. + * @param caller Caller info of the event, default is caller's file, func and line. + * @return Returns the pointer of InnerEvent instance. + */ + template + static inline Pointer Get(const EventId &innerEventId, int64_t param, std::unique_ptr &object, + const Caller &caller = {}) + { + auto event = Get(innerEventId, param, caller); + event->SaveUniquePtr(object); + return event; + } + /** * Get InnerEvent instance from pool. * @@ -339,6 +496,20 @@ public: * @return Returns id of the event after it has been sent. */ inline uint32_t GetInnerEventId() const + { + if (innerEventId_.index() != TYPE_U32_INDEX) { + return 0u; + } + return std::get(innerEventId_); + } + + /** + * Get id of the event. + * Make sure {@link #hasTask} returns false. + * + * @return Returns id of the event after it has been sent. + */ + inline EventId GetInnerEventIdEx() const { return innerEventId_; } @@ -592,7 +763,7 @@ private: uint64_t senderKernelThreadId_{0}; // Event id of the event, if it is not a task object - uint32_t innerEventId_{0}; + EventId innerEventId_ = 0u; // Simple parameter for the event. int64_t param_{0}; -- Gitee