diff --git a/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeoninputbufferavailable_fuzzer/decodeoninputbufferavailable_fuzzer.cpp b/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeoninputbufferavailable_fuzzer/decodeoninputbufferavailable_fuzzer.cpp index e5094bff608f07154ecae5118f475c33d79209d7..ebeb9c00a196548e55da8af608a33f3952b235c5 100644 --- a/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeoninputbufferavailable_fuzzer/decodeoninputbufferavailable_fuzzer.cpp +++ b/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeoninputbufferavailable_fuzzer/decodeoninputbufferavailable_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -27,9 +27,11 @@ void DecodeOnInputBufferAvailableFuzzTest(const uint8_t* data, size_t size) uint32_t index = *(reinterpret_cast(data)); std::shared_ptr sourcePipeline = std::make_shared(); - std::shared_ptr eventBusPipeline = nullptr; + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + std::shared_ptr pipeEventHandler = + std::make_shared(runner, sourcePipeline); std::shared_ptr decodeDataProcess = - std::make_shared(eventBusPipeline, sourcePipeline); + std::make_shared(pipeEventHandler, sourcePipeline); std::shared_ptr decodeVideoCallback = std::make_shared(decodeDataProcess); std::shared_ptr buffer = nullptr; decodeVideoCallback->OnInputBufferAvailable(index, buffer); diff --git a/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeonoutputbufferavailable_fuzzer/decodeonoutputbufferavailable_fuzzer.cpp b/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeonoutputbufferavailable_fuzzer/decodeonoutputbufferavailable_fuzzer.cpp index b4d6339b0cbf04666d6874a6af7908c4bda2a473..2bfa77aab76fb6702dc92cec3c9c9df9dedfd166 100644 --- a/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeonoutputbufferavailable_fuzzer/decodeonoutputbufferavailable_fuzzer.cpp +++ b/interfaces/inner_kits/native_cpp/test/sourcefuzztest/decodeonoutputbufferavailable_fuzzer/decodeonoutputbufferavailable_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -33,9 +33,11 @@ void DecodeOnOutputBufferAvailableFuzzTest(const uint8_t* data, size_t size) MediaAVCodec::AVCodecBufferInfo info = { presentTimeUs, infoSize, offset}; MediaAVCodec::AVCodecBufferFlag flag = static_cast(bufferFlag); std::shared_ptr sourcePipeline = std::make_shared(); - std::shared_ptr eventBusPipeline = nullptr; + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + std::shared_ptr pipeEventHandler = + std::make_shared(runner, sourcePipeline); std::shared_ptr decodeDataProcess = - std::make_shared(eventBusPipeline, sourcePipeline); + std::make_shared(pipeEventHandler, sourcePipeline); std::shared_ptr decodeVideoCallback = std::make_shared(decodeDataProcess); std::shared_ptr buffer = nullptr; diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h index 9a52710b77c4f9a994124dfacaf9885d514c0709..ab015bf24bfa7a96be02719f0b5b8b4a2f11892b 100644 --- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h +++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h @@ -16,9 +16,7 @@ #ifndef OHOS_DCAMERA_SINK_CONTROLLER_H #define OHOS_DCAMERA_SINK_CONTROLLER_H -#include "eventbus/event_bus.h" -#include "dcamera_frame_trigger_event.h" -#include "dcamera_post_authorization_event.h" +#include "event_handler.h" #include "icamera_controller.h" #include "icamera_channel.h" @@ -34,10 +32,9 @@ namespace OHOS { namespace DistributedHardware { -class DCameraSinkController : public ICameraController, public EventSender, - public DistributedHardware::EventBusHandler, - public DistributedHardware::EventBusHandler, - public std::enable_shared_from_this { +constexpr uint32_t EVENT_FRAME_TRIGGER = 1; +constexpr uint32_t EVENT_AUTHORIZATION = 2; +class DCameraSinkController : public ICameraController, public std::enable_shared_from_this { public: explicit DCameraSinkController(std::shared_ptr& accessControl, const sptr &sinkCallback); @@ -57,9 +54,6 @@ public: int32_t ResumeDistributedHardware(const std::string &networkId) override; int32_t StopDistributedHardware(const std::string &networkId) override; - void OnEvent(DCameraFrameTriggerEvent& event) override; - void OnEvent(DCameraPostAuthorizationEvent& event) override; - void OnStateChanged(std::shared_ptr& event); void OnMetadataResult(std::vector>& settings); @@ -67,6 +61,16 @@ public: void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail); void OnDataReceived(std::vector>& buffers); + class DCameraSinkContrEventHandler : public AppExecFwk::EventHandler { + public: + DCameraSinkContrEventHandler(const std::shared_ptr &runner, + std::shared_ptr sinkContrPtr); + ~DCameraSinkContrEventHandler() override = default; + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + private: + std::weak_ptr sinkContrWPtr_; + }; + private: int32_t StartCaptureInner(std::vector>& captureInfos); int32_t DCameraNotifyInner(int32_t type, int32_t result, std::string content); @@ -77,6 +81,8 @@ private: std::string GetUdidByNetworkId(const std::string &networkId); int32_t PullUpPage(); bool CheckPermission(); + void ProcessFrameTrigger(const AppExecFwk::InnerEvent::Pointer &event); + void ProcessPostAuthorization(const AppExecFwk::InnerEvent::Pointer &event); bool isInit_; int32_t sessionState_; @@ -85,7 +91,7 @@ private: std::mutex channelLock_; std::string dhId_; std::string srcDevId_; - std::shared_ptr eventBus_; + std::shared_ptr sinkCotrEventHandler_; std::shared_ptr channel_; std::shared_ptr operator_; std::shared_ptr accessControl_; diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp index 8e524a2878842a22f810751278762e805bb8fb9e..9debead87453ccaaf532db1ac8d282b062b8a91f 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -72,11 +72,16 @@ int32_t DCameraSinkController::StartCapture(std::vectorPostEvent(triggerEvent, POSTMODE::POST_ASYNC); - eventBus_->PostEvent(authEvent, POSTMODE::POST_ASYNC); + std::shared_ptr param = std::make_shared(""); + std::shared_ptr>> infos = + std::make_shared>>(captureInfos); + CHECK_NULL_RETURN(sinkCotrEventHandler_, DCAMERA_BAD_VALUE); + AppExecFwk::InnerEvent::Pointer triggerEvent = + AppExecFwk::InnerEvent::Get(EVENT_FRAME_TRIGGER, param, 0); + AppExecFwk::InnerEvent::Pointer authorizationEvent = + AppExecFwk::InnerEvent::Get(EVENT_AUTHORIZATION, infos, 0); + sinkCotrEventHandler_->SendEvent(triggerEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); + sinkCotrEventHandler_->SendEvent(authorizationEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); } return DCAMERA_OK; } @@ -320,12 +325,9 @@ int32_t DCameraSinkController::Init(std::vector& indexs) } channel_ = std::make_shared(); - eventBus_ = std::make_shared("SinkCtlHandler"); - DCameraFrameTriggerEvent triggerEvent(*this); - DCameraPostAuthorizationEvent authEvent(*this); - eventBus_->AddHandler(triggerEvent.GetType(), *this); - eventBus_->AddHandler(authEvent.GetType(), *this); - + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + sinkCotrEventHandler_ = + std::make_shared(runner, shared_from_this()); isInit_ = true; initCallback_ = std::make_shared(); DHLOGI("DCameraSinkController Init %{public}s success", GetAnonyString(dhId_).c_str()); @@ -369,16 +371,48 @@ int32_t DCameraSinkController::UnInit() return DCAMERA_OK; } -void DCameraSinkController::OnEvent(DCameraFrameTriggerEvent& event) +DCameraSinkController::DCameraSinkContrEventHandler::DCameraSinkContrEventHandler( + const std::shared_ptr &runner, std::shared_ptr sinkContrPtr) + : AppExecFwk::EventHandler(runner), sinkContrWPtr_(sinkContrPtr) +{ + DHLOGI("Ctor DCameraSinkContrEventHandler."); +} + +void DCameraSinkController::DCameraSinkContrEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + CHECK_AND_RETURN_LOG(event, "event is nullptr."); + uint32_t eventId = event->GetInnerEventId(); + auto sinkContr = sinkContrWPtr_.lock(); + if (sinkContr == nullptr) { + DHLOGE("Can not get strong self ptr"); + return; + } + switch (eventId) { + case EVENT_FRAME_TRIGGER: + sinkContr->ProcessFrameTrigger(event); + break; + case EVENT_AUTHORIZATION: + sinkContr->ProcessPostAuthorization(event); + break; + default: + DHLOGE("event is undefined, id is %d", eventId); + break; + } +} + +void DCameraSinkController::ProcessFrameTrigger(const AppExecFwk::InnerEvent::Pointer &event) { - std::string param = event.GetParam(); - accessControl_->TriggerFrame(param); + DHLOGD("Receive frame trigger event then start process data in sink controller."); + std::shared_ptr param = event->GetSharedObject(); + accessControl_->TriggerFrame(*param); } -void DCameraSinkController::OnEvent(DCameraPostAuthorizationEvent& event) +void DCameraSinkController::ProcessPostAuthorization(const AppExecFwk::InnerEvent::Pointer &event) { - std::vector> captureInfos = event.GetParam(); - PostAuthorization(captureInfos); + DHLOGD("Receive post authorization event then start process data in sink controller."); + std::shared_ptr>> captureInfos = + event->GetSharedObject>>(); + PostAuthorization(*captureInfos); } void DCameraSinkController::OnStateChanged(std::shared_ptr& event) diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_data_process.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_data_process.h index a35612aa6ffebe6a4f14b3c0e72170e0671bd962..052d2ccdfd4f74c75823ab78fdbaaa18a89346fe 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_data_process.h +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_data_process.h @@ -19,8 +19,7 @@ #include #include -#include "eventbus/event.h" -#include "eventbus/event_bus.h" +#include "event_handler.h" #include "data_buffer.h" #include "data_process_listener.h" @@ -34,9 +33,7 @@ namespace OHOS { namespace DistributedHardware { -class MockDCameraSinkDataProcess : public ICameraSinkDataProcess, public EventSender, - public DistributedHardware::EventBusHandler, - public DistributedHardware::EventBusHandler, +class MockDCameraSinkDataProcess : public ICameraSinkDataProcess, public std::enable_shared_from_this { public: explicit MockDCameraSinkDataProcess(const std::shared_ptr& channel) diff --git a/services/cameraservice/sourceservice/BUILD.gn b/services/cameraservice/sourceservice/BUILD.gn index a0444f3316568f13361399cabb858dc096a75254..fcca268c6ef7e3844bb7bdeb55ab818491b01949 100644 --- a/services/cameraservice/sourceservice/BUILD.gn +++ b/services/cameraservice/sourceservice/BUILD.gn @@ -21,7 +21,6 @@ ohos_shared_library("distributed_camera_source") { cfi = true cfi_cross_dso = true debug = false - blocklist = "./cfi_blocklist.txt" boundary_sanitize = true integer_overflow = true ubsan = true diff --git a/services/cameraservice/sourceservice/cfi_blocklist.txt b/services/cameraservice/sourceservice/cfi_blocklist.txt deleted file mode 100644 index 8e7f2af61199ec9e9d44d4df7382a30fb15f9175..0000000000000000000000000000000000000000 --- a/services/cameraservice/sourceservice/cfi_blocklist.txt +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (c) 2023 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -[cfi] -src:*/foundation/distributedhardware/distributed_hardware_fwk/utils/include/eventbus/event_bus.h -src:*/foundation/distributedhardware/distributed_hardware_fwk/utils/include/eventbus/eventbus_handler.h diff --git a/services/cameraservice/sourceservice/include/distributedcamera/distributed_camera_source_service.h b/services/cameraservice/sourceservice/include/distributedcamera/distributed_camera_source_service.h index fc1753685341f77fd0fb542ef365be0a897567d9..c0f4cb1d1361e4d8a883abccd06f6a0bc6a6b2ab 100644 --- a/services/cameraservice/sourceservice/include/distributedcamera/distributed_camera_source_service.h +++ b/services/cameraservice/sourceservice/include/distributedcamera/distributed_camera_source_service.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -19,6 +19,7 @@ #include #include #include +#include #include #include "system_ability.h" diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h index 2e3a81ce4711116661940f8329543e09f7a773d7..0f9a1d2120800555de5eb8dd7dc8a3ed0f99eb8f 100644 --- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h +++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h @@ -16,10 +16,12 @@ #ifndef OHOS_DCAMERA_SOURCE_DEV_H #define OHOS_DCAMERA_SOURCE_DEV_H +#include + #include "dcamera_index.h" #include "dcamera_source_event.h" #include "dcamera_source_state_machine.h" -#include "eventbus/event_bus.h" +#include "event_handler.h" #include "icamera_controller.h" #include "icamera_state_listener.h" #include "icamera_input.h" @@ -30,11 +32,12 @@ namespace OHOS { namespace DistributedHardware { -class DCameraSourceDev : public EventSender, public DistributedHardware::EventBusHandler, - public std::enable_shared_from_this { +const uint32_t EVENT_SOURCE_DEV_PROCESS = 0; +const uint32_t EVENT_HICOLLIE = 1; +class DCameraSourceDev : public std::enable_shared_from_this { public: explicit DCameraSourceDev(std::string devId, std::string dhId, std::shared_ptr& stateLisener); - ~DCameraSourceDev() override; + virtual ~DCameraSourceDev(); int32_t InitDCameraSourceDev(); int32_t RegisterDistributedHardware(const std::string& devId, const std::string& dhId, const std::string& reqId, @@ -50,7 +53,6 @@ public: int32_t StopCameraCapture(const std::vector& streamIds); int32_t UpdateCameraSettings(const std::vector>& settings); - void OnEvent(DCameraSourceEvent& event) override; int32_t GetStateInfo(); std::string GetVersion(); int32_t OnChannelConnectedEvent(); @@ -59,6 +61,16 @@ public: void SetHicollieFlag(bool flag); bool GetHicollieFlag(); + class DCameraSourceDevEventHandler : public AppExecFwk::EventHandler { + public: + DCameraSourceDevEventHandler(const std::shared_ptr &runner, + std::shared_ptr srcDevPtr); + ~DCameraSourceDevEventHandler() override = default; + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + private: + std::weak_ptr srcDevPtrWPtr_; + }; + public: virtual int32_t Register(std::shared_ptr& param); virtual int32_t UnRegister(std::shared_ptr& param); @@ -82,6 +94,8 @@ private: void NotifyHalResult(DCAMERA_EVENT eventType, DCameraSourceEvent& event, int32_t result); void HitraceAndHisyseventImpl(std::vector>& captureInfos); int32_t ParseEnableParam(std::shared_ptr& param, std::string& ability); + void DoProcessData(const AppExecFwk::InnerEvent::Pointer &event); + void DoHicollieProcess(); private: std::string devId_; @@ -89,7 +103,7 @@ private: std::string version_; std::set actualDevInfo_; std::shared_ptr stateListener_; - std::shared_ptr eventBus_; + std::shared_ptr srcDevEventHandler_ = nullptr; std::shared_ptr stateMachine_; std::shared_ptr controller_; std::shared_ptr input_; diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h index f737f9ea19557620dbe15a4de3c651679da3a0da..4664d7ca188db14c41a2ec837351fa86682d85fa 100644 --- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h +++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_event.h @@ -18,7 +18,6 @@ #include -#include "eventbus/event.h" #include "v1_0/dcamera_types.h" #include "dcamera_event_cmd.h" @@ -55,52 +54,50 @@ public: std::string srcParam_; }; -class DCameraSourceEvent : public Event { - TYPEINDENT(DCameraSourceEvent) - +class DCameraSourceEvent { public: - explicit DCameraSourceEvent(EventSender& sender) : Event(sender) {} + explicit DCameraSourceEvent() {} ~DCameraSourceEvent() = default; - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType) - : Event(sender), eventType_(eventType) {} - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, DCameraIndex& index) - : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType) + : eventType_(eventType) {} + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, DCameraIndex& index) + : eventType_(eventType) { eventParam_ = index; } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, - std::shared_ptr& param) : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, + std::shared_ptr& param) : eventType_(eventType) { eventParam_ = param; } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, - const std::vector>& streamInfos) : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, + const std::vector>& streamInfos) : eventType_(eventType) { eventParam_ = std::move(streamInfos); } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, - const std::vector>& captureInfos) : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, + const std::vector>& captureInfos) : eventType_(eventType) { eventParam_ = std::move(captureInfos); } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, - const std::vector>& settings) : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, + const std::vector>& settings) : eventType_(eventType) { eventParam_ = std::move(settings); } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, const std::vector& streamIds) - : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, const std::vector& streamIds) + : eventType_(eventType) { eventParam_ = std::move(streamIds); } - explicit DCameraSourceEvent(EventSender& sender, DCAMERA_EVENT eventType, std::shared_ptr& camEvent) - : Event(sender), eventType_(eventType) + explicit DCameraSourceEvent(DCAMERA_EVENT eventType, std::shared_ptr& camEvent) + : eventType_(eventType) { eventParam_ = camEvent; } diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h index 0c844b80ddd6e8c5d57ea83b2dd0e63550969361..34e74fa6a9cec14ae01d26e63fd9afd39eb18ddd 100644 --- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h +++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h @@ -22,7 +22,6 @@ #include "icamera_channel_listener.h" #include "dcamera_source_dev.h" #include "dcamera_source_state_machine.h" -#include "eventbus/event_bus.h" #include "icamera_channel.h" #include "iremote_object.h" @@ -30,7 +29,7 @@ namespace OHOS { namespace DistributedHardware { -class DCameraSourceController : public ICameraController, public EventSender, +class DCameraSourceController : public ICameraController, public std::enable_shared_from_this { public: DCameraSourceController(std::string devId, std::string dhId, diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h index 3b60547ab08778b200fd06aa50459d8295951535..6fa3b270903d2fbbe7a4026833446791d3e7c583 100644 --- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h +++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h @@ -22,12 +22,10 @@ #include "icamera_source_data_process.h" #include "dcamera_source_dev.h" -#include "eventbus/event_bus.h" -#include "eventbus/event_sender.h" namespace OHOS { namespace DistributedHardware { -class DCameraSourceInput : public ICameraInput, public EventSender, +class DCameraSourceInput : public ICameraInput, public std::enable_shared_from_this { public: DCameraSourceInput(std::string devId, std::string dhId, std::shared_ptr& camDev); diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp index 812d258ef7a5b9c58b0bb6410696e9a31558e4cc..89525c1636312e9b63bda143ea944d2821a8c431 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp @@ -59,7 +59,7 @@ DCameraSourceDev::~DCameraSourceDev() { DHLOGI("DCameraSourceDev Delete devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - eventBus_ = nullptr; + srcDevEventHandler_ = nullptr; hdiCallback_ = nullptr; input_ = nullptr; controller_ = nullptr; @@ -76,9 +76,9 @@ int32_t DCameraSourceDev::InitDCameraSourceDev() { DHLOGI("DCameraSourceDev InitDCameraSourceDev devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - eventBus_ = std::make_shared("SrcDevHandler"); - DCameraSourceEvent event(*this); - eventBus_->AddHandler(event.GetType(), *this); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + srcDevEventHandler_ = std::make_shared( + runner, shared_from_this()); auto cameraSourceDev = std::shared_ptr(shared_from_this()); stateMachine_ = std::make_shared(cameraSourceDev); stateMachine_->UpdateState(DCAMERA_STATE_INIT); @@ -105,8 +105,12 @@ int32_t DCameraSourceDev::RegisterDistributedHardware(const std::string& devId, std::shared_ptr regParam = std::make_shared(devId, dhId, reqId, param.sinkAttrs, param.sourceAttrs); - DCameraSourceEvent event(*this, DCAMERA_EVENT_REGIST, regParam); - eventBus_->PostEvent(event); + DCameraSourceEvent event(DCAMERA_EVENT_REGIST, regParam); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -119,8 +123,12 @@ int32_t DCameraSourceDev::UnRegisterDistributedHardware(const std::string devId, std::string sourceAttrs; std::shared_ptr regParam = std::make_shared(devId, dhId, reqId, sinkAttrs, sourceAttrs); - DCameraSourceEvent event(*this, DCAMERA_EVENT_UNREGIST, regParam); - eventBus_->PostEvent(event); + DCameraSourceEvent event(DCAMERA_EVENT_UNREGIST, regParam); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -136,8 +144,12 @@ int32_t DCameraSourceDev::DCameraNotify(std::string& eventStr) return ret; } - DCameraSourceEvent event(*this, DCAMERA_EVENT_NOFIFY, cmd.value_); - eventBus_->PostEvent(event); + DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, cmd.value_); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -145,8 +157,13 @@ int32_t DCameraSourceDev::OpenSession(DCameraIndex& camIndex) { DHLOGI("DCameraSourceDev PostTask OpenSession devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - DCameraSourceEvent event(*this, DCAMERA_EVENT_OPEN, camIndex); - eventBus_->PostEvent(event); + std::shared_ptr dCamIndex = std::make_shared(camIndex); + DCameraSourceEvent event(DCAMERA_EVENT_OPEN, camIndex); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -154,8 +171,13 @@ int32_t DCameraSourceDev::CloseSession(DCameraIndex& camIndex) { DHLOGI("DCameraSourceDev PostTask CloseSession devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - DCameraSourceEvent event(*this, DCAMERA_EVENT_CLOSE, camIndex); - eventBus_->PostEvent(event); + std::shared_ptr dCamIndex = std::make_shared(camIndex); + DCameraSourceEvent event(DCAMERA_EVENT_CLOSE, camIndex); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -163,8 +185,14 @@ int32_t DCameraSourceDev::ConfigCameraStreams(const std::vectorPostEvent(event); + std::shared_ptr>> streams = + std::make_shared>>(streamInfos); + DCameraSourceEvent event(DCAMERA_EVENT_CONFIG_STREAMS, streamInfos); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -172,8 +200,13 @@ int32_t DCameraSourceDev::ReleaseCameraStreams(const std::vector& streamIds { DHLOGI("DCameraSourceDev PostTask ReleaseStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - DCameraSourceEvent event(*this, DCAMERA_EVENT_RELEASE_STREAMS, streamIds); - eventBus_->PostEvent(event); + std::shared_ptr> ids = std::make_shared>(streamIds); + DCameraSourceEvent event(DCAMERA_EVENT_RELEASE_STREAMS, streamIds); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -181,8 +214,14 @@ int32_t DCameraSourceDev::StartCameraCapture(const std::vectorPostEvent(event); + std::shared_ptr>> capInfos = + std::make_shared>>(captureInfos); + DCameraSourceEvent event(DCAMERA_EVENT_START_CAPTURE, captureInfos); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -190,8 +229,13 @@ int32_t DCameraSourceDev::StopCameraCapture(const std::vector& streamIds) { DHLOGI("DCameraSourceDev PostTask StopCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - DCameraSourceEvent event(*this, DCAMERA_EVENT_STOP_CAPTURE, streamIds); - eventBus_->PostEvent(event); + std::shared_ptr> ids = std::make_shared>(streamIds); + DCameraSourceEvent event(DCAMERA_EVENT_STOP_CAPTURE, streamIds); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -199,25 +243,61 @@ int32_t DCameraSourceDev::UpdateCameraSettings(const std::vectorPostEvent(event); + std::shared_ptr>> dcamSettins = + std::make_shared>>(settings); + DCameraSourceEvent event(DCAMERA_EVENT_UPDATE_SETTINGS, settings); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } -void DCameraSourceDev::OnEvent(DCameraSourceEvent& event) +void DCameraSourceDev::DoHicollieProcess() { - DHLOGI("DCameraSourceDev OnEvent devId %{public}s dhId %{public}s eventType: %{public}d", - GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), event.GetEventType()); - if (event.GetEventType() == DCAMERA_EVENT_HICOLLIE) { - SetHicollieFlag(true); - return; - } - int32_t ret = stateMachine_->Execute(event.GetEventType(), event); + SetHicollieFlag(true); +} + +void DCameraSourceDev::DoProcessData(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr eventParam = event->GetSharedObject(); + CHECK_AND_RETURN_LOG(eventParam == nullptr, "eventParam is nullptr."); + int32_t ret = stateMachine_->Execute((*eventParam).GetEventType(), (*eventParam)); if (ret != DCAMERA_OK) { - DHLOGE("DCameraSourceDev OnEvent failed, ret: %{public}d, devId: %{public}s dhId: %{public}s", ret, + DHLOGE("DCameraSourceDev Execute failed, ret: %{public}d, devId: %{public}s dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); } - NotifyResult(event.GetEventType(), event, ret); + NotifyResult((*eventParam).GetEventType(), (*eventParam), ret); +} + +DCameraSourceDev::DCameraSourceDevEventHandler::DCameraSourceDevEventHandler( + const std::shared_ptr &runner, std::shared_ptr srcDevPtr) + : AppExecFwk::EventHandler(runner), srcDevPtrWPtr_(srcDevPtr) +{ + DHLOGI("Ctor DCameraSourceDevEventHandler."); +} + +void DCameraSourceDev::DCameraSourceDevEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + CHECK_AND_RETURN_LOG(event == nullptr, "event is nullptr."); + uint32_t eventId = event->GetInnerEventId(); + auto srcDevPtr = srcDevPtrWPtr_.lock(); + if (srcDevPtr == nullptr) { + DHLOGE("Can not get strong self ptr"); + return; + } + switch (eventId) { + case EVENT_HICOLLIE: + srcDevPtr->DoHicollieProcess(); + break; + case EVENT_SOURCE_DEV_PROCESS: + srcDevPtr->DoProcessData(event); + break; + default: + DHLOGE("event is undefined, id is %d", eventId); + break; + } } int32_t DCameraSourceDev::Register(std::shared_ptr& param) @@ -658,29 +738,40 @@ int32_t DCameraSourceDev::OnChannelConnectedEvent() std::shared_ptr camEvent = std::make_shared(); camEvent->eventType_ = DCAMERA_MESSAGE; camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_CONNECTED; - DCameraSourceEvent event(*this, DCAMERA_EVENT_NOFIFY, camEvent); - eventBus_->PostEvent(event); + DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } int32_t DCameraSourceDev::OnChannelDisconnectedEvent() { DCameraIndex camIndex(devId_, dhId_); - DCameraSourceEvent event(*this, DCAMERA_EVENT_CLOSE, camIndex); - eventBus_->PostEvent(event); + std::shared_ptr index = std::make_shared(camIndex); + DCameraSourceEvent event(DCAMERA_EVENT_CLOSE, camIndex); + std::shared_ptr eventParam = std::make_shared(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); std::shared_ptr camEvent = std::make_shared(); camEvent->eventType_ = DCAMERA_MESSAGE; camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED; - DCameraSourceEvent eventNotify(*this, DCAMERA_EVENT_NOFIFY, camEvent); - eventBus_->PostEvent(eventNotify); + DCameraSourceEvent eventNotify(DCAMERA_EVENT_NOFIFY, camEvent); + eventParam = std::make_shared(eventNotify); + msgEvent = AppExecFwk::InnerEvent::Get(EVENT_SOURCE_DEV_PROCESS, eventParam, 0); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } int32_t DCameraSourceDev::PostHicollieEvent() { - DCameraIndex camIndex(devId_, dhId_); - DCameraSourceEvent event(*this, DCAMERA_EVENT_HICOLLIE, camIndex); - eventBus_->PostEvent(event); + CHECK_AND_RETURN_RET_LOG(srcDevEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "srcDevEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(EVENT_HICOLLIE); + srcDevEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp index 8d89e44b0f91e12e8febcfdd01c045787b01d800..777de02ac9f87a7ded17b3b38455ae7d7ad5ff16 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp @@ -21,6 +21,7 @@ #include "iservmgr_hdi.h" #include "iproxy_broker.h" +#include "anonymous_string.h" #include "dcamera_capture_info_cmd.h" #include "dcamera_channel_source_impl.h" #include "dcamera_hitrace_adapter.h" diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp index 7c5720255776c31b77d3bce0b40f1994cafaa7ea..0c69d8d07d46c322887a3f8e0d6d8ba810fa2739 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -89,7 +89,7 @@ void DCameraSourceConfigStreamStateTest::TearDown(void) */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_001, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); std::shared_ptr configstate = std::make_shared(stateMachine_); int32_t ret = configstate->DoUnregisterTask(camDev_, event0); @@ -104,7 +104,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_002, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); std::shared_ptr configstate = std::make_shared(stateMachine_); int32_t ret = configstate->DoUpdateSettingsTask(camDev_, event0); @@ -119,7 +119,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_003, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); std::shared_ptr configstate = std::make_shared(stateMachine_); int32_t ret = configstate->DoEventNofityTask(camDev_, event0); @@ -134,7 +134,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_004, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr openState = std::make_shared(stateMachine_); int32_t ret = openState->DoUnregisterTask(camDev_, event0); EXPECT_EQ(DCAMERA_OK, ret); @@ -148,7 +148,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_005, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr openState = std::make_shared(stateMachine_); int32_t ret = openState->DoUpdateSettingsTask(camDev_, event0); EXPECT_EQ(DCAMERA_NOT_FOUND, ret); @@ -162,7 +162,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_006, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr openState = std::make_shared(stateMachine_); int32_t ret = openState->DoEventNofityTask(camDev_, event0); EXPECT_EQ(DCAMERA_NOT_FOUND, ret); @@ -176,7 +176,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_007, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr captureState = std::make_shared(stateMachine_); int32_t ret = captureState->DoUnregisterTask(camDev_, event0); @@ -191,7 +191,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_008, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr captureState = std::make_shared(stateMachine_); int32_t ret = captureState->DoStartCaptureTask(camDev_, event0); @@ -206,7 +206,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_009, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr captureState = std::make_shared(stateMachine_); int32_t ret = captureState->DoStopCaptureTask(camDev_, event0); @@ -221,7 +221,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_010, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr captureState = std::make_shared(stateMachine_); int32_t ret = captureState->DoUpdateSettingsTask(camDev_, event0); @@ -236,7 +236,7 @@ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_ */ HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_011, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam); std::shared_ptr captureState = std::make_shared(stateMachine_); int32_t ret = captureState->DoEventNofityTask(camDev_, event0); diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp index 7850060ee4d1a46aaab65ab39ac036fdea55132d..7698aa7d07c715c3b3698ce491bdd029e49f40f1 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -21,6 +21,7 @@ #include "dcamera_source_state.h" #include "dcamera_utils_tools.h" #include "mock_camera_channel.h" +#include "distributed_hardware_log.h" #include "icamera_state_listener.h" #include "dcamera_source_controller_channel_listener.h" #include "distributed_camera_errno.h" diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp index f556f307ca32dc09e00fc0513f01815d28c79537..c5483978b4e8a5d163612d361e78f1fc511ccbfe 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -343,9 +343,8 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_011, TestSize.Level1) HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_012, TestSize.Level1) { std::shared_ptr camEvent = std::make_shared(); - DCameraSourceEvent event(*camDev_, DCAMERA_EVENT_NOFIFY, camEvent); + DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent); camDev_->InitDCameraSourceDev(); - camDev_->OnEvent(event); camDev_->GetVersion(); int32_t ret = camDev_->GetStateInfo(); EXPECT_EQ(DCAMERA_OK, ret); @@ -642,7 +641,7 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_022, TestSize.Level1) int32_t result = 0; DCAMERA_EVENT eventType = DCAMERA_EVENT::DCAMERA_EVENT_OPEN; std::shared_ptr camEvent = std::make_shared(); - DCameraSourceEvent event(*camDev_, DCAMERA_EVENT_NOFIFY, camEvent); + DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent); camDev_->NotifyResult(eventType, event, result); camDev_->memberFuncMap_.clear(); camDev_->NotifyResult(eventType, event, result); diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp index 8a8655a0512070f8068b124c8361081f58e2f5c5..52b49292dadaa9fed926c408f9cffa646f84d011 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -174,8 +174,8 @@ void DCameraSourceStateMachineTest::TearDown(void) */ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); - DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam); stateMachine_ ->UpdateState(DCAMERA_STATE_INIT); int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0); EXPECT_EQ(DCAMERA_OK, ret); @@ -192,11 +192,11 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, T */ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); - DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam); - DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex); - DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex); - DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam); + DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex); + DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex); + DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent); stateMachine_ ->UpdateState(DCAMERA_STATE_INIT); stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST); int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0); @@ -223,14 +223,14 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, T */ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); - DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam); - DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex); - DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex); - DCameraSourceEvent event4(*camDev_, DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap); - DCameraSourceEvent event5(*camDev_, DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap); - DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); - DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam); + DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex); + DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex); + DCameraSourceEvent event4(DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap); + DCameraSourceEvent event5(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap); + DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); + DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent); stateMachine_ ->UpdateState(DCAMERA_STATE_INIT); stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST); stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED); @@ -267,16 +267,16 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, T */ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); - DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam); - DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex); - DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex); - DCameraSourceEvent event4(*camDev_, DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap); - DCameraSourceEvent event5(*camDev_, DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap); - DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap); - DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap); - DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); - DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam); + DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex); + DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex); + DCameraSourceEvent event4(DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap); + DCameraSourceEvent event5(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap); + DCameraSourceEvent event6(DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap); + DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap); + DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); + DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent); stateMachine_ ->UpdateState(DCAMERA_STATE_INIT); stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST); stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED); @@ -320,14 +320,14 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, T */ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, TestSize.Level1) { - DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); - DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam); - DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex); - DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex); - DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap); - DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap); - DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); - DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent); + DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam); + DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam); + DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex); + DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex); + DCameraSourceEvent event6(DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap); + DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap); + DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap); + DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent); stateMachine_ ->UpdateState(DCAMERA_STATE_INIT); stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST); stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED); diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp index 9efe6b6561e9a2b696d6d9b1dcfb535c2bf1b9d5..5dcf82d3c628283dc2505c650c43e4429afb2e39 100644 --- a/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp +++ b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp @@ -43,7 +43,6 @@ public: std::shared_ptr input_; std::shared_ptr camDev_; - std::shared_ptr eventBus_; std::shared_ptr channel_; std::shared_ptr listener_; std::shared_ptr stateListener_; @@ -72,7 +71,6 @@ void DCameraChannelSourceImplTest::TearDown(void) usleep(TEST_SLEEP_SEC); input_ = nullptr; camDev_ = nullptr; - eventBus_ = nullptr; listener_ = nullptr; stateListener_ = nullptr; channel_ = nullptr; @@ -93,11 +91,8 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_001, Tes camIndexs.push_back(index); std::string sessionFlag = "test001"; DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; - eventBus_ = std::make_shared("SrcDevHandlerTest01"); stateListener_ = std::make_shared(); camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); - DCameraSourceEvent event(*camDev_); - eventBus_->AddHandler(event.GetType(), *camDev_); input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_); @@ -121,11 +116,8 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_002, Tes camIndexs.push_back(index); std::string sessionFlag = "test002"; DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; - eventBus_ = std::make_shared("SrcDevHandlerTest02"); stateListener_ = std::make_shared(); camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); - DCameraSourceEvent event(*camDev_); - eventBus_->AddHandler(event.GetType(), *camDev_); input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_); @@ -150,11 +142,8 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_003, Tes camIndexs.push_back(index); std::string sessionFlag = "test003"; DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; - eventBus_ = std::make_shared("SrcDevHandlerTest03"); stateListener_ = std::make_shared(); camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); - DCameraSourceEvent event(*camDev_); - eventBus_->AddHandler(event.GetType(), *camDev_); input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_); diff --git a/services/data_process/BUILD.gn b/services/data_process/BUILD.gn index 2c0e3638984639549fdc6ff5d291b11ed7521e3c..c273ecc2a7d557dd849c89c8ce9d2f90dc86e5e0 100644 --- a/services/data_process/BUILD.gn +++ b/services/data_process/BUILD.gn @@ -21,7 +21,6 @@ ohos_shared_library("distributed_camera_data_process") { cfi = true cfi_cross_dso = true debug = false - blocklist = "./cfi_blocklist.txt" boundary_sanitize = true integer_overflow = true ubsan = true diff --git a/services/data_process/cfi_blocklist.txt b/services/data_process/cfi_blocklist.txt deleted file mode 100644 index 8e7f2af61199ec9e9d44d4df7382a30fb15f9175..0000000000000000000000000000000000000000 --- a/services/data_process/cfi_blocklist.txt +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (c) 2023 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -[cfi] -src:*/foundation/distributedhardware/distributed_hardware_fwk/utils/include/eventbus/event_bus.h -src:*/foundation/distributedhardware/distributed_hardware_fwk/utils/include/eventbus/eventbus_handler.h diff --git a/services/data_process/include/eventbus/dcamera_codec_event.h b/services/data_process/include/eventbus/dcamera_codec_event.h index c34e679cd9c5a36ede4b194c1eaabdacd2b6e942..eb44ed4a15c300dabe950c065f10288149ad12a4 100644 --- a/services/data_process/include/eventbus/dcamera_codec_event.h +++ b/services/data_process/include/eventbus/dcamera_codec_event.h @@ -18,7 +18,6 @@ #include -#include "eventbus/event.h" #include "data_buffer.h" #include "image_common_type.h" #include "surface.h" @@ -76,14 +75,13 @@ private: sptr surface_; }; -class DCameraCodecEvent : public Event { - TYPEINDENT(DCameraCodecEvent) +class DCameraCodecEvent { public: - DCameraCodecEvent(EventSender& sender, const std::shared_ptr& codecPacket) - : Event(sender), codecPacket_(codecPacket), action_(VideoCodecAction::NO_ACTION) {} - DCameraCodecEvent(EventSender& sender, const std::shared_ptr& codecPacket, + DCameraCodecEvent(const std::shared_ptr& codecPacket) + : codecPacket_(codecPacket), action_(VideoCodecAction::NO_ACTION) {} + DCameraCodecEvent(const std::shared_ptr& codecPacket, VideoCodecAction otherAction) - : Event(sender), codecPacket_(codecPacket), action_(otherAction) {} + : codecPacket_(codecPacket), action_(otherAction) {} ~DCameraCodecEvent() {} std::shared_ptr GetCodecPacket() const diff --git a/services/data_process/include/pipeline/dcamera_pipeline_sink.h b/services/data_process/include/pipeline/dcamera_pipeline_sink.h index 9ddee71714403dbf1c096b4234128a385b4836fd..fdf0945888767c9b447dac54f5a5a0641b4e154f 100644 --- a/services/data_process/include/pipeline/dcamera_pipeline_sink.h +++ b/services/data_process/include/pipeline/dcamera_pipeline_sink.h @@ -19,15 +19,9 @@ #include #include -#include "eventbus/event.h" -#include "eventbus/event_bus.h" -#include "eventbus/event_sender.h" -#include "eventbus/eventbus_handler.h" - #include "data_buffer.h" #include "image_common_type.h" #include "distributed_camera_errno.h" -#include "dcamera_pipeline_event.h" #include "idata_process_pipeline.h" #include "abstract_data_process.h" #include "data_process_listener.h" diff --git a/services/data_process/include/pipeline/dcamera_pipeline_source.h b/services/data_process/include/pipeline/dcamera_pipeline_source.h index 380bad31fa97c38135d3abb6a6d2b5d37a16655b..d3304064672489a69836b2bd1188e794123618b1 100644 --- a/services/data_process/include/pipeline/dcamera_pipeline_source.h +++ b/services/data_process/include/pipeline/dcamera_pipeline_source.h @@ -18,11 +18,7 @@ #include #include - -#include "eventbus/event.h" -#include "eventbus/event_bus.h" -#include "eventbus/event_sender.h" -#include "eventbus/eventbus_handler.h" +#include "event_handler.h" #include "data_buffer.h" #include "image_common_type.h" @@ -35,9 +31,9 @@ namespace OHOS { namespace DistributedHardware { class DecodeDataProcess; +const uint32_t EVENT_PIPELINE_PROCESS_DATA = 0; -class DCameraPipelineSource : public EventSender, public EventBusHandler, - public IDataProcessPipeline, public std::enable_shared_from_this { +class DCameraPipelineSource : public IDataProcessPipeline, public std::enable_shared_from_this { public: ~DCameraPipelineSource() override; @@ -45,17 +41,27 @@ public: const VideoConfigParams& targetConfig, const std::shared_ptr& listener) override; int32_t ProcessData(std::vector>& dataBuffers) override; void DestroyDataProcessPipeline() override; - void OnEvent(DCameraPipelineEvent& ev) override; void OnError(DataProcessErrorType errorType); void OnProcessedVideoBuffer(const std::shared_ptr& videoResult); int32_t GetProperty(const std::string& propertyName, PropertyCarrier& propertyCarrier) override; + class DCameraPipelineSrcEventHandler : public AppExecFwk::EventHandler { + public: + DCameraPipelineSrcEventHandler(const std::shared_ptr &runner, + std::shared_ptr pipeSourcePtr); + ~DCameraPipelineSrcEventHandler() override = default; + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + private: + std::weak_ptr pipeSourceWPtr_; + }; + private: bool IsInRange(const VideoConfigParams& curConfig); void InitDCameraPipEvent(); int32_t InitDCameraPipNodes(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig); + void DoProcessData(const AppExecFwk::InnerEvent::Pointer &event); private: const static std::string PIPELINE_OWNER; @@ -68,7 +74,7 @@ private: std::shared_ptr processListener_ = nullptr; std::shared_ptr pipelineHead_ = nullptr; - std::shared_ptr eventBusSource_ = nullptr; + std::shared_ptr pipeEventHandler_ = nullptr; bool isProcess_ = false; PipelineType piplineType_ = PipelineType::VIDEO; diff --git a/services/data_process/include/pipeline_node/multimedia_codec/decoder/decode_data_process.h b/services/data_process/include/pipeline_node/multimedia_codec/decoder/decode_data_process.h index 6cfb5f95557e7457850b4ce4b453627f8e1db903..5283dbf3db4d04e61526b7c402fc09dcb2fba45b 100644 --- a/services/data_process/include/pipeline_node/multimedia_codec/decoder/decode_data_process.h +++ b/services/data_process/include/pipeline_node/multimedia_codec/decoder/decode_data_process.h @@ -26,11 +26,7 @@ #include "avcodec_common.h" #include "avcodec_video_decoder.h" #include "buffer/avsharedmemory.h" -#include "eventbus/event.h" -#include "eventbus/event_bus.h" -#include "eventbus/event_sender.h" -#include "eventbus/event_registration.h" -#include "eventbus/eventbus_handler.h" +#include "event_handler.h" #include "meta/format.h" #include "ibuffer_consumer_listener.h" #include "iconsumer_surface.h" @@ -49,20 +45,21 @@ namespace OHOS { namespace DistributedHardware { class DCameraPipelineSource; class DecodeVideoCallback; +const uint32_t EVENT_NO_ACTION = 0; +const uint32_t EVENT_ACTION_ONCE_AGAIN = 1; +const uint32_t EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER = 2; -class DecodeDataProcess : public EventSender, public EventBusHandler, public AbstractDataProcess, - public std::enable_shared_from_this { +class DecodeDataProcess : public AbstractDataProcess, public std::enable_shared_from_this { public: - DecodeDataProcess(const std::shared_ptr& eventBusPipeline, + DecodeDataProcess(const std::shared_ptr& pipeEventHandler, const std::weak_ptr& callbackPipSource) - : eventBusPipeline_(eventBusPipeline), callbackPipelineSource_(callbackPipSource) {} + : pipeSrcEventHandler_(pipeEventHandler), callbackPipelineSource_(callbackPipSource) {} ~DecodeDataProcess() override; int32_t InitNode(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig, VideoConfigParams& processedConfig) override; int32_t ProcessData(std::vector>& inputBuffers) override; void ReleaseProcessNode() override; - void OnEvent(DCameraCodecEvent& ev) override; void OnError(); void OnInputBufferAvailable(uint32_t index, std::shared_ptr buffer); @@ -77,6 +74,16 @@ public: int32_t GetProperty(const std::string& propertyName, PropertyCarrier& propertyCarrier) override; + class DecodeDataProcessEventHandler : public AppExecFwk::EventHandler { + public: + DecodeDataProcessEventHandler(const std::shared_ptr &runner, + std::shared_ptr decPtr); + ~DecodeDataProcessEventHandler() override = default; + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + private: + std::weak_ptr decPtrWPtr_; + }; + private: bool IsInDecoderRange(const VideoConfigParams& curConfig); bool IsConvertible(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig); @@ -99,6 +106,9 @@ private: bool IsCorrectSurfaceBuffer(const sptr& surBuf, int32_t alignedWidth, int32_t alignedHeight); void PostOutputDataBuffers(std::shared_ptr& outputBuffer); int32_t DecodeDone(std::vector>& outputBuffers); + void ProcessFeedDecoderInputBuffer(); + void ProcessGetDecoderOutputBuffer(const AppExecFwk::InnerEvent::Pointer &event); + void ProcessDecodeDone(const AppExecFwk::InnerEvent::Pointer &event); private: constexpr static int32_t VIDEO_DECODER_QUEUE_MAX = 1000; @@ -119,7 +129,7 @@ private: constexpr static int32_t ALIGNED_WIDTH_MAX_SIZE = 10000; constexpr static uint32_t MEMORY_RATIO_UV = 1; - std::shared_ptr eventBusPipeline_; + std::shared_ptr pipeSrcEventHandler_; std::weak_ptr callbackPipelineSource_; std::mutex mtxDecoderLock_; std::mutex mtxDecoderState_; @@ -128,9 +138,7 @@ private: VideoConfigParams sourceConfig_; VideoConfigParams targetConfig_; VideoConfigParams processedConfig_; - std::shared_ptr eventBusDecode_ = nullptr; - std::shared_ptr eventBusRegHandleDecode_ = nullptr; - std::shared_ptr eventBusRegHandlePipeline2Decode_ = nullptr; + std::shared_ptr decEventHandler_; std::shared_ptr videoDecoder_ = nullptr; std::shared_ptr decodeVideoCallback_ = nullptr; sptr decodeConsumerSurface_ = nullptr; diff --git a/services/data_process/src/pipeline/dcamera_pipeline_source.cpp b/services/data_process/src/pipeline/dcamera_pipeline_source.cpp index 818cf703ee77d6e124d8cb9f406f85f16cc52fb5..a4f5ac6ac522da2b18230daaebf2468d4e4fdcdc 100644 --- a/services/data_process/src/pipeline/dcamera_pipeline_source.cpp +++ b/services/data_process/src/pipeline/dcamera_pipeline_source.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -83,9 +83,9 @@ bool DCameraPipelineSource::IsInRange(const VideoConfigParams& curConfig) void DCameraPipelineSource::InitDCameraPipEvent() { DHLOGD("Init source DCamera pipeline event to asynchronously process data."); - eventBusSource_ = std::make_shared("PipelineSrcHandler"); - DCameraPipelineEvent pipelineEvent(*this, std::make_shared()); - eventBusSource_->AddHandler(pipelineEvent.GetType(), *this); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + pipeEventHandler_ = std::make_shared( + runner, shared_from_this()); } int32_t DCameraPipelineSource::InitDCameraPipNodes(const VideoConfigParams& sourceConfig, @@ -96,12 +96,12 @@ int32_t DCameraPipelineSource::InitDCameraPipNodes(const VideoConfigParams& sour DHLOGE("JPEG data process is not supported."); return DCAMERA_NOT_FOUND; } - if (eventBusSource_ == nullptr) { + if (pipeEventHandler_ == nullptr) { DHLOGE("eventBusSource is nullptr."); return DCAMERA_BAD_VALUE; } - pipNodeRanks_.push_back(std::make_shared(eventBusSource_, shared_from_this())); + pipNodeRanks_.push_back(std::make_shared(pipeEventHandler_, shared_from_this())); pipNodeRanks_.push_back(std::make_shared(shared_from_this())); if (pipNodeRanks_.size() == 0) { DHLOGD("Creating an empty source pipeline."); @@ -166,12 +166,10 @@ int32_t DCameraPipelineSource::ProcessData(std::vector pipConfigSource = std::make_shared(piplineType_, PIPELINE_OWNER, dataBuffers); - DCameraPipelineEvent dCamPipelineEvent(*this, pipConfigSource); - if (eventBusSource_ == nullptr) { - DHLOGE("eventBusSource_ is nullptr."); - return DCAMERA_BAD_VALUE; - } - eventBusSource_->PostEvent(dCamPipelineEvent, POSTMODE::POST_ASYNC); + CHECK_AND_RETURN_RET_LOG(pipeEventHandler_ == nullptr, DCAMERA_BAD_VALUE, "pipeEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_PIPELINE_PROCESS_DATA, pipConfigSource, 0); + pipeEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); return DCAMERA_OK; } @@ -184,17 +182,22 @@ void DCameraPipelineSource::DestroyDataProcessPipeline() pipelineHead_->ReleaseProcessNode(); pipelineHead_ = nullptr; } - eventBusSource_ = nullptr; + pipeEventHandler_ = nullptr; processListener_ = nullptr; pipNodeRanks_.clear(); piplineType_ = PipelineType::VIDEO; DHLOGD("Destroy source data process pipeline end."); } -void DCameraPipelineSource::OnEvent(DCameraPipelineEvent& ev) +void DCameraPipelineSource::DoProcessData(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGD("Receive asynchronous event then start process data in source pipeline."); - std::shared_ptr pipelineConfig = ev.GetPipelineConfig(); + std::shared_ptr pipelineConfig = event->GetSharedObject(); + if (pipelineConfig == nullptr) { + DHLOGE("pipeline config is nullptr."); + OnError(ERROR_PIPELINE_EVENTBUS); + return; + } std::vector> inputBuffers = pipelineConfig->GetDataBuffers(); if (inputBuffers.empty()) { DHLOGE("Receiving process data buffers is empty in source pipeline."); @@ -229,5 +232,31 @@ int32_t DCameraPipelineSource::GetProperty(const std::string& propertyName, Prop { return DCAMERA_OK; } + +DCameraPipelineSource::DCameraPipelineSrcEventHandler::DCameraPipelineSrcEventHandler( + const std::shared_ptr &runner, std::shared_ptr pipeSourcePtr) + : AppExecFwk::EventHandler(runner), pipeSourceWPtr_(pipeSourcePtr) +{ + DHLOGI("Ctor DCameraPipelineSrcEventHandler."); +} + +void DCameraPipelineSource::DCameraPipelineSrcEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + CHECK_AND_RETURN_LOG(event == nullptr, "event is nullptr."); + uint32_t eventId = event->GetInnerEventId(); + auto pipeSrc = pipeSourceWPtr_.lock(); + if (pipeSrc == nullptr) { + DHLOGE("Can not get strong self ptr"); + return; + } + switch (eventId) { + case EVENT_PIPELINE_PROCESS_DATA: + pipeSrc->DoProcessData(event); + break; + default: + DHLOGE("event is undefined, id is %{public}d", eventId); + break; + } +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp index a449b62b8cd0238a0337338e5fa4fed785166c92..57227ac5d3acd94fde3f00203382a6e3efa69ea6 100644 --- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp +++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp @@ -93,12 +93,9 @@ bool DecodeDataProcess::IsConvertible(const VideoConfigParams& sourceConfig, con void DecodeDataProcess::InitCodecEvent() { DHLOGD("Init DecodeNode eventBus, and add handler for it."); - eventBusDecode_ = std::make_shared("DeDtProcHandler"); - DCameraCodecEvent codecEvent(*this, std::make_shared()); - eventBusRegHandleDecode_ = eventBusDecode_->AddHandler(codecEvent.GetType(), *this); - - DHLOGD("Add handler for DCamera pipeline eventBus."); - eventBusRegHandlePipeline2Decode_ = eventBusPipeline_->AddHandler(codecEvent.GetType(), *this); + std::shared_ptr decRunner = AppExecFwk::EventRunner::Create(true); + decEventHandler_ = std::make_shared( + decRunner, shared_from_this()); } int32_t DecodeDataProcess::InitDecoder() @@ -115,7 +112,7 @@ int32_t DecodeDataProcess::InitDecoder() DHLOGE("Start Video decoder failed."); ReportDcamerOptFail(DCAMERA_OPT_FAIL, DCAMERA_DECODE_ERROR, CreateMsg("start video decoder failed, width: %d, height: %d, format: %s", - sourceConfig_.GetWidth(), sourceConfig_.GetHeight(), sourceConfig_.GetHeight(), + sourceConfig_.GetWidth(), sourceConfig_.GetHeight(), ENUM_VIDEOFORMAT_STRINGS[static_cast(sourceConfig_.GetVideoformat())].c_str())); return ret; } @@ -289,17 +286,8 @@ void DecodeDataProcess::ReleaseDecoderSurface() void DecodeDataProcess::ReleaseCodecEvent() { - DCameraCodecEvent codecEvent(*this, std::make_shared()); - if (eventBusDecode_ != nullptr) { - eventBusDecode_->RemoveHandler(codecEvent.GetType(), eventBusRegHandleDecode_); - eventBusRegHandleDecode_ = nullptr; - eventBusDecode_ = nullptr; - } - if (eventBusPipeline_ != nullptr) { - eventBusPipeline_->RemoveHandler(codecEvent.GetType(), eventBusRegHandlePipeline2Decode_); - eventBusRegHandlePipeline2Decode_ = nullptr; - eventBusPipeline_ = nullptr; - } + decEventHandler_ = nullptr; + pipeSrcEventHandler_ = nullptr; DHLOGD("Release DecodeNode eventBusDecode and eventBusPipeline end."); } @@ -367,10 +355,11 @@ int32_t DecodeDataProcess::ProcessData(std::vector>& DHLOGD("Feed decoder input buffer failed. Try FeedDecoderInputBuffer again."); std::shared_ptr reFeedInputPacket = std::make_shared(); reFeedInputPacket->SetVideoCodecType(sourceConfig_.GetVideoCodecType()); - DCameraCodecEvent dCamCodecEv(*this, reFeedInputPacket, VideoCodecAction::ACTION_ONCE_AGAIN); - CHECK_AND_RETURN_RET_LOG(eventBusPipeline_ == nullptr, DCAMERA_BAD_VALUE, - "%{public}s", "eventBusPipeline_ is nullptr."); - eventBusPipeline_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + CHECK_AND_RETURN_RET_LOG(pipeSrcEventHandler_ == nullptr, DCAMERA_BAD_VALUE, + "%{public}s", "pipeSrcEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_ACTION_ONCE_AGAIN, reFeedInputPacket, 0); + pipeSrcEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); } return DCAMERA_OK; } @@ -482,8 +471,10 @@ void DecodeDataProcess::ReduceWaitDecodeCnt() void DecodeDataProcess::OnSurfaceOutputBufferAvailable(const sptr& surface) { std::shared_ptr bufferPkt = std::make_shared(surface); - DCameraCodecEvent dCamCodecEv(*this, bufferPkt, VideoCodecAction::ACTION_GET_DECODER_OUTPUT_BUFFER); - eventBusDecode_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + CHECK_AND_RETURN_LOG(decEventHandler_ == nullptr, "decEventHandler is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER, bufferPkt, 0); + decEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); } void DecodeDataProcess::GetDecoderOutputBuffer(const sptr& surface) @@ -593,16 +584,17 @@ bool DecodeDataProcess::IsCorrectSurfaceBuffer(const sptr& surBuf void DecodeDataProcess::PostOutputDataBuffers(std::shared_ptr& outputBuffer) { - if (eventBusDecode_ == nullptr || outputBuffer == nullptr) { - DHLOGE("eventBusDecode_ or outputBuffer is null."); + if (decEventHandler_ == nullptr || outputBuffer == nullptr) { + DHLOGE("decEventHandler_ or outputBuffer is null."); return; } std::vector> multiDataBuffers; multiDataBuffers.push_back(outputBuffer); std::shared_ptr transNextNodePacket = std::make_shared(VideoCodecType::NO_CODEC, multiDataBuffers); - DCameraCodecEvent dCamCodecEv(*this, transNextNodePacket, VideoCodecAction::NO_ACTION); - eventBusDecode_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_NO_ACTION, transNextNodePacket, 0); + decEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); DHLOGD("Send video decoder output asynchronous DCameraCodecEvents success."); } @@ -632,40 +624,67 @@ int32_t DecodeDataProcess::DecodeDone(std::vector>& return DCAMERA_OK; } -void DecodeDataProcess::OnEvent(DCameraCodecEvent& ev) +DecodeDataProcess::DecodeDataProcessEventHandler::DecodeDataProcessEventHandler( + const std::shared_ptr &runner, std::shared_ptr decPtr) + : AppExecFwk::EventHandler(runner), decPtrWPtr_(decPtr) { - DHLOGD("Receiving asynchronous DCameraCodecEvents."); - std::shared_ptr receivedCodecPacket = ev.GetCodecPacket(); - VideoCodecAction action = ev.GetAction(); - switch (action) { - case VideoCodecAction::NO_ACTION: { - if (receivedCodecPacket == nullptr) { - DHLOGE("the received codecPacket of action [%{public}d] is null.", action); - OnError(); - return; - } - std::vector> dataBuffers = receivedCodecPacket->GetDataBuffers(); - DecodeDone(dataBuffers); + DHLOGI("Ctor DecodeDataProcessEventHandler."); +} + +void DecodeDataProcess::DecodeDataProcessEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + CHECK_AND_RETURN_LOG(event == nullptr, "event is nullptr."); + uint32_t eventId = event->GetInnerEventId(); + auto decPtr = decPtrWPtr_.lock(); + if (decPtr == nullptr) { + DHLOGE("Can not get strong self ptr"); + return; + } + switch (eventId) { + case EVENT_NO_ACTION: + decPtr->ProcessDecodeDone(event); break; - } - case VideoCodecAction::ACTION_ONCE_AGAIN: + case EVENT_ACTION_ONCE_AGAIN: DHLOGD("Try FeedDecoderInputBuffer again."); - FeedDecoderInputBuffer(); + decPtr->ProcessFeedDecoderInputBuffer(); return; - case VideoCodecAction::ACTION_GET_DECODER_OUTPUT_BUFFER: - if (receivedCodecPacket == nullptr) { - DHLOGE("the received codecPacket of action [%{public}d] is null.", action); - OnError(); - return; - } - GetDecoderOutputBuffer(receivedCodecPacket->GetSurface()); + case EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER: + decPtr->ProcessGetDecoderOutputBuffer(event); break; default: - DHLOGD("The action : %{public}d is not supported.", action); + DHLOGD("The action : %{public}d is not supported.", eventId); return; } } +void DecodeDataProcess::ProcessFeedDecoderInputBuffer() +{ + FeedDecoderInputBuffer(); +} + +void DecodeDataProcess::ProcessGetDecoderOutputBuffer(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr receivedCodecPacket = event->GetSharedObject(); + if (receivedCodecPacket == nullptr) { + DHLOGE("the received codecPacket of eventId [%{public}d] is null.", EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER); + OnError(); + return; + } + GetDecoderOutputBuffer(receivedCodecPacket->GetSurface()); +} + +void DecodeDataProcess::ProcessDecodeDone(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr receivedCodecPacket = event->GetSharedObject(); + if (receivedCodecPacket == nullptr) { + DHLOGE("the received codecPacket of eventId [%{public}d] is null.", EVENT_NO_ACTION); + OnError(); + return; + } + std::vector> dataBuffers = receivedCodecPacket->GetDataBuffers(); + DecodeDone(dataBuffers); +} + void DecodeDataProcess::OnError() { DHLOGD("DecodeDataProcess : OnError."); diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp index 23aaee75fc82765c6ed43639d6d37c29b703a863..3fd6040c68d3b1d2f6d4598a47b5042ca09c8751 100644 --- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp +++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp @@ -92,12 +92,9 @@ bool DecodeDataProcess::IsConvertible(const VideoConfigParams& sourceConfig, con void DecodeDataProcess::InitCodecEvent() { DHLOGD("Init DecodeNode eventBus, and add handler for it."); - eventBusDecode_ = std::make_shared("DeDtProcHandler"); - DCameraCodecEvent codecEvent(*this, std::make_shared()); - eventBusRegHandleDecode_ = eventBusDecode_->AddHandler(codecEvent.GetType(), *this); - - DHLOGD("Add handler for DCamera pipeline eventBus."); - eventBusRegHandlePipeline2Decode_ = eventBusPipeline_->AddHandler(codecEvent.GetType(), *this); + std::shared_ptr decRunner = AppExecFwk::EventRunner::Create(true); + decEventHandler_ = std::make_shared( + decRunner, shared_from_this()); } int32_t DecodeDataProcess::InitDecoder() @@ -335,17 +332,8 @@ void DecodeDataProcess::ReleaseDecoderSurface() void DecodeDataProcess::ReleaseCodecEvent() { - DCameraCodecEvent codecEvent(*this, std::make_shared()); - if (eventBusDecode_ != nullptr) { - eventBusDecode_->RemoveHandler(codecEvent.GetType(), eventBusRegHandleDecode_); - eventBusRegHandleDecode_ = nullptr; - eventBusDecode_ = nullptr; - } - if (eventBusPipeline_ != nullptr) { - eventBusPipeline_->RemoveHandler(codecEvent.GetType(), eventBusRegHandlePipeline2Decode_); - eventBusRegHandlePipeline2Decode_ = nullptr; - eventBusPipeline_ = nullptr; - } + decEventHandler_ = nullptr; + pipeSrcEventHandler_ = nullptr; DHLOGD("Release DecodeNode eventBusDecode and eventBusPipeline end."); } @@ -413,12 +401,11 @@ int32_t DecodeDataProcess::ProcessData(std::vector>& DHLOGD("Feed decoder input buffer failed. Try FeedDecoderInputBuffer again."); std::shared_ptr reFeedInputPacket = std::make_shared(); reFeedInputPacket->SetVideoCodecType(sourceConfig_.GetVideoCodecType()); - DCameraCodecEvent dCamCodecEv(*this, reFeedInputPacket, VideoCodecAction::ACTION_ONCE_AGAIN); - if (eventBusPipeline_ == nullptr) { - DHLOGE("eventBusPipeline_ is nullptr."); - return DCAMERA_BAD_VALUE; - } - eventBusPipeline_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + CHECK_AND_RETURN_RET_LOG(pipeSrcEventHandler_ == nullptr, DCAMERA_BAD_VALUE, + "%{public}s", "pipeSrcEventHandler_ is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_ACTION_ONCE_AGAIN, reFeedInputPacket, 0); + pipeSrcEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); } return DCAMERA_OK; } @@ -530,8 +517,10 @@ void DecodeDataProcess::ReduceWaitDecodeCnt() void DecodeDataProcess::OnSurfaceOutputBufferAvailable(const sptr& surface) { std::shared_ptr bufferPkt = std::make_shared(surface); - DCameraCodecEvent dCamCodecEv(*this, bufferPkt, VideoCodecAction::ACTION_GET_DECODER_OUTPUT_BUFFER); - eventBusDecode_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + CHECK_AND_RETURN_LOG(decEventHandler_ == nullptr, "decEventHandler is nullptr."); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER, bufferPkt, 0); + decEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); } void DecodeDataProcess::GetDecoderOutputBuffer(const sptr& surface) @@ -641,16 +630,17 @@ bool DecodeDataProcess::IsCorrectSurfaceBuffer(const sptr& surBuf void DecodeDataProcess::PostOutputDataBuffers(std::shared_ptr& outputBuffer) { - if (eventBusDecode_ == nullptr || outputBuffer == nullptr) { - DHLOGE("eventBusDecode_ or outputBuffer is null."); + if (decEventHandler_ == nullptr || outputBuffer == nullptr) { + DHLOGE("decEventHandler_ or outputBuffer is null."); return; } std::vector> multiDataBuffers; multiDataBuffers.push_back(outputBuffer); std::shared_ptr transNextNodePacket = std::make_shared(VideoCodecType::NO_CODEC, multiDataBuffers); - DCameraCodecEvent dCamCodecEv(*this, transNextNodePacket, VideoCodecAction::NO_ACTION); - eventBusDecode_->PostEvent(dCamCodecEv, POSTMODE::POST_ASYNC); + AppExecFwk::InnerEvent::Pointer msgEvent = + AppExecFwk::InnerEvent::Get(EVENT_NO_ACTION, transNextNodePacket, 0); + decEventHandler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); DHLOGD("Send video decoder output asynchronous DCameraCodecEvents success."); } @@ -680,40 +670,67 @@ int32_t DecodeDataProcess::DecodeDone(std::vector>& return DCAMERA_OK; } -void DecodeDataProcess::OnEvent(DCameraCodecEvent& ev) +DecodeDataProcess::DecodeDataProcessEventHandler::DecodeDataProcessEventHandler( + const std::shared_ptr &runner, std::shared_ptr decPtr) + : AppExecFwk::EventHandler(runner), decPtrWPtr_(decPtr) { - DHLOGD("Receiving asynchronous DCameraCodecEvents."); - std::shared_ptr receivedCodecPacket = ev.GetCodecPacket(); - VideoCodecAction action = ev.GetAction(); - switch (action) { - case VideoCodecAction::NO_ACTION: { - if (receivedCodecPacket == nullptr) { - DHLOGE("the received codecPacket of action [%{public}d] is null.", action); - OnError(); - return; - } - std::vector> dataBuffers = receivedCodecPacket->GetDataBuffers(); - DecodeDone(dataBuffers); + DHLOGI("Ctor DecodeDataProcessEventHandler."); +} + +void DecodeDataProcess::DecodeDataProcessEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + CHECK_AND_RETURN_LOG(event == nullptr, "event is nullptr."); + uint32_t eventId = event->GetInnerEventId(); + auto decPtr = decPtrWPtr_.lock(); + if (decPtr == nullptr) { + DHLOGE("Can not get strong self ptr"); + return; + } + switch (eventId) { + case EVENT_NO_ACTION: + decPtr->ProcessDecodeDone(event); break; - } - case VideoCodecAction::ACTION_ONCE_AGAIN: + case EVENT_ACTION_ONCE_AGAIN: DHLOGD("Try FeedDecoderInputBuffer again."); - FeedDecoderInputBuffer(); + decPtr->ProcessFeedDecoderInputBuffer(); return; - case VideoCodecAction::ACTION_GET_DECODER_OUTPUT_BUFFER: - if (receivedCodecPacket == nullptr) { - DHLOGE("the received codecPacket of action [%{public}d] is null.", action); - OnError(); - return; - } - GetDecoderOutputBuffer(receivedCodecPacket->GetSurface()); + case EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER: + decPtr->ProcessGetDecoderOutputBuffer(event); break; default: - DHLOGD("The action : %{public}d is not supported.", action); + DHLOGD("The action : %{public}d is not supported.", eventId); return; } } +void DecodeDataProcess::ProcessFeedDecoderInputBuffer() +{ + FeedDecoderInputBuffer(); +} + +void DecodeDataProcess::ProcessGetDecoderOutputBuffer(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr receivedCodecPacket = event->GetSharedObject(); + if (receivedCodecPacket == nullptr) { + DHLOGE("the received codecPacket of eventId [%{public}d] is null.", EVENT_ACTION_GET_DECODER_OUTPUT_BUFFER); + OnError(); + return; + } + GetDecoderOutputBuffer(receivedCodecPacket->GetSurface()); +} + +void DecodeDataProcess::ProcessDecodeDone(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr receivedCodecPacket = event->GetSharedObject(); + if (receivedCodecPacket == nullptr) { + DHLOGE("the received codecPacket of eventId [%{public}d] is null.", EVENT_NO_ACTION); + OnError(); + return; + } + std::vector> dataBuffers = receivedCodecPacket->GetDataBuffers(); + DecodeDone(dataBuffers); +} + void DecodeDataProcess::OnError() { DHLOGD("DecodeDataProcess : OnError."); diff --git a/services/data_process/test/unittest/common/pipeline_node/decode_data_process_test.cpp b/services/data_process/test/unittest/common/pipeline_node/decode_data_process_test.cpp index 9af0fcc9138a78e48c607f20da6d8be9ea59dd10..471b3126065cc9513d100efdcc14b02cf6bb1e9f 100644 --- a/services/data_process/test/unittest/common/pipeline_node/decode_data_process_test.cpp +++ b/services/data_process/test/unittest/common/pipeline_node/decode_data_process_test.cpp @@ -34,7 +34,7 @@ public: void TearDown(); std::shared_ptr testDecodeDataProcess_; - std::shared_ptr eventBusPipeline_; + std::shared_ptr pipeEventHandler_; std::shared_ptr sourcePipeline_; }; @@ -60,8 +60,10 @@ void DecodeDataProcessTest::SetUp(void) { DHLOGI("DecodeDataProcessTest SetUp"); sourcePipeline_ = std::make_shared(); - eventBusPipeline_ = std::make_shared("TestDecodeHandler"); - testDecodeDataProcess_ = std::make_shared(eventBusPipeline_, sourcePipeline_); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + pipeEventHandler_ = std::make_shared( + runner, sourcePipeline_); + testDecodeDataProcess_ = std::make_shared(pipeEventHandler_, sourcePipeline_); } void DecodeDataProcessTest::TearDown(void) @@ -69,7 +71,7 @@ void DecodeDataProcessTest::TearDown(void) DHLOGI("DecodeDataProcessTest TearDown"); usleep(SLEEP_TIME); sourcePipeline_ = nullptr; - eventBusPipeline_ = nullptr; + pipeEventHandler_ = nullptr; testDecodeDataProcess_ = nullptr; }