From bf352979aef8d920b4b597a1061dda94dfaaaf5e Mon Sep 17 00:00:00 2001 From: yangli Date: Sat, 22 Jul 2023 19:38:40 +0800 Subject: [PATCH 1/7] 0722 Signed-off-by: yangli --- .../2.0/include/screenregion.h | 78 ---- .../screenregionmgr/2.0/src/screenregion.cpp | 384 ---------------- .../dscreenmgr/2.0/include/dscreen_test.h | 39 ++ .../dscreenmgr/2.0/src/dscreen_test.cpp | 428 ++++++++++++++++++ .../sourceservice/dscreenmgr/BUILD.gn | 1 + 5 files changed, 468 insertions(+), 462 deletions(-) delete mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h delete mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h deleted file mode 100644 index fba417d2..00000000 --- a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (c) 2022-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. - */ - -#ifndef OHOS_DSCREEN_SCREEN_REGION_V2_0_H -#define OHOS_DSCREEN_SCREEN_REGION_V2_0_H - -#include - -#include "surface.h" - -#include "2.0/include/av_receiver_engine_adapter.h" -#include "distributed_hardware_fwk_kit.h" -#include "dscreen_maprelation.h" -#include "screen_client_common.h" -#include "video_param.h" - -namespace OHOS { -namespace DistributedHardware { -namespace V2_0 { -class ScreenRegion : public AVReceiverAdapterCallback, public std::enable_shared_from_this { -public: - ScreenRegion(const std::string &remoteDevId); - ~ScreenRegion(); - - // interfaces from AVReceiverAdapterCallback - void OnEngineEvent(DScreenEventType event, const std::string &content) override; - void OnEngineMessage(const std::shared_ptr &message) override; - void OnEngineDataDone(const std::shared_ptr &buffer) override; - void GetWSBuffer(sptr &wsBuffer, const std::shared_ptr &buffer); - - int32_t Release(); - int32_t InitReceiverEngine(IAVEngineProvider *providerPtr); - int32_t GetWindowId(); - uint64_t GetScreenId(); - std::string GetRemoteDevId(); - std::shared_ptr GetVideoParam(); - std::shared_ptr GetWindowProperty(); - -private: - int32_t StartReceiverEngine(const std::string &content); - int32_t StopReceiverEngine(); - int32_t SetUp(const std::string &content); - int32_t ConfigWindow(); - bool CheckContentJson(json &contentJson); - void PublishMessage(const DHTopic topic, const uint64_t &screenId, const std::string &remoteDevId, - const int32_t &windowId, std::shared_ptr windowProperty); - -private: - uint64_t screenId_; - uint64_t displayId_; - std::string remoteDevId_; - int32_t windowId_ = INVALID_WINDOW_ID; - uint32_t alignedHeight_ = 0; - bool isRunning = false; - std::atomic frameNumber_; - - sptr windowSurface_ = nullptr; - std::shared_ptr videoParam_ = nullptr; - std::shared_ptr windowProperty_ = nullptr; - std::shared_ptr mapRelation_ = nullptr; - std::shared_ptr receiverAdapter_ = nullptr; -}; -} // namespace V2_0 -} // namespace DistributedHardware -} // namespace OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp deleted file mode 100644 index 413cf2ac..00000000 --- a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp +++ /dev/null @@ -1,384 +0,0 @@ -/* - * Copyright (c) 2022-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. - */ - -#include "2.0/include/screenregion.h" - -#include -#include "display_manager.h" -#include "dscreen_constants.h" -#include "dscreen_errcode.h" -#include "dscreen_fwkkit.h" -#include "dscreen_hisysevent.h" -#include "dscreen_log.h" -#include "dscreen_json_util.h" -#include "dscreen_util.h" -#include "screen.h" -#include "screen_client.h" -#include "screen_client_common.h" - -namespace OHOS { -namespace DistributedHardware { -namespace V2_0 { -ScreenRegion::ScreenRegion(const std::string &remoteDevId) : screenId_(0), displayId_(0), remoteDevId_(remoteDevId) -{ - DHLOGI("ScreenRegion ctor."); - frameNumber_.store(0); -} - -ScreenRegion::~ScreenRegion() -{ - DHLOGI("ScreenRegion dctor."); - if (receiverAdapter_ != nullptr) { - receiverAdapter_->Release(); - } - receiverAdapter_ = nullptr; - frameNumber_.store(0); -} - -int32_t ScreenRegion::InitReceiverEngine(IAVEngineProvider *providerPtr) -{ - DHLOGI("InitReceiverEngine enter."); - if (receiverAdapter_ == nullptr) { - receiverAdapter_ = std::make_shared(); - } - int32_t ret = receiverAdapter_->Initialize(providerPtr, remoteDevId_); - if (ret != DH_SUCCESS) { - DHLOGE("initialize av receiver adapter failed."); - return ERR_DH_AV_TRANS_INIT_FAILED; - } - return receiverAdapter_->RegisterAdapterCallback(shared_from_this()); -} - -int32_t ScreenRegion::Release() -{ - DHLOGI("ScreenRegion::Release remoteDevId: %s", GetAnonyString(remoteDevId_).c_str()); - if (!isRunning) { - DHLOGI("ScreenRegion not running, no need release"); - return DH_SUCCESS; - } - ScreenClient::GetInstance().RemoveWindow(windowId_); - - if (receiverAdapter_ == nullptr) { - DHLOGE("av transport receiver adapter is nullptr."); - return ERR_DH_AV_TRANS_NULL_VALUE; - } - - int32_t ret = receiverAdapter_->Stop(); - if (ret != DH_SUCCESS) { - DHLOGE("sink trans stop failed."); - } - - ret = receiverAdapter_->Release(); - if (ret != DH_SUCCESS) { - DHLOGE("release av receiver adapter failed."); - } - - isRunning = false; - return DH_SUCCESS; -} - -int32_t ScreenRegion::StartReceiverEngine(const std::string &content) -{ - DHLOGI("StartReceiverEngine enter."); - if (receiverAdapter_ == nullptr) { - DHLOGE("av transport receiver adapter is null."); - return ERR_DH_AV_TRANS_NULL_VALUE; - } - int32_t ret = SetUp(content); - if (ret != DH_SUCCESS) { - DHLOGE("set up av receiver parameter failed."); - return ERR_DH_AV_TRANS_SETUP_FAILED; - } - ret = receiverAdapter_->Start(); - if (ret != DH_SUCCESS) { - DHLOGE("start av receiver engine failed."); - return ERR_DH_AV_TRANS_START_FAILED; - } - isRunning = true; - PublishMessage(DHTopic::TOPIC_SINK_PROJECT_WINDOW_INFO, screenId_, remoteDevId_, windowId_, windowProperty_); - return DH_SUCCESS; -} - -int32_t ScreenRegion::StopReceiverEngine() -{ - DHLOGI("StopReceiverEngine, remoteDevId: %s, screenId is: %" PRIu64, - GetAnonyString(remoteDevId_).c_str(), screenId_); - - int32_t ret = ScreenClient::GetInstance().RemoveWindow(windowId_); - if (ret != DH_SUCCESS) { - DHLOGE("remove window failed."); - } - - if (receiverAdapter_ == nullptr) { - DHLOGE("av transport receiver adapter is null."); - return ERR_DH_AV_TRANS_NULL_VALUE; - } - return receiverAdapter_->Stop(); -} - -int32_t ScreenRegion::SetUp(const std::string &content) -{ - json contentJson = json::parse(content, nullptr, false); - if (contentJson.is_discarded()) { - return ERR_DH_SCREEN_INPUT_PARAM_INVALID; - } - if (!CheckContentJson(contentJson) || !contentJson.contains(KEY_VIDEO_PARAM) || - !contentJson.contains(KEY_MAPRELATION)) { - return ERR_DH_SCREEN_INPUT_PARAM_INVALID; - } - screenId_ = contentJson[KEY_SCREEN_ID].get(); - displayId_ = Rosen::DisplayManager::GetInstance().GetDefaultDisplayId(); - videoParam_ = std::make_shared(contentJson[KEY_VIDEO_PARAM].get()); - mapRelation_ = std::make_shared(contentJson[KEY_MAPRELATION].get()); - - int32_t ret = ConfigWindow(); - if (ret != DH_SUCCESS) { - DHLOGE("config dscreen region window failed."); - return ret; - } - std::string codecType; - if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H265) { - codecType = MIME_VIDEO_H265; - } else if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H264) { - codecType = MIME_VIDEO_H264; - } else { - codecType = MIME_VIDEO_RAW; - } - std::string pixelFormat; - if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_YUVI420) { - pixelFormat = VIDEO_FORMAT_YUVI420; - } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV12) { - pixelFormat = VIDEO_FORMAT_NV12; - } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV21) { - pixelFormat = VIDEO_FORMAT_NV21; - } else { - pixelFormat = VIDEO_FORMAT_RGBA8888; - } - receiverAdapter_->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, codecType); - receiverAdapter_->SetParameter(AVTransTag::VIDEO_PIXEL_FORMAT, pixelFormat); - receiverAdapter_->SetParameter(AVTransTag::VIDEO_WIDTH, std::to_string(videoParam_->GetVideoWidth())); - receiverAdapter_->SetParameter(AVTransTag::VIDEO_HEIGHT, std::to_string(videoParam_->GetVideoHeight())); - receiverAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, std::to_string(videoParam_->GetFps())); - receiverAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SCREEN); - - alignedHeight_ = videoParam_->GetVideoHeight(); - if (alignedHeight_ % ALIGNEDBITS != 0) { - alignedHeight_ = ((alignedHeight_ / ALIGNEDBITS) +1) * ALIGNEDBITS; - } - return DH_SUCCESS; -} - -int32_t ScreenRegion::ConfigWindow() -{ - DHLOGI("ConfigWindow enter"); - std::shared_ptr windowProperty = std::make_shared(); - windowProperty->displayId = displayId_; - if (mapRelation_ == nullptr) { - DHLOGE("mapRelation is nullptr."); - return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; - } - ScreenRect screenRect = mapRelation_->GetScreenRect(); - windowProperty->startX = screenRect.startX; - windowProperty->startY = screenRect.startY; - windowProperty->width = screenRect.width; - windowProperty->height = screenRect.height; - windowProperty_ = windowProperty; - - windowId_ = ScreenClient::GetInstance().AddWindow(windowProperty); - if (windowId_ < 0) { - DHLOGE("AddWindow failed."); - ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "AddWindow failed."); - return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; - } - int32_t ret = ScreenClient::GetInstance().ShowWindow(windowId_); - if (ret != DH_SUCCESS) { - DHLOGE("show window failed."); - ReportOptFail(DSCREEN_OPT_FAIL, ret, "show window failed."); - return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; - } - - sptr surface = ScreenClient::GetInstance().GetSurface(windowId_); - if (surface == nullptr) { - DHLOGE("get window surface failed."); - ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "get window surface failed."); - return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; - } - windowSurface_ = surface; - return DH_SUCCESS; -} - -void ScreenRegion::PublishMessage(const DHTopic topic, const uint64_t &screenId, - const std::string &remoteDevId, const int32_t &windowId, std::shared_ptr windowProperty) -{ - DHLOGI("ScreenRegion PublishMessage"); - if (DScreenFwkKit::GetInstance().GetDHFwkKit() == nullptr) { - DHLOGE("GetDHFwkKit fail."); - return; - } - json messageJosn; - std::string message; - messageJosn[SOURCE_WIN_ID] = screenId; - messageJosn[SOURCE_DEV_ID] = remoteDevId; - messageJosn[SINK_SHOW_WIN_ID] = windowId; - messageJosn[SINK_PROJ_SHOW_WIDTH] = windowProperty->width; - messageJosn[SINK_PROJ_SHOW_HEIGHT] = windowProperty->height; - messageJosn[SINK_WIN_SHOW_X] = windowProperty->startX; - messageJosn[SINK_WIN_SHOW_Y] = windowProperty->startY; - message = messageJosn.dump(); - DScreenFwkKit::GetInstance().GetDHFwkKit()->PublishMessage(topic, message); -} - -void ScreenRegion::OnEngineEvent(DScreenEventType event, const std::string &content) -{ - (void)content; - if (event == DScreenEventType::ENGINE_ERROR) { - StopReceiverEngine(); - } -} - -void ScreenRegion::OnEngineMessage(const std::shared_ptr &message) -{ - if (message == nullptr) { - DHLOGE("received engine message is null."); - return; - } - - DHLOGI("On source device engine message received, message type =%d.", message->type_); - if (message->type_ == DScreenMsgType::START_MIRROR) { - int32_t ret = StartReceiverEngine(message->content_); - DScreenMsgType msgType = (ret == DH_SUCCESS) ? DScreenMsgType::START_MIRROR_SUCCESS : - DScreenMsgType::START_MIRROR_FAIL; - - json paramJson; - paramJson[KEY_DEV_ID] = remoteDevId_; - auto avMessage = std::make_shared(msgType, paramJson.dump(), remoteDevId_); - receiverAdapter_->SendMessageToRemote(avMessage); - } else if (message->type_ == DScreenMsgType::STOP_MIRROR) { - StopReceiverEngine(); - } -} - -void ScreenRegion::GetWSBuffer(sptr &wsBuffer, const std::shared_ptr &buffer) -{ - auto bufferData = buffer->GetBufferData(0); - auto bufferAddr = bufferData->GetAddress(); - auto wsBufAddr = static_cast(wsBuffer->GetVirAddr()); - uint32_t wsBufSize = wsBuffer->GetSize(); - uint32_t srcOffset = 0; - uint32_t dstOffset = 0; - uint32_t alignedWidth = videoParam_->GetVideoWidth(); - uint32_t chromaOffset = videoParam_->GetVideoWidth() * videoParam_->GetVideoHeight(); - - for (unsigned int yh = 0 ; yh < videoParam_->GetVideoHeight(); yh++) { - int32_t ret = memcpy_s(wsBufAddr + dstOffset, chromaOffset - dstOffset, - bufferAddr + srcOffset, videoParam_->GetVideoWidth()); - if (ret != EOK) { - DHLOGE("memcpy video buffer y data failed,ret: %d.", ret); - windowSurface_->CancelBuffer(wsBuffer); - return; - } - dstOffset += videoParam_->GetVideoWidth(); - srcOffset += alignedWidth; - } - - dstOffset = chromaOffset; - srcOffset = alignedWidth * alignedHeight_; - - for (unsigned int uvh = 0 ; uvh < videoParam_->GetVideoHeight() / TWO; uvh++) { - int32_t ret = memcpy_s(wsBufAddr + dstOffset, wsBufSize - dstOffset, - bufferAddr + srcOffset, videoParam_->GetVideoWidth()); - if (ret != EOK) { - DHLOGE("memcpy video buffer uv data failed,ret: %d.", ret); - windowSurface_->CancelBuffer(wsBuffer); - return; - } - dstOffset += videoParam_->GetVideoWidth(); - srcOffset += alignedWidth; - } -} - -void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer) -{ - ++frameNumber_; - DHLOGI("OnEngineDataDone enter"); - if (buffer == nullptr) { - DHLOGE("received video buffer data is nullptr."); - return; - } - if (windowSurface_ == nullptr) { - DHLOGE("window surface is nullptr."); - return; - } - sptr wsBuffer = nullptr; - int32_t releaseFence = -1; - OHOS::BufferRequestConfig requestConfig = { - .width = videoParam_->GetVideoWidth(), - .height = videoParam_->GetVideoHeight(), - .strideAlignment = STRIDE_ALIGNMENT, - .format = GRAPHIC_PIXEL_FMT_YCRCB_420_SP, - .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, - }; - SurfaceError surfaceErr = windowSurface_->RequestBuffer(wsBuffer, releaseFence, requestConfig); - if (surfaceErr != SURFACE_ERROR_OK || wsBuffer == nullptr) { - DHLOGE("surface request buffer failed, surfaceErr: %d.", surfaceErr); - windowSurface_->CancelBuffer(wsBuffer); - return; - } - GetWSBuffer(wsBuffer, buffer); - BufferFlushConfig flushConfig = { {0, 0, wsBuffer->GetWidth(), wsBuffer->GetHeight()}, 0}; - surfaceErr = windowSurface_->FlushBuffer(wsBuffer, -1, flushConfig); - if (surfaceErr != SURFACE_ERROR_OK) { - DHLOGE("surface flush buffer failed, surfaceErr: %d.", surfaceErr); - windowSurface_->CancelBuffer(wsBuffer); - return; - } - DHLOGI("Fill video buffer data to window surface success. frameNumber: %zu", frameNumber_.load()); -} - -uint64_t ScreenRegion::GetScreenId() -{ - return screenId_; -} - -std::string ScreenRegion::GetRemoteDevId() -{ - return remoteDevId_; -} - -std::shared_ptr ScreenRegion::GetVideoParam() -{ - return videoParam_; -} - -int32_t ScreenRegion::GetWindowId() -{ - return windowId_; -} - -std::shared_ptr ScreenRegion::GetWindowProperty() -{ - return windowProperty_; -} - -bool ScreenRegion::CheckContentJson(json &contentJson) -{ - if (!IsUInt64(contentJson, KEY_SCREEN_ID)) { - return false; - } - return true; -} -} // namespace V1_0 -} // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_test.h new file mode 100644 index 00000000..4e348dd5 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_test.h @@ -0,0 +1,39 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_TEST_V2_0_H +#define OHOS_DSCREEN_TEST_V2_0_H + +#include +#include + +#define private public +#include "2.0/include/dscreen.h" +#undef private +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class DScreenTestV2 : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + std::shared_ptr dScreen_ = nullptr; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp new file mode 100644 index 00000000..ed8f67fa --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -0,0 +1,428 @@ +/* + * 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. + */ + +#include "2.0/include/dscreen_test.h" + +#define private public +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "2.0/include/dscreen_manager.h" +#include "common/include/screen_manager_adapter.h" +#include "dscreen_util.h" +#include "video_param.h" +#include "screen_source_trans.h" +#undef private + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +constexpr static int32_t videoDataNum = 100; +void DScreenTestV2::SetUpTestCase(void) {} + +void DScreenTestV2::TearDownTestCase(void) {} + +void DScreenTestV2::SetUp(void) +{ + std::string devId = "devId"; + std::string dhId = "dhId"; + std::shared_ptr dScreenCallback = std::make_shared(); + dScreen_ = std::make_shared(devId, dhId, dScreenCallback); + dScreen_->videoParam_ = std::make_shared(); + dScreen_->videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264); + dScreen_->videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420); + dScreen_->videoParam_->SetVideoHeight(videoDataNum); + dScreen_->videoParam_->SetVideoWidth(videoDataNum); + dScreen_->videoParam_->SetScreenHeight(videoDataNum); + dScreen_->videoParam_->SetScreenWidth(videoDataNum); + dScreen_->videoParam_->SetFps(videoDataNum); + dScreen_->devId_ = "peerDevId"; +} + +void DScreenTestV2::TearDown(void) {} + +/** + * @tc.name: AddTask_001 + * @tc.desc: Verify the AddTask function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, AddTask_001, TestSize.Level1) +{ + + dScreen_->GetVideoParam(); + + DScreenState state = ENABLING; + dScreen_->SetState(state); + + dScreen_->GetState(); + dScreen_->GetScreenId(); + dScreen_->GetDHId(); + dScreen_->GetDevId(); + + std::shared_ptr task = nullptr; + int32_t ret = dScreen_->AddTask(task); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, ret); + std::string reqId = "reqId"; + std::string attrs = "attrs"; + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleTask_001 + * @tc.desc: Verify the HandleTask function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + int32_t ret = dScreen_->HandleTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISABLE, reqId, attrs)); + dScreen_->HandleTask(std::make_shared(TaskType::TASK_CONNECT, reqId, attrs)); + dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs)); + dScreen_->HandleTask(std::make_shared(TaskType::TASK_ERROR, reqId, attrs)); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleEnable_001 + * @tc.desc: Verify the HandleEnable function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleEnable_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + dScreen_->dscreenCallback_ = nullptr; + std::string param = "param"; + std::string taskId = "taskId"; + dScreen_->HandleEnable(param, taskId); + dScreenCallback_ = std::make_shared(); + DScreenState state = ENABLING; + dScreen_->SetState(state); + dScreen_->HandleEnable(param, taskId); + + DScreenState state = state; + dScreen_->SetState(state); + dScreen_->HandleEnable(param, taskId); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleEnable_002 + * @tc.desc: Verify the HandleEnable function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleEnable_002, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + dScreenCallback_ = std::make_shared(); + std::shared_ptr task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); + dScreen_->curState_ = curState; + dScreen_->videoParam_ = nullptr; + std::string param = "{\"codecType\":\"OMX_rk_video_encoder_avc\", \ + \"screenHeight\":1280, \"screenVersion\":\"1.0\", \"screenWidth\":720}"; + std::string taskId = "taskId"; + dScreen_->HandleEnable(param, taskId); + int32_t ret = dScreen_->AddTask(task); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleDisable_001 + * @tc.desc: Verify the HandleDisable function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleDisable_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + std::string taskId = "taskId"; + dScreen_->HandleDisable(taskId); + dScreenCallback_ = std::make_shared(); + dScreen_->HandleDisable(taskId); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleConnect_001 + * @tc.desc: Verify the HandleConnect function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleConnect_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + DScreenState state = state; + dScreen_->SetState(state); + dScreen_->HandleConnect(); + + DScreenState state = ENABLED; + dScreen_->SetState(state); + dScreen_->HandleConnect(); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: HandleDisConnect_001 + * @tc.desc: Verify the HandleDisConnect function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, HandleDisConnect_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + DScreenState state = state; + dScreen_->SetState(state); + dScreen_->HandleDisConnect(); + + DScreenState state = CONNECTED; + dScreen_->SetState(state); + dScreen_->HandleDisConnect(); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: ConfigSurface_001 + * @tc.desc: Verify the ConfigSurface function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, ConfigSurface_001, TestSize.Level1) +{ + int32_t ret = dScreen_->ConfigSurface(); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: RemoveSurface_001 + * @tc.desc: Verify the RemoveSurface function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, RemoveSurface_001, TestSize.Level1) +{ + int32_t ret = dScreen_->RemoveSurface(); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); + + std::shared_ptr dScreenCallback = std::make_shared(); + ConsumBufferListener consumBufferListener; + ConsumBufferListener consumBufferListener.dScreen_ = std::make_shared(devId, dhId, dScreenCallback); + DScreenState state = CONNECTED; + consumBufferListener.dScreen_->SetState(state); + consumBufferListener.OnBufferAvailable(); + + ret = dScreen_->ConfigSurface(); + dScreen_->RemoveSurface(); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: ConsumeSurface_001 + * @tc.desc: Verify the ConsumeSurface function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, ConsumeSurface_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + dScreen_->ConsumeSurface(); + dScreen_.senderAdapter_ = std::make_shared(); + dScreen_->ConsumeSurface(); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: InitSenderEngine_001 + * @tc.desc: Verify the InitSenderEngine function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, InitSenderEngine_001, TestSize.Level1) +{ + int32_t ret = dScreen_->InitSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); +} + +/** + * @tc.name: StartSenderEngine_001 + * @tc.desc: Verify the StartSenderEngine function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, StartSenderEngine_001, TestSize.Level1) +{ + int32_t ret = dScreen_->StartSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + dScreen_.senderAdapter_ = std::make_shared(); + ret = dScreen_->StartSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); +} + +/** + * @tc.name: StopSenderEngine_001 + * @tc.desc: Verify the StopSenderEngine function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, StopSenderEngine_001, TestSize.Level1) +{ + std::string codecType = "codecType"; + std::string pixelFormat = "pixelFormat"; + dScreen_->ChooseParameter(); + int32_t ret = dScreen_->StopSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + dScreen_.senderAdapter_ = std::make_shared(); + ret = dScreen_->StopSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); +} + +/** + * @tc.name: SetUp_001 + * @tc.desc: Verify the SetUp function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, SetUp_001, TestSize.Level1) +{ + int32_t ret = dScreen_->SetUp(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + dScreen_.senderAdapter_ = std::make_shared(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); +} + +/** + * @tc.name: WaitForSinkStarted_001 + * @tc.desc: Verify the WaitForSinkStarted function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, WaitForSinkStarted_001, TestSize.Level1) +{ + int32_t ret = dScreen_->WaitForSinkStarted(); + EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); +} + +/** + * @tc.name: NegotiateCodecType_001 + * @tc.desc: Verify the NegotiateCodecType function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, NegotiateCodecType_001, TestSize.Level1) +{ + std::string remoteCodecInfoStr = "remoteCodecInfoStr"; + int32_t ret = dScreen_->NegotiateCodecType(remoteCodecInfoStr); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL, ret); +} + +/** + * @tc.name: NegotiateCodecType_002 + * @tc.desc: Verify the NegotiateCodecType function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, NegotiateCodecType_002, TestSize.Level1) +{ + std::string remoteCodecInfoStr = "{\"codecType\":\"[\"OMX_rk_video_encoder_avc\", \"OMX_rk_video_encoder_hevc\", \ + \"avenc_mpeg4\"]\"}"; + dScreen_->TaskThreadLoop(); + int32_t ret = dScreen_->NegotiateCodecType(remoteCodecInfoStr); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL, ret); + +} + +/** + * @tc.name: CheckJsonData_001 + * @tc.desc: Verify the CheckJsonData function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, CheckJsonData_001, TestSize.Level1) +{ + json attrJson; + attrJson["screenWidth"] = width; + attrJson["screenHeight"] = heigth; + attrJson["codecType"] = 0; + EXPECT_EQ(true, dScreen_->CheckJsonData(attrJson)); +} + +/** + * @tc.name: CheckJsonData_002 + * @tc.desc: Verify the CheckJsonData function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, CheckJsonData_002, TestSize.Level1) +{ + json attrJson; + std::string taskId = "taskId"; + EXPECT_EQ(false, dScreen_->CheckJsonData(attrJson)); +} + +/** + * @tc.name: CheckJsonData_003 + * @tc.desc: Verify the CheckJsonData function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, CheckJsonData_003, TestSize.Level1) +{ + json attrJson; + attrJson["dhid"] = "dhid"; + std::string taskId = "taskId"; + EXPECT_EQ(false, dScreen_->CheckJsonData(attrJson)); +} + +/** + * @tc.name: OnEngineEvent_001 + * @tc.desc: Verify the OnEngineEvent function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTestV2, OnEngineEvent_001, TestSize.Level1) +{ + std::string reqId = "reqId"; + std::string attrs = "attrs"; + DScreenEventType event; + event = ENGINE_ERROR; + std::string content = "content"; + dScreen_->OnEngineEvent(event, content); + event = TRANS_CHANNEL_CLOSED; + dScreen_->OnEngineEvent(event, content); + int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + EXPECT_EQ(DH_SUCCESS, ret); +} +} +} +} \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn index 480d2027..f929eecb 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn @@ -61,6 +61,7 @@ ohos_unittest("DscreenMgrTest") { "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/screen_manager_adapter_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/av_sender_engine_adapter_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp", ] configs = [ ":module_private_config" ] -- Gitee From f9ddbca60df07a2f90a5e3b2510b4b2e8cdadc01 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 10:20:28 +0800 Subject: [PATCH 2/7] 0724 Signed-off-by: yangli --- .../2.0/include/screenregion.h | 78 ++++ .../screenregionmgr/2.0/src/screenregion.cpp | 384 ++++++++++++++++++ 2 files changed, 462 insertions(+) create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h new file mode 100644 index 00000000..fba417d2 --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2022-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. + */ + +#ifndef OHOS_DSCREEN_SCREEN_REGION_V2_0_H +#define OHOS_DSCREEN_SCREEN_REGION_V2_0_H + +#include + +#include "surface.h" + +#include "2.0/include/av_receiver_engine_adapter.h" +#include "distributed_hardware_fwk_kit.h" +#include "dscreen_maprelation.h" +#include "screen_client_common.h" +#include "video_param.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class ScreenRegion : public AVReceiverAdapterCallback, public std::enable_shared_from_this { +public: + ScreenRegion(const std::string &remoteDevId); + ~ScreenRegion(); + + // interfaces from AVReceiverAdapterCallback + void OnEngineEvent(DScreenEventType event, const std::string &content) override; + void OnEngineMessage(const std::shared_ptr &message) override; + void OnEngineDataDone(const std::shared_ptr &buffer) override; + void GetWSBuffer(sptr &wsBuffer, const std::shared_ptr &buffer); + + int32_t Release(); + int32_t InitReceiverEngine(IAVEngineProvider *providerPtr); + int32_t GetWindowId(); + uint64_t GetScreenId(); + std::string GetRemoteDevId(); + std::shared_ptr GetVideoParam(); + std::shared_ptr GetWindowProperty(); + +private: + int32_t StartReceiverEngine(const std::string &content); + int32_t StopReceiverEngine(); + int32_t SetUp(const std::string &content); + int32_t ConfigWindow(); + bool CheckContentJson(json &contentJson); + void PublishMessage(const DHTopic topic, const uint64_t &screenId, const std::string &remoteDevId, + const int32_t &windowId, std::shared_ptr windowProperty); + +private: + uint64_t screenId_; + uint64_t displayId_; + std::string remoteDevId_; + int32_t windowId_ = INVALID_WINDOW_ID; + uint32_t alignedHeight_ = 0; + bool isRunning = false; + std::atomic frameNumber_; + + sptr windowSurface_ = nullptr; + std::shared_ptr videoParam_ = nullptr; + std::shared_ptr windowProperty_ = nullptr; + std::shared_ptr mapRelation_ = nullptr; + std::shared_ptr receiverAdapter_ = nullptr; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp new file mode 100644 index 00000000..413cf2ac --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp @@ -0,0 +1,384 @@ +/* + * Copyright (c) 2022-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. + */ + +#include "2.0/include/screenregion.h" + +#include +#include "display_manager.h" +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_fwkkit.h" +#include "dscreen_hisysevent.h" +#include "dscreen_log.h" +#include "dscreen_json_util.h" +#include "dscreen_util.h" +#include "screen.h" +#include "screen_client.h" +#include "screen_client_common.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +ScreenRegion::ScreenRegion(const std::string &remoteDevId) : screenId_(0), displayId_(0), remoteDevId_(remoteDevId) +{ + DHLOGI("ScreenRegion ctor."); + frameNumber_.store(0); +} + +ScreenRegion::~ScreenRegion() +{ + DHLOGI("ScreenRegion dctor."); + if (receiverAdapter_ != nullptr) { + receiverAdapter_->Release(); + } + receiverAdapter_ = nullptr; + frameNumber_.store(0); +} + +int32_t ScreenRegion::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + receiverAdapter_ = std::make_shared(); + } + int32_t ret = receiverAdapter_->Initialize(providerPtr, remoteDevId_); + if (ret != DH_SUCCESS) { + DHLOGE("initialize av receiver adapter failed."); + return ERR_DH_AV_TRANS_INIT_FAILED; + } + return receiverAdapter_->RegisterAdapterCallback(shared_from_this()); +} + +int32_t ScreenRegion::Release() +{ + DHLOGI("ScreenRegion::Release remoteDevId: %s", GetAnonyString(remoteDevId_).c_str()); + if (!isRunning) { + DHLOGI("ScreenRegion not running, no need release"); + return DH_SUCCESS; + } + ScreenClient::GetInstance().RemoveWindow(windowId_); + + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is nullptr."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + + int32_t ret = receiverAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("sink trans stop failed."); + } + + ret = receiverAdapter_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("release av receiver adapter failed."); + } + + isRunning = false; + return DH_SUCCESS; +} + +int32_t ScreenRegion::StartReceiverEngine(const std::string &content) +{ + DHLOGI("StartReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = SetUp(content); + if (ret != DH_SUCCESS) { + DHLOGE("set up av receiver parameter failed."); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + ret = receiverAdapter_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("start av receiver engine failed."); + return ERR_DH_AV_TRANS_START_FAILED; + } + isRunning = true; + PublishMessage(DHTopic::TOPIC_SINK_PROJECT_WINDOW_INFO, screenId_, remoteDevId_, windowId_, windowProperty_); + return DH_SUCCESS; +} + +int32_t ScreenRegion::StopReceiverEngine() +{ + DHLOGI("StopReceiverEngine, remoteDevId: %s, screenId is: %" PRIu64, + GetAnonyString(remoteDevId_).c_str(), screenId_); + + int32_t ret = ScreenClient::GetInstance().RemoveWindow(windowId_); + if (ret != DH_SUCCESS) { + DHLOGE("remove window failed."); + } + + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + return receiverAdapter_->Stop(); +} + +int32_t ScreenRegion::SetUp(const std::string &content) +{ + json contentJson = json::parse(content, nullptr, false); + if (contentJson.is_discarded()) { + return ERR_DH_SCREEN_INPUT_PARAM_INVALID; + } + if (!CheckContentJson(contentJson) || !contentJson.contains(KEY_VIDEO_PARAM) || + !contentJson.contains(KEY_MAPRELATION)) { + return ERR_DH_SCREEN_INPUT_PARAM_INVALID; + } + screenId_ = contentJson[KEY_SCREEN_ID].get(); + displayId_ = Rosen::DisplayManager::GetInstance().GetDefaultDisplayId(); + videoParam_ = std::make_shared(contentJson[KEY_VIDEO_PARAM].get()); + mapRelation_ = std::make_shared(contentJson[KEY_MAPRELATION].get()); + + int32_t ret = ConfigWindow(); + if (ret != DH_SUCCESS) { + DHLOGE("config dscreen region window failed."); + return ret; + } + std::string codecType; + if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H265) { + codecType = MIME_VIDEO_H265; + } else if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H264) { + codecType = MIME_VIDEO_H264; + } else { + codecType = MIME_VIDEO_RAW; + } + std::string pixelFormat; + if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_YUVI420) { + pixelFormat = VIDEO_FORMAT_YUVI420; + } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV12) { + pixelFormat = VIDEO_FORMAT_NV12; + } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV21) { + pixelFormat = VIDEO_FORMAT_NV21; + } else { + pixelFormat = VIDEO_FORMAT_RGBA8888; + } + receiverAdapter_->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, codecType); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_PIXEL_FORMAT, pixelFormat); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_WIDTH, std::to_string(videoParam_->GetVideoWidth())); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_HEIGHT, std::to_string(videoParam_->GetVideoHeight())); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, std::to_string(videoParam_->GetFps())); + receiverAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SCREEN); + + alignedHeight_ = videoParam_->GetVideoHeight(); + if (alignedHeight_ % ALIGNEDBITS != 0) { + alignedHeight_ = ((alignedHeight_ / ALIGNEDBITS) +1) * ALIGNEDBITS; + } + return DH_SUCCESS; +} + +int32_t ScreenRegion::ConfigWindow() +{ + DHLOGI("ConfigWindow enter"); + std::shared_ptr windowProperty = std::make_shared(); + windowProperty->displayId = displayId_; + if (mapRelation_ == nullptr) { + DHLOGE("mapRelation is nullptr."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + ScreenRect screenRect = mapRelation_->GetScreenRect(); + windowProperty->startX = screenRect.startX; + windowProperty->startY = screenRect.startY; + windowProperty->width = screenRect.width; + windowProperty->height = screenRect.height; + windowProperty_ = windowProperty; + + windowId_ = ScreenClient::GetInstance().AddWindow(windowProperty); + if (windowId_ < 0) { + DHLOGE("AddWindow failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "AddWindow failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + int32_t ret = ScreenClient::GetInstance().ShowWindow(windowId_); + if (ret != DH_SUCCESS) { + DHLOGE("show window failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ret, "show window failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + + sptr surface = ScreenClient::GetInstance().GetSurface(windowId_); + if (surface == nullptr) { + DHLOGE("get window surface failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "get window surface failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + windowSurface_ = surface; + return DH_SUCCESS; +} + +void ScreenRegion::PublishMessage(const DHTopic topic, const uint64_t &screenId, + const std::string &remoteDevId, const int32_t &windowId, std::shared_ptr windowProperty) +{ + DHLOGI("ScreenRegion PublishMessage"); + if (DScreenFwkKit::GetInstance().GetDHFwkKit() == nullptr) { + DHLOGE("GetDHFwkKit fail."); + return; + } + json messageJosn; + std::string message; + messageJosn[SOURCE_WIN_ID] = screenId; + messageJosn[SOURCE_DEV_ID] = remoteDevId; + messageJosn[SINK_SHOW_WIN_ID] = windowId; + messageJosn[SINK_PROJ_SHOW_WIDTH] = windowProperty->width; + messageJosn[SINK_PROJ_SHOW_HEIGHT] = windowProperty->height; + messageJosn[SINK_WIN_SHOW_X] = windowProperty->startX; + messageJosn[SINK_WIN_SHOW_Y] = windowProperty->startY; + message = messageJosn.dump(); + DScreenFwkKit::GetInstance().GetDHFwkKit()->PublishMessage(topic, message); +} + +void ScreenRegion::OnEngineEvent(DScreenEventType event, const std::string &content) +{ + (void)content; + if (event == DScreenEventType::ENGINE_ERROR) { + StopReceiverEngine(); + } +} + +void ScreenRegion::OnEngineMessage(const std::shared_ptr &message) +{ + if (message == nullptr) { + DHLOGE("received engine message is null."); + return; + } + + DHLOGI("On source device engine message received, message type =%d.", message->type_); + if (message->type_ == DScreenMsgType::START_MIRROR) { + int32_t ret = StartReceiverEngine(message->content_); + DScreenMsgType msgType = (ret == DH_SUCCESS) ? DScreenMsgType::START_MIRROR_SUCCESS : + DScreenMsgType::START_MIRROR_FAIL; + + json paramJson; + paramJson[KEY_DEV_ID] = remoteDevId_; + auto avMessage = std::make_shared(msgType, paramJson.dump(), remoteDevId_); + receiverAdapter_->SendMessageToRemote(avMessage); + } else if (message->type_ == DScreenMsgType::STOP_MIRROR) { + StopReceiverEngine(); + } +} + +void ScreenRegion::GetWSBuffer(sptr &wsBuffer, const std::shared_ptr &buffer) +{ + auto bufferData = buffer->GetBufferData(0); + auto bufferAddr = bufferData->GetAddress(); + auto wsBufAddr = static_cast(wsBuffer->GetVirAddr()); + uint32_t wsBufSize = wsBuffer->GetSize(); + uint32_t srcOffset = 0; + uint32_t dstOffset = 0; + uint32_t alignedWidth = videoParam_->GetVideoWidth(); + uint32_t chromaOffset = videoParam_->GetVideoWidth() * videoParam_->GetVideoHeight(); + + for (unsigned int yh = 0 ; yh < videoParam_->GetVideoHeight(); yh++) { + int32_t ret = memcpy_s(wsBufAddr + dstOffset, chromaOffset - dstOffset, + bufferAddr + srcOffset, videoParam_->GetVideoWidth()); + if (ret != EOK) { + DHLOGE("memcpy video buffer y data failed,ret: %d.", ret); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + dstOffset += videoParam_->GetVideoWidth(); + srcOffset += alignedWidth; + } + + dstOffset = chromaOffset; + srcOffset = alignedWidth * alignedHeight_; + + for (unsigned int uvh = 0 ; uvh < videoParam_->GetVideoHeight() / TWO; uvh++) { + int32_t ret = memcpy_s(wsBufAddr + dstOffset, wsBufSize - dstOffset, + bufferAddr + srcOffset, videoParam_->GetVideoWidth()); + if (ret != EOK) { + DHLOGE("memcpy video buffer uv data failed,ret: %d.", ret); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + dstOffset += videoParam_->GetVideoWidth(); + srcOffset += alignedWidth; + } +} + +void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer) +{ + ++frameNumber_; + DHLOGI("OnEngineDataDone enter"); + if (buffer == nullptr) { + DHLOGE("received video buffer data is nullptr."); + return; + } + if (windowSurface_ == nullptr) { + DHLOGE("window surface is nullptr."); + return; + } + sptr wsBuffer = nullptr; + int32_t releaseFence = -1; + OHOS::BufferRequestConfig requestConfig = { + .width = videoParam_->GetVideoWidth(), + .height = videoParam_->GetVideoHeight(), + .strideAlignment = STRIDE_ALIGNMENT, + .format = GRAPHIC_PIXEL_FMT_YCRCB_420_SP, + .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, + }; + SurfaceError surfaceErr = windowSurface_->RequestBuffer(wsBuffer, releaseFence, requestConfig); + if (surfaceErr != SURFACE_ERROR_OK || wsBuffer == nullptr) { + DHLOGE("surface request buffer failed, surfaceErr: %d.", surfaceErr); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + GetWSBuffer(wsBuffer, buffer); + BufferFlushConfig flushConfig = { {0, 0, wsBuffer->GetWidth(), wsBuffer->GetHeight()}, 0}; + surfaceErr = windowSurface_->FlushBuffer(wsBuffer, -1, flushConfig); + if (surfaceErr != SURFACE_ERROR_OK) { + DHLOGE("surface flush buffer failed, surfaceErr: %d.", surfaceErr); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + DHLOGI("Fill video buffer data to window surface success. frameNumber: %zu", frameNumber_.load()); +} + +uint64_t ScreenRegion::GetScreenId() +{ + return screenId_; +} + +std::string ScreenRegion::GetRemoteDevId() +{ + return remoteDevId_; +} + +std::shared_ptr ScreenRegion::GetVideoParam() +{ + return videoParam_; +} + +int32_t ScreenRegion::GetWindowId() +{ + return windowId_; +} + +std::shared_ptr ScreenRegion::GetWindowProperty() +{ + return windowProperty_; +} + +bool ScreenRegion::CheckContentJson(json &contentJson) +{ + if (!IsUInt64(contentJson, KEY_SCREEN_ID)) { + return false; + } + return true; +} +} // namespace V1_0 +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file -- Gitee From 0e9bc9cd4d4b47e198e904f96d55f160aee09eb9 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 13:20:28 +0800 Subject: [PATCH 3/7] 0724 Signed-off-by: yangli --- .../dscreenmgr/2.0/src/dscreen_test.cpp | 66 +++++++------------ 1 file changed, 25 insertions(+), 41 deletions(-) diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp index ed8f67fa..22cda9f8 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -79,7 +79,7 @@ HWTEST_F(DScreenTestV2, AddTask_001, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, ret); std::string reqId = "reqId"; std::string attrs = "attrs"; - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); } @@ -93,11 +93,10 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - int32_t ret = dScreen_->HandleTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + dScreen_->HandleTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISABLE, reqId, attrs)); dScreen_->HandleTask(std::make_shared(TaskType::TASK_CONNECT, reqId, attrs)); dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs)); - dScreen_->HandleTask(std::make_shared(TaskType::TASK_ERROR, reqId, attrs)); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); } @@ -116,14 +115,10 @@ HWTEST_F(DScreenTestV2, HandleEnable_001, TestSize.Level1) std::string param = "param"; std::string taskId = "taskId"; dScreen_->HandleEnable(param, taskId); - dScreenCallback_ = std::make_shared(); + dScreen_-> dscreenCallback_ = std::make_shared(); DScreenState state = ENABLING; dScreen_->SetState(state); dScreen_->HandleEnable(param, taskId); - - DScreenState state = state; - dScreen_->SetState(state); - dScreen_->HandleEnable(param, taskId); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); } @@ -138,9 +133,9 @@ HWTEST_F(DScreenTestV2, HandleEnable_002, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - dScreenCallback_ = std::make_shared(); + dScreen_->dscreenCallback_ = std::make_shared(); std::shared_ptr task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); - dScreen_->curState_ = curState; + dScreen_->curState_ = DISABLED; dScreen_->videoParam_ = nullptr; std::string param = "{\"codecType\":\"OMX_rk_video_encoder_avc\", \ \"screenHeight\":1280, \"screenVersion\":\"1.0\", \"screenWidth\":720}"; @@ -162,7 +157,7 @@ HWTEST_F(DScreenTestV2, HandleDisable_001, TestSize.Level1) std::string attrs = "attrs"; std::string taskId = "taskId"; dScreen_->HandleDisable(taskId); - dScreenCallback_ = std::make_shared(); + dScreen_->dscreenCallback_ = std::make_shared(); dScreen_->HandleDisable(taskId); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); @@ -178,34 +173,30 @@ HWTEST_F(DScreenTestV2, HandleConnect_001, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - DScreenState state = state; - dScreen_->SetState(state); + dScreen_->SetState(DISABLED); dScreen_->HandleConnect(); - DScreenState state = ENABLED; - dScreen_->SetState(state); + dScreen_->SetState(ENABLED); dScreen_->HandleConnect(); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); } /** - * @tc.name: HandleDisConnect_001 - * @tc.desc: Verify the HandleDisConnect function failed. + * @tc.name: HandleDisconnect_001 + * @tc.desc: Verify the HandleDisconnect function failed. * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(DScreenTestV2, HandleDisConnect_001, TestSize.Level1) +HWTEST_F(DScreenTestV2, HandleDisconnect_001, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - DScreenState state = state; - dScreen_->SetState(state); - dScreen_->HandleDisConnect(); + dScreen_->SetState(DISABLED); + dScreen_->HandleDisconnect(); - DScreenState state = CONNECTED; - dScreen_->SetState(state); - dScreen_->HandleDisConnect(); + dScreen_->SetState(CONNECTED); + dScreen_->HandleDisconnect(); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); } @@ -232,17 +223,6 @@ HWTEST_F(DScreenTestV2, RemoveSurface_001, TestSize.Level1) { int32_t ret = dScreen_->RemoveSurface(); EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); - - std::shared_ptr dScreenCallback = std::make_shared(); - ConsumBufferListener consumBufferListener; - ConsumBufferListener consumBufferListener.dScreen_ = std::make_shared(devId, dhId, dScreenCallback); - DScreenState state = CONNECTED; - consumBufferListener.dScreen_->SetState(state); - consumBufferListener.OnBufferAvailable(); - - ret = dScreen_->ConfigSurface(); - dScreen_->RemoveSurface(); - EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -256,7 +236,7 @@ HWTEST_F(DScreenTestV2, ConsumeSurface_001, TestSize.Level1) std::string reqId = "reqId"; std::string attrs = "attrs"; dScreen_->ConsumeSurface(); - dScreen_.senderAdapter_ = std::make_shared(); + dScreen_->senderAdapter_ = std::make_shared(); dScreen_->ConsumeSurface(); int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); EXPECT_EQ(DH_SUCCESS, ret); @@ -270,7 +250,9 @@ HWTEST_F(DScreenTestV2, ConsumeSurface_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, InitSenderEngine_001, TestSize.Level1) { - int32_t ret = dScreen_->InitSenderEngine(); + IAVEngineProvider *providerPtr = nullptr; + std::string peerDevId = "peer"; + int32_t ret = dScreen_->InitSenderEngine(providerPtr, peerDevId); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); } @@ -284,7 +266,7 @@ HWTEST_F(DScreenTestV2, StartSenderEngine_001, TestSize.Level1) { int32_t ret = dScreen_->StartSenderEngine(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); - dScreen_.senderAdapter_ = std::make_shared(); + dScreen_->senderAdapter_ = std::make_shared(); ret = dScreen_->StartSenderEngine(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); } @@ -299,10 +281,10 @@ HWTEST_F(DScreenTestV2, StopSenderEngine_001, TestSize.Level1) { std::string codecType = "codecType"; std::string pixelFormat = "pixelFormat"; - dScreen_->ChooseParameter(); + dScreen_->ChooseParameter(codecType, pixelFormat); int32_t ret = dScreen_->StopSenderEngine(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); - dScreen_.senderAdapter_ = std::make_shared(); + dScreen_->senderAdapter_ = std::make_shared(); ret = dScreen_->StopSenderEngine(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); } @@ -317,7 +299,7 @@ HWTEST_F(DScreenTestV2, SetUp_001, TestSize.Level1) { int32_t ret = dScreen_->SetUp(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); - dScreen_.senderAdapter_ = std::make_shared(); + dScreen_->senderAdapter_ = std::make_shared(); EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); } @@ -371,6 +353,8 @@ HWTEST_F(DScreenTestV2, NegotiateCodecType_002, TestSize.Level1) HWTEST_F(DScreenTestV2, CheckJsonData_001, TestSize.Level1) { json attrJson; + uint32_t width = 100; + uint32_t heigth = 100; attrJson["screenWidth"] = width; attrJson["screenHeight"] = heigth; attrJson["codecType"] = 0; -- Gitee From b4e0df490f2a838a1e794bf3d794f9604c5cfa04 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 18:05:54 +0800 Subject: [PATCH 4/7] 0724 Signed-off-by: yangli --- .../dscreenmgr/2.0/src/dscreen_test.cpp | 87 ++++++------------- 1 file changed, 27 insertions(+), 60 deletions(-) diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp index 22cda9f8..2cb18c13 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -77,10 +77,6 @@ HWTEST_F(DScreenTestV2, AddTask_001, TestSize.Level1) std::shared_ptr task = nullptr; int32_t ret = dScreen_->AddTask(task); EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, ret); - std::string reqId = "reqId"; - std::string attrs = "attrs"; - ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -93,12 +89,16 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - dScreen_->HandleTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISABLE, reqId, attrs)); - dScreen_->HandleTask(std::make_shared(TaskType::TASK_CONNECT, reqId, attrs)); - dScreen_->HandleTask(std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs)); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + + std::shared_ptr task = std::make_shared(TaskType::DISCONNECT, reqId, attrs); + int32_t ret = dScreen_->AddTask(task); EXPECT_EQ(DH_SUCCESS, ret); + task = std::make_shared(TaskType::TASK_DISABLE, reqId, attrs); + dScreen_->HandleTask(task); + task = std::make_shared(TaskType::TASK_CONNECT, reqId, attrs); + dScreen_->HandleTask(task); + task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); + dScreen_->HandleTask(task); } /** @@ -109,8 +109,6 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, HandleEnable_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; dScreen_->dscreenCallback_ = nullptr; std::string param = "param"; std::string taskId = "taskId"; @@ -119,30 +117,7 @@ HWTEST_F(DScreenTestV2, HandleEnable_001, TestSize.Level1) DScreenState state = ENABLING; dScreen_->SetState(state); dScreen_->HandleEnable(param, taskId); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); -} - -/** - * @tc.name: HandleEnable_002 - * @tc.desc: Verify the HandleEnable function failed. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenTestV2, HandleEnable_002, TestSize.Level1) -{ - std::string reqId = "reqId"; - std::string attrs = "attrs"; - dScreen_->dscreenCallback_ = std::make_shared(); - std::shared_ptr task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); - dScreen_->curState_ = DISABLED; - dScreen_->videoParam_ = nullptr; - std::string param = "{\"codecType\":\"OMX_rk_video_encoder_avc\", \ - \"screenHeight\":1280, \"screenVersion\":\"1.0\", \"screenWidth\":720}"; - std::string taskId = "taskId"; - dScreen_->HandleEnable(param, taskId); - int32_t ret = dScreen_->AddTask(task); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -153,14 +128,11 @@ HWTEST_F(DScreenTestV2, HandleEnable_002, TestSize.Level1) */ HWTEST_F(DScreenTestV2, HandleDisable_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; std::string taskId = "taskId"; dScreen_->HandleDisable(taskId); dScreen_->dscreenCallback_ = std::make_shared(); dScreen_->HandleDisable(taskId); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -171,15 +143,12 @@ HWTEST_F(DScreenTestV2, HandleDisable_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, HandleConnect_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; dScreen_->SetState(DISABLED); dScreen_->HandleConnect(); dScreen_->SetState(ENABLED); dScreen_->HandleConnect(); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -197,8 +166,7 @@ HWTEST_F(DScreenTestV2, HandleDisconnect_001, TestSize.Level1) dScreen_->SetState(CONNECTED); dScreen_->HandleDisconnect(); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -210,7 +178,7 @@ HWTEST_F(DScreenTestV2, HandleDisconnect_001, TestSize.Level1) HWTEST_F(DScreenTestV2, ConfigSurface_001, TestSize.Level1) { int32_t ret = dScreen_->ConfigSurface(); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -265,10 +233,10 @@ HWTEST_F(DScreenTestV2, InitSenderEngine_001, TestSize.Level1) HWTEST_F(DScreenTestV2, StartSenderEngine_001, TestSize.Level1) { int32_t ret = dScreen_->StartSenderEngine(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); dScreen_->senderAdapter_ = std::make_shared(); ret = dScreen_->StartSenderEngine(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_CREAT_CHANNEL_FAILED, ret); } /** @@ -279,14 +247,16 @@ HWTEST_F(DScreenTestV2, StartSenderEngine_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, StopSenderEngine_001, TestSize.Level1) { + dScreen_->senderAdapter_ = nullptr; + int32_t ret = dScreen_->StopSenderEngine(); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); std::string codecType = "codecType"; std::string pixelFormat = "pixelFormat"; - dScreen_->ChooseParameter(codecType, pixelFormat); - int32_t ret = dScreen_->StopSenderEngine(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); dScreen_->senderAdapter_ = std::make_shared(); + dScreen_->ChooseParameter(codecType, pixelFormat); + dScreen_->dhId_ = "dhId"; ret = dScreen_->StopSenderEngine(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_STOP_FAILED, ret); } /** @@ -298,9 +268,10 @@ HWTEST_F(DScreenTestV2, StopSenderEngine_001, TestSize.Level1) HWTEST_F(DScreenTestV2, SetUp_001, TestSize.Level1) { int32_t ret = dScreen_->SetUp(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); dScreen_->senderAdapter_ = std::make_shared(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + ret = dScreen_->SetUp(); + EXPECT_EQ(ERR_DH_AV_TRANS_SETUP_FAILED, ret); } /** @@ -312,7 +283,7 @@ HWTEST_F(DScreenTestV2, SetUp_001, TestSize.Level1) HWTEST_F(DScreenTestV2, WaitForSinkStarted_001, TestSize.Level1) { int32_t ret = dScreen_->WaitForSinkStarted(); - EXPECT_EQ(ERR_DH_AV_TRANS_INIT_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_TIMEOUT, ret); } /** @@ -338,7 +309,6 @@ HWTEST_F(DScreenTestV2, NegotiateCodecType_002, TestSize.Level1) { std::string remoteCodecInfoStr = "{\"codecType\":\"[\"OMX_rk_video_encoder_avc\", \"OMX_rk_video_encoder_hevc\", \ \"avenc_mpeg4\"]\"}"; - dScreen_->TaskThreadLoop(); int32_t ret = dScreen_->NegotiateCodecType(remoteCodecInfoStr); EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL, ret); @@ -396,16 +366,13 @@ HWTEST_F(DScreenTestV2, CheckJsonData_003, TestSize.Level1) */ HWTEST_F(DScreenTestV2, OnEngineEvent_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; DScreenEventType event; event = ENGINE_ERROR; std::string content = "content"; dScreen_->OnEngineEvent(event, content); event = TRANS_CHANNEL_CLOSED; dScreen_->OnEngineEvent(event, content); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } } } -- Gitee From a18241471c380fb78837a421905a7fd1f0d8cea9 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 18:09:36 +0800 Subject: [PATCH 5/7] 0724 Signed-off-by: yangli --- .../dscreenmgr/2.0/src/dscreen_test.cpp | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp index 2cb18c13..51ce784a 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -90,7 +90,7 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) std::string reqId = "reqId"; std::string attrs = "attrs"; - std::shared_ptr task = std::make_shared(TaskType::DISCONNECT, reqId, attrs); + std::shared_ptr task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); int32_t ret = dScreen_->AddTask(task); EXPECT_EQ(DH_SUCCESS, ret); task = std::make_shared(TaskType::TASK_DISABLE, reqId, attrs); @@ -159,8 +159,6 @@ HWTEST_F(DScreenTestV2, HandleConnect_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, HandleDisconnect_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; dScreen_->SetState(DISABLED); dScreen_->HandleDisconnect(); @@ -178,7 +176,7 @@ HWTEST_F(DScreenTestV2, HandleDisconnect_001, TestSize.Level1) HWTEST_F(DScreenTestV2, ConfigSurface_001, TestSize.Level1) { int32_t ret = dScreen_->ConfigSurface(); - EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); + EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -201,13 +199,10 @@ HWTEST_F(DScreenTestV2, RemoveSurface_001, TestSize.Level1) */ HWTEST_F(DScreenTestV2, ConsumeSurface_001, TestSize.Level1) { - std::string reqId = "reqId"; - std::string attrs = "attrs"; dScreen_->ConsumeSurface(); dScreen_->senderAdapter_ = std::make_shared(); dScreen_->ConsumeSurface(); - int32_t ret = dScreen_->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); - EXPECT_EQ(DH_SUCCESS, ret); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** @@ -236,7 +231,7 @@ HWTEST_F(DScreenTestV2, StartSenderEngine_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, ret); dScreen_->senderAdapter_ = std::make_shared(); ret = dScreen_->StartSenderEngine(); - EXPECT_EQ(ERR_DH_AV_TRANS_CREAT_CHANNEL_FAILED, ret); + EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, ret); } /** -- Gitee From e12a243025ece89e11b8de23ed8a26fc96f1ff33 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 19:33:47 +0800 Subject: [PATCH 6/7] 0724 Signed-off-by: yangli --- .../sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp index 51ce784a..6bb2c428 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -63,12 +63,9 @@ void DScreenTestV2::TearDown(void) {} */ HWTEST_F(DScreenTestV2, AddTask_001, TestSize.Level1) { - dScreen_->GetVideoParam(); - DScreenState state = ENABLING; dScreen_->SetState(state); - dScreen_->GetState(); dScreen_->GetScreenId(); dScreen_->GetDHId(); @@ -89,7 +86,6 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) { std::string reqId = "reqId"; std::string attrs = "attrs"; - std::shared_ptr task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); int32_t ret = dScreen_->AddTask(task); EXPECT_EQ(DH_SUCCESS, ret); @@ -306,7 +302,6 @@ HWTEST_F(DScreenTestV2, NegotiateCodecType_002, TestSize.Level1) \"avenc_mpeg4\"]\"}"; int32_t ret = dScreen_->NegotiateCodecType(remoteCodecInfoStr); EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL, ret); - } /** -- Gitee From ddd7ec5ccfcdb8a1d3af4921bfd9c95aefbd4624 Mon Sep 17 00:00:00 2001 From: yangli Date: Mon, 24 Jul 2023 21:33:39 +0800 Subject: [PATCH 7/7] 0724 Signed-off-by: yangli --- .../unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp index 6bb2c428..56fb9161 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp @@ -95,6 +95,7 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1) dScreen_->HandleTask(task); task = std::make_shared(TaskType::TASK_DISCONNECT, reqId, attrs); dScreen_->HandleTask(task); + EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_); } /** -- Gitee