From 19274c4dbb85727e4fdc9444f433498822961e7f Mon Sep 17 00:00:00 2001 From: hulei0901 Date: Mon, 4 Dec 2023 15:53:54 +0800 Subject: [PATCH 1/2] IssueNo: https://e.gitee.com/kunyuan-hongke/dashboard?issue=I89YBC Description: midify for screen mirroring and remote control Sig:SIG_BscSoftSrv Feature or Bugfix: Feature Binary Source: No Signed-off-by: hulei0901 --- bundle.json | 7 +- screennapi/BUILD.gn | 74 ++++++ screennapi/decoder_demo.cpp | 336 +++++++++++++++++++++++++ screennapi/decoder_demo.h | 95 +++++++ screennapi/js_screen_demo_manager.cpp | 138 ++++++++++ screennapi/js_screen_demo_manager.h | 28 +++ screennapi/js_screen_demo_module.cpp | 30 +++ screennapi/screendemo_manager_hilog.h | 52 ++++ screennapi/test.cpp | 346 ++++++++++++++++++++++++++ 9 files changed, 1105 insertions(+), 1 deletion(-) create mode 100644 screennapi/BUILD.gn create mode 100644 screennapi/decoder_demo.cpp create mode 100644 screennapi/decoder_demo.h create mode 100644 screennapi/js_screen_demo_manager.cpp create mode 100644 screennapi/js_screen_demo_manager.h create mode 100644 screennapi/js_screen_demo_module.cpp create mode 100644 screennapi/screendemo_manager_hilog.h create mode 100644 screennapi/test.cpp diff --git a/bundle.json b/bundle.json index 6b9bba34..51e69ccc 100644 --- a/bundle.json +++ b/bundle.json @@ -28,6 +28,8 @@ ], "deps": { "components": [ + "access_token", + "ability_runtime", "dsoftbus", "hisysevent", "init", @@ -42,6 +44,8 @@ "player_framework", "window_manager", "image_framework", + "multimedia_image_framework", + "napi", "distributed_hardware_fwk" ], "third_party": [ @@ -61,7 +65,8 @@ "//foundation/distributedhardware/distributed_screen/services/screenservice/sinkservice:distributed_screen_sink", "//foundation/distributedhardware/distributed_screen/services/screenservice/sourceservice:distributed_screen_source", "//foundation/distributedhardware/distributed_screen/sa_profile:dscreen_sa_profile", - "//foundation/distributedhardware/distributed_screen/sa_profile:dscreen.cfg" + "//foundation/distributedhardware/distributed_screen/sa_profile:dscreen.cfg", + "//foundation/distributedhardware/distributed_screen/services/screennapi:distributedscreennapi" ], "inner_kits": [{ "type": "so", diff --git a/screennapi/BUILD.gn b/screennapi/BUILD.gn new file mode 100644 index 00000000..5281eb48 --- /dev/null +++ b/screennapi/BUILD.gn @@ -0,0 +1,74 @@ +# 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. + +import("//build/ohos.gni") +import( + "//foundation/distributedhardware/distributed_screen/distributedscreen.gni") + +ohos_shared_library("distributedscreennapi") { + + include_dirs = [ + "${services_path}/common/utils/include", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", + "${fwk_common_path}/utils/include", + "${services_path}/screenclient/include", + "${common_path}/include", + "./" + ] + + sources = [ + "./decoder_demo.cpp", + "./test.cpp", + "./js_screen_demo_module.cpp", + "./js_screen_demo_manager.cpp" + ] + + deps = [ + "${common_path}:distributed_screen_utils", + "${interfaces_path}/innerkits/native_cpp/screen_sink:distributed_screen_sink_sdk", + "${interfaces_path}/innerkits/native_cpp/screen_source:distributed_screen_source_sdk", + "${services_path}/screenclient:distributed_screen_client", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"distributedScreenNapi\"", + "LOG_DOMAIN=0xD004100", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", + "dsoftbus:softbus_client", + "graphic_2d:librender_service_client", + "graphic_2d:surface", + "hilog:libhilog", + "player_framework:media_client", + "samgr:samgr_proxy", + "window_manager:libdm", + "window_manager:libwm", + "ability_runtime:runtime", + "hitrace:hitrace_meter", + "napi:ace_napi", + ] + + cflags = [ "-Wall" ] + cflags_cc = cflags + + relative_install_dir = "module" + part_name = "distributed_screen" + subsystem_name = "distributedhardware" +} diff --git a/screennapi/decoder_demo.cpp b/screennapi/decoder_demo.cpp new file mode 100644 index 00000000..12a07eb4 --- /dev/null +++ b/screennapi/decoder_demo.cpp @@ -0,0 +1,336 @@ +/* + * 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 "decoder_demo.h" + +#include +#include + +#include "avcodec_list.h" +#include "securec.h" +#include "wm_common.h" +#include "window.h" +#include "window_option.h" + +static const int32_t ES_R[325] = { + 11895, 8109, 1578, 1616, 1313, 572, 805, 837, 755, 706, 952, 879, 13193, 422, 389, 509, 725, 465, 479, 959, + 677, 364, 541, 696, 9306, 322, 318, 767, 590, 422, 530, 403, 505, 566, 445, 508, 7783, 460, 405, 343, 451, + 608, 431, 411, 543, 487, 527, 400, 6287, 385, 418, 391, 592, 434, 412, 398, 504, 492, 479, 561, 5413, 317, + 355, 422, 467, 452, 476, 460, 490, 492, 485, 451, 5036, 312, 408, 460, 432, 502, 388, 475, 407, 544, 401, + 487, 4404, 362, 378, 427, 416, 426, 456, 414, 438, 424, 442, 444, 4310, 362, 388, 393, 390, 441, 398, 423, + 369, 443, 406, 392, 4231, 343, 363, 355, 390, 459, 371, 378, 381, 405, 392, 426, 3975, 387, 337, 393, 439, + 378, 355, 374, 484, 381, 373, 423, 3869, 312, 350, 400, 345, 356, 320, 473, 431, 386, 338, 431, 3426, 268, + 315, 416, 383, 373, 381, 354, 383, 328, 348, 418, 3715, 324, 361, 331, 350, 302, 409, 377, 359, 384, 334, + 326, 3439, 266, 324, 329, 353, 405, 303, 357, 332, 292, 361, 333, 3542, 294, 284, 247, 331, 306, 322, 287, + 367, 341, 276, 258, 3980, 246, 245, 259, 309, 333, 250, 275, 334, 281, 253, 371, 3640, 213, 231, 301, 302, + 228, 289, 290, 281, 201, 284, 277, 4242, 205, 328, 237, 283, 295, 266, 230, 321, 348, 212, 308, 4103, 259, + 238, 245, 298, 330, 265, 271, 287, 267, 286, 290, 3856, 269, 242, 209, 314, 267, 278, 280, 314, 250, 433, + 238, 3654, 195, 246, 301, 298, 250, 270, 320, 269, 305, 258, 368, 3810, 231, 212, 279, 289, 252, 303, 287, + 295, 206, 264, 349, 4071, 242, 296, 271, 231, 307, 265, 254, 267, 317, 232, 348, 4077, 259, 222, 268, 235, + 324, 266, 256, 312, 246, 248, 325, 4000, 266, 201, 230, 293, 264, 265, 273, 301, 304, 253, 266, 3978, 228, + 232, 250, 248, 281, 219, 243, 293, 287, 253, 328, 3719 +}; + +static const int32_t ES_W[183] = { + 2111, 109091, 9316, 969, 13656, 1349, 959, 10484, 1219, 14839, 1092, 23378, 1653, 1725, 1526, 8500, 15407, + 2058, 1346, 21066, 3758, 1734, 1950, 19955, 3997, 1732, 1784, 22687, 4392, 2448, 2180, 17456, 3930, 1851, + 1802, 24227, 4393, 2639, 2778, 18314, 4023, 2392, 2283, 20566, 4118, 2664, 2013, 18964, 2624, 45258, 5860, + 4124, 3473, 27772, 4687, 3140, 2939, 26288, 3808, 2967, 2823, 27219, 3943, 3242, 2667, 27372, 3522, 2899, + 2316, 26608, 3284, 2853, 2285, 19581, 2894, 2436, 24898, 4002, 2876, 2807, 25730, 3903, 2874, 2975, 26309, + 3771, 2763, 2666, 23404, 3826, 2410, 2644, 24629, 4145, 3121, 2878, 50773, 7040, 3945, 3292, 30828, 5210, + 2883, 3277, 31501, 4809, 3068, 3220, 30746, 4715, 3461, 3583, 32278, 4798, 3398, 3389, 31404, 4921, 3382, + 3766, 31821, 5848, 3860, 4047, 37642, 5793, 4271, 4094, 29853, 6163, 4399, 4063, 32151, 6038, 4332, 4041, + 30390, 5679, 4098, 3921, 29401, 5307, 3996, 3945, 45997, 7060, 3716, 4183, 26357, 6190, 3714, 4250, 29086, + 5929, 3491, 4489, 27772, 6656, 4219, 4348, 25851, 6088, 3617, 4477, 25722, 6303, 3856, 4208, 25348, 5896, + 3816, 4521, 22462, 5914, 3673, 4594, 18091, 6474, 3878, 4492, 10890, 4823, 4148 +}; + +using namespace OHOS; +using namespace OHOS::Media; +using namespace std; +namespace { + constexpr uint32_t DEFAULT_FRAME_RATE = 30; + constexpr uint32_t MAX_INPUT_BUFFER_SIZE = 30000; + constexpr uint32_t FRAME_DURATION_US = 33000; + constexpr uint32_t VIDEO_DATA_FORMAT_NV12 = 2; + constexpr uint32_t VIDEO_DATA_FORMAT_RGBA = 5; + constexpr uint32_t SLEEP_THREE_SECOND = 3; + constexpr uint32_t INDEX_CONSTANT = 10000; + const string CODEC_NAME_H264 = "OMX_hisi_video_encoder_avc"; + const string CODEC_NAME_MPEG4 = "avenc_mpeg4"; +} + +void VDecDemo::RunCase() +{ + CheckCodecType(); + CreateVdec(); + Format format; + format.PutIntValue("width", width_); + format.PutIntValue("height", height_); + if (isW) { + format.PutIntValue("pixel_format", VIDEO_DATA_FORMAT_NV12); + } else { + format.PutIntValue("pixel_format", VIDEO_DATA_FORMAT_RGBA); + } + format.PutIntValue("frame_rate", DEFAULT_FRAME_RATE); + format.PutIntValue("max_input_size", MAX_INPUT_BUFFER_SIZE); + Configure(format); + SetSurface(); + Prepare(); + Start(); + sleep(SLEEP_THREE_SECOND); + Stop(); + Release(); +} + +int32_t VDecDemo::CreateVdec() +{ + if (isW) { + vdec_ = VideoDecoderFactory::CreateByMime("video/avc"); + } else { + vdec_ = VideoDecoderFactory::CreateByMime("video/mp4v-es"); + } + + signal_ = make_shared(); + cb_ = make_unique(signal_); + vdec_->SetCallback(cb_); + return 0; +} + +int32_t VDecDemo::Configure(const Format &format) +{ + return vdec_->Configure(format); +} + +int32_t VDecDemo::Prepare() +{ + return vdec_->Prepare(); +} + +int32_t VDecDemo::Start() +{ + isRunning_.store(true); + + testFile_ = std::make_unique(); + testFile_->open("/data/media/video.es", std::ios::in | std::ios::binary); + + inputLoop_ = make_unique(&VDecDemo::InputFunc, this); + outputLoop_ = make_unique(&VDecDemo::OutputFunc, this); + return vdec_->Start(); +} + +int32_t VDecDemo::Stop() +{ + isRunning_.store(false); + + if (inputLoop_ != nullptr && inputLoop_->joinable()) { + { + unique_lock inLock(signal_->inMutex_); + signal_->inQueue_.push(INDEX_CONSTANT); + signal_->inCond_.notify_all(); + } + inputLoop_->join(); + inputLoop_.reset(); + } + + if (outputLoop_ != nullptr && outputLoop_->joinable()) { + { + unique_lock outLock(signal_->outMutex_); + signal_->outQueue_.push(INDEX_CONSTANT); + signal_->outCond_.notify_all(); + } + outputLoop_->join(); + outputLoop_.reset(); + } + + return vdec_->Stop(); +} + +int32_t VDecDemo::Flush() +{ + return vdec_->Flush(); +} + +int32_t VDecDemo::Reset() +{ + return vdec_->Reset(); +} + +int32_t VDecDemo::Release() +{ + return vdec_->Release(); +} + +void VDecDemo::SetOutputSurface(sptr surface) +{ + surface_ = surface; +} + +void VDecDemo::SetWindowSize(uint32_t width, uint32_t height) +{ + width_ = width; + height_ = height; +} + +int32_t VDecDemo::SetSurface() +{ + return vdec_->SetOutputSurface(surface_); +} + +void VDecDemo::CheckCodecType() +{ + std::vector localCodecArray; + std::shared_ptr codecList = Media::AVCodecListFactory::CreateAVCodecList(); + std::vector> caps = codecList->GetVideoEncoderCaps(); + for (const auto &cap : caps) { + std::shared_ptr codecInfo = cap->GetCodecInfo(); + localCodecArray.push_back(codecInfo->GetName()); + } + + if (std::find(localCodecArray.begin(), localCodecArray.end(), + CODEC_NAME_H264) != localCodecArray.end()) { + cout << "device is W" << endl; + isW = true; + } else if (std::find(localCodecArray.begin(), localCodecArray.end(), + CODEC_NAME_MPEG4) != localCodecArray.end()) { + cout << "device is R" << endl; + isW = false; + } +} + +const int32_t* VDecDemo::GetFrameLen() +{ + const int32_t* frameLen = nullptr; + if (isW) { + frameLen = ES_W; + defaultFrameCount_ = sizeof(ES_W) / sizeof(ES_W[0]); + } else { + frameLen = ES_R; + defaultFrameCount_ = sizeof(ES_R) / sizeof(ES_R[0]); + } + return frameLen; +} + +void VDecDemo::InputFunc() +{ + const int32_t *frameLen = GetFrameLen(); + + while (true) { + if (!isRunning_.load()) { + break; + } + + unique_lock lock(signal_->inMutex_); + signal_->inCond_.wait(lock, [this]() { return signal_->inQueue_.size() > 0; }); + + if (!isRunning_.load()) { + break; + } + + uint32_t index = signal_->inQueue_.front(); + auto buffer = vdec_->GetInputBuffer(index); + + char *fileBuffer = static_cast(malloc(sizeof(char) * (*frameLen) + 1)); + if (fileBuffer == nullptr) { + break; + } + + (void)testFile_->read(fileBuffer, *frameLen); + if (memcpy_s(buffer->GetBase(), buffer->GetSize(), fileBuffer, *frameLen) != EOK) { + free(fileBuffer); + cout << "Fatal: memcpy fail" << endl; + break; + } + + AVCodecBufferInfo info; + info.size = *frameLen; + info.offset = 0; + info.presentationTimeUs = timeStamp_; + + int32_t ret = 0; + if (isFirstFrame_) { + ret = vdec_->QueueInputBuffer(index, info, AVCODEC_BUFFER_FLAG_CODEC_DATA); + isFirstFrame_ = false; + } else { + ret = vdec_->QueueInputBuffer(index, info, AVCODEC_BUFFER_FLAG_NONE); + } + + free(fileBuffer); + frameLen++; + timeStamp_ += FRAME_DURATION_US; + signal_->inQueue_.pop(); + + frameCount_++; + if (frameCount_ == defaultFrameCount_) { + cout << "Finish decode, exit" << endl; + break; + } + + if (ret != 0) { + cout << "Fatal error, exit" << endl; + break; + } + } +} + +void VDecDemo::OutputFunc() +{ + while (true) { + if (!isRunning_.load()) { + break; + } + + unique_lock lock(signal_->outMutex_); + signal_->outCond_.wait(lock, [this]() { return signal_->outQueue_.size() > 0; }); + + if (!isRunning_.load()) { + break; + } + + uint32_t index = signal_->outQueue_.front(); + if (vdec_->ReleaseOutputBuffer(index, true) != 0) { + cout << "Fatal: ReleaseOutputBuffer fail" << endl; + break; + } + + signal_->outQueue_.pop(); + } +} + +void VDecDemoCallback::OnError(AVCodecErrorType errorType, int32_t errorCode) +{ + cout << "Error received, errorType:" << errorType << " errorCode:" << errorCode << endl; +} + +void VDecDemoCallback::OnOutputFormatChanged(const Format &format) +{ + cout << "OnOutputFormatChanged received" << endl; +} + +void VDecDemoCallback::OnInputBufferAvailable(uint32_t index) +{ + cout << "OnInputBufferAvailable received, index:" << index << endl; + unique_lock lock(signal_->inMutex_); + signal_->inQueue_.push(index); + signal_->inCond_.notify_all(); +} + +void VDecDemoCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag) +{ + cout << "OnOutputBufferAvailable received, index:" << index << endl; + unique_lock lock(signal_->outMutex_); + signal_->outQueue_.push(index); + signal_->outCond_.notify_all(); +} diff --git a/screennapi/decoder_demo.h b/screennapi/decoder_demo.h new file mode 100644 index 00000000..b55963c5 --- /dev/null +++ b/screennapi/decoder_demo.h @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2022 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 AVCODEC_VDEC_DEMO_H +#define AVCODEC_VDEC_DEMO_H + +#include +#include +#include +#include +#include + +#include "avcodec_video_decoder.h" +#include "nocopyable.h" + +namespace OHOS { +namespace Media { +class VDecSignal { +public: + std::mutex inMutex_; + std::mutex outMutex_; + std::condition_variable inCond_; + std::condition_variable outCond_; + std::queue inQueue_; + std::queue outQueue_; +}; + +class VDecDemoCallback : public AVCodecCallback, public NoCopyable { +public: + explicit VDecDemoCallback(std::shared_ptr signal) : signal_(signal) {}; + virtual ~VDecDemoCallback() = default; + + void OnError(AVCodecErrorType errorType, int32_t errorCode) override; + void OnOutputFormatChanged(const Format &format) override; + void OnInputBufferAvailable(uint32_t index) override; + void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag) override; + +private: + std::shared_ptr signal_; +}; + +class VDecDemo : public NoCopyable { +public: + VDecDemo() = default; + virtual ~VDecDemo() = default; + void RunCase(); + void SetOutputSurface(sptr surface); + void SetWindowSize(uint32_t width, uint32_t height); + +private: + int32_t CreateVdec(); + int32_t Configure(const Format &format); + int32_t Prepare(); + int32_t Start(); + int32_t Stop(); + int32_t Flush(); + int32_t Reset(); + int32_t Release(); + int32_t SetSurface(); + const int32_t *GetFrameLen(); + void InputFunc(); + void OutputFunc(); + void CheckCodecType(); + + std::atomic isRunning_ = false; + sptr surface_ = nullptr; + uint32_t width_ = 0; + uint32_t height_ = 0; + std::unique_ptr testFile_; + std::unique_ptr inputLoop_; + std::unique_ptr outputLoop_; + std::shared_ptr vdec_; + std::shared_ptr signal_; + std::shared_ptr cb_; + bool isFirstFrame_ = true; + bool isW = true; + int64_t timeStamp_ = 0; + uint32_t frameCount_ = 0; + uint32_t defaultFrameCount_ = 0; +}; +} // namespace Media +} // namespace OHOS +#endif // AVCODEC_VDEC_DEMO_H \ No newline at end of file diff --git a/screennapi/js_screen_demo_manager.cpp b/screennapi/js_screen_demo_manager.cpp new file mode 100644 index 00000000..6f76ba66 --- /dev/null +++ b/screennapi/js_screen_demo_manager.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2022 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 +#include + +#include +#include "js_runtime_utils.h" +#include "native_engine/native_reference.h" +#include "screendemo_manager_hilog.h" +#include "singleton_container.h" +#include "js_screen_demo_manager.h" + +extern int dscreen_connect(); +extern int dscreen_disconnect(); + +namespace OHOS { +namespace Rosen { +using namespace AbilityRuntime; +constexpr size_t ARGC_ONE = 1; +namespace { + constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_SCREENDEMO, "JsScreenDemoManager"}; +} + +class JsScreenDemoManager { +public: +explicit JsScreenDemoManager(NativeEngine* engine) { +} + +~JsScreenDemoManager() = default; + +static void Finalizer(NativeEngine* engine, void* data, void* hint) +{ + WLOGI("Finalizer is called"); + std::unique_ptr(static_cast(data)); +} + +static NativeValue* StartDemo(NativeEngine* engine, NativeCallbackInfo* info) +{ + JsScreenDemoManager* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnStartDemo(*engine, *info) : nullptr; +} + +static NativeValue* StopDemo(NativeEngine* engine, NativeCallbackInfo* info) +{ + JsScreenDemoManager* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnStopDemo(*engine, *info) : nullptr; +} + +private: +std::mutex mtx_; + + + +NativeValue* OnStartDemo(NativeEngine& engine, NativeCallbackInfo& info) +{ + WLOGFI("JsScreenDemoManager::OnStartDemo is called"); + + AsyncTask::CompleteCallback complete = + [=](NativeEngine& engine, AsyncTask& task, int32_t status) { + int rc = dscreen_connect(); + WLOGFI("JsScreenDemoManager::OnStartDemo call end %{public}d",rc); + task.Resolve(engine, CreateJsError(engine, rc, + "JsScreenDemoManager::OnStartDemo done.")); + }; + + NativeValue* lastParam = nullptr; + if (info.argc >= ARGC_ONE && info.argv[ARGC_ONE - 1] != nullptr && + info.argv[ARGC_ONE - 1]->TypeOf() == NATIVE_FUNCTION) { + lastParam = info.argv[0]; + } + NativeValue* result = nullptr; + AsyncTask::Schedule("JsScreenDemoManager::OnGetAllDisplays", + engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + return result; +} + +NativeValue* OnStopDemo(NativeEngine& engine, NativeCallbackInfo& info) +{ + WLOGFI("JsScreenDemoManager::OnStartDemo is called"); + + AsyncTask::CompleteCallback complete = + [=](NativeEngine& engine, AsyncTask& task, int32_t status) { + int rc = dscreen_disconnect(); + WLOGFI("JsScreenDemoManager::OnStopDemo call end %{public}d",rc); + task.Resolve(engine, CreateJsError(engine, rc, + "JsScreenDemoManager::OnStopDemo done.")); + }; + + NativeValue* lastParam = nullptr; + if (info.argc >= ARGC_ONE && info.argv[ARGC_ONE - 1] != nullptr && + info.argv[ARGC_ONE - 1]->TypeOf() == NATIVE_FUNCTION) { + lastParam = info.argv[0]; + } + NativeValue* result = nullptr; + AsyncTask::Schedule("JsScreenDemoManager::OnGetAllDisplays", + engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + return result; +} +}; + +NativeValue* JsScreenDemoManagerInit(NativeEngine* engine, NativeValue* exportObj) +{ + WLOGI("JsScreenDemoManagerInit is called"); + + if (engine == nullptr || exportObj == nullptr) { + WLOGFE("JsScreenDemoManagerInit engine or exportObj is nullptr"); + return nullptr; + } + + NativeObject* object = ConvertNativeValueTo(exportObj); + if (object == nullptr) { + WLOGFE("JsScreenDemoManagerInit object is nullptr"); + return nullptr; + } + + std::unique_ptr jsScreenDemoManager = std::make_unique(engine); + object->SetNativePointer(jsScreenDemoManager.release(), JsScreenDemoManager::Finalizer, nullptr); + + const char *moduleName = "distributedScreenNapi"; + BindNativeFunction(*engine, *object, "startDemo", moduleName, JsScreenDemoManager::StartDemo); + BindNativeFunction(*engine, *object, "stopDemo", moduleName, JsScreenDemoManager::StopDemo); + return engine->CreateUndefined(); +} +} // namespace Rosen +} // namespace OHOS \ No newline at end of file diff --git a/screennapi/js_screen_demo_manager.h b/screennapi/js_screen_demo_manager.h new file mode 100644 index 00000000..8dc770ba --- /dev/null +++ b/screennapi/js_screen_demo_manager.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022 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_JS_SCREEN_DEMO_MANAGER_H +#define OHOS_JS_SCREEN_DEMO_MANAGER_H + +#include "native_engine/native_engine.h" +#include "native_engine/native_value.h" + +namespace OHOS { +namespace Rosen { +NativeValue* JsScreenDemoManagerInit(NativeEngine* engine, NativeValue* exportObj); +} // namespace Rosen +} // namespace OHOS + +#endif diff --git a/screennapi/js_screen_demo_module.cpp b/screennapi/js_screen_demo_module.cpp new file mode 100644 index 00000000..6610bd73 --- /dev/null +++ b/screennapi/js_screen_demo_module.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2022 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 "js_screen_demo_manager.h" +#include "native_engine/native_engine.h" + +extern "C" __attribute__((constructor)) void NAPI_application_screendemomanager_AutoRegister() +{ + auto moduleManager = NativeModuleManager::GetInstance(); + NativeModule newModuleInfo = { + .name = "distributedScreenNapi", + // .fileName = "module/distributedScreenNapi.so/distributedScreenNapi.js", + .fileName = "distributedScreenNapi.so/distributedScreenNapi.js", + .registerCallback = OHOS::Rosen::JsScreenDemoManagerInit, + }; + + moduleManager->Register(&newModuleInfo); +} diff --git a/screennapi/screendemo_manager_hilog.h b/screennapi/screendemo_manager_hilog.h new file mode 100644 index 00000000..649cc7d2 --- /dev/null +++ b/screennapi/screendemo_manager_hilog.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2021-2022 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_WM_INCLUDE_SCREENDEMO_MANAGER_HILOG_H +#define OHOS_WM_INCLUDE_SCREENDEMO_MANAGER_HILOG_H + +#include "hilog/log.h" +namespace OHOS { +namespace Rosen { +static constexpr unsigned int HILOG_DOMAIN_SCREENDEMO = 0xD009999; +// static constexpr unsigned int HILOG_DOMAIN_DISPLAY = 0xD004201; +static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = {LOG_CORE, HILOG_DOMAIN_SCREENDEMO, "ScreenDemo"}; + +#define WLOG_F(...) (void)OHOS::HiviewDFX::HiLog::Fatal(LOG_LABEL, __VA_ARGS__) +#define WLOG_E(...) (void)OHOS::HiviewDFX::HiLog::Error(LOG_LABEL, __VA_ARGS__) +#define WLOG_W(...) (void)OHOS::HiviewDFX::HiLog::Warn(LOG_LABEL, __VA_ARGS__) +#define WLOG_I(...) (void)OHOS::HiviewDFX::HiLog::Info(LOG_LABEL, __VA_ARGS__) +#define WLOG_D(...) (void)OHOS::HiviewDFX::HiLog::Debug(LOG_LABEL, __VA_ARGS__) + +#define _W_DFUNC HiviewDFX::HiLog::Debug +#define _W_IFUNC HiviewDFX::HiLog::Info +#define _W_WFUNC HiviewDFX::HiLog::Warn +#define _W_EFUNC HiviewDFX::HiLog::Error + +#define _W_CPRINTF(func, fmt, ...) func(LABEL, "<%{public}d>" fmt, __LINE__, ##__VA_ARGS__) + +#define WLOGD(fmt, ...) _W_CPRINTF(_W_DFUNC, fmt, ##__VA_ARGS__) +#define WLOGI(fmt, ...) _W_CPRINTF(_W_IFUNC, fmt, ##__VA_ARGS__) +#define WLOGW(fmt, ...) _W_CPRINTF(_W_WFUNC, fmt, ##__VA_ARGS__) +#define WLOGE(fmt, ...) _W_CPRINTF(_W_EFUNC, fmt, ##__VA_ARGS__) + +#define _W_FUNC __func__ + +#define WLOGFD(fmt, ...) WLOGD("%{public}s: " fmt, _W_FUNC, ##__VA_ARGS__) +#define WLOGFI(fmt, ...) WLOGI("%{public}s: " fmt, _W_FUNC, ##__VA_ARGS__) +#define WLOGFW(fmt, ...) WLOGW("%{public}s: " fmt, _W_FUNC, ##__VA_ARGS__) +#define WLOGFE(fmt, ...) WLOGE("%{public}s: " fmt, _W_FUNC, ##__VA_ARGS__) +} // namespace OHOS +} +#endif // OHOS_WM_INCLUDE_SCREENDEMO_MANAGER_HILOG_H diff --git a/screennapi/test.cpp b/screennapi/test.cpp new file mode 100644 index 00000000..34236bf2 --- /dev/null +++ b/screennapi/test.cpp @@ -0,0 +1,346 @@ +/* + * 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 + +#include "accesstoken_kit.h" +#include "display.h" +#include "display_manager.h" +#include "dscreen_source_handler.h" +#include "dscreen_sink_handler.h" +#include "dscreen_util.h" +#include "idistributed_hardware_sink.h" +#include "idistributed_hardware_source.h" +#include "screen.h" +#include "screen_client.h" +#include "screen_client_common.h" +#include "screen_manager.h" +#include "wm_common.h" +#include "window.h" +#include "window_option.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +#include "decoder_demo.h" +#include "softbus_bus_center.h" +#include "softbus_common.h" + +using namespace std; +using namespace OHOS; +using namespace OHOS::DistributedHardware; +using namespace OHOS::Rosen; +using namespace OHOS::Media; +using namespace OHOS::Security::AccessToken; + +// namespace { +// static char const *g_pkgName = "ohos.dsoftbus.tool"; +// const uint32_t MAX_WINDOW_WIDTH = 2560; +// const uint32_t MAX_WINDOW_HEIGHT = 2772; +// const uint32_t DCODE_WIDTH = 1920; +// const uint32_t DCODE_HEIGHT = 1080; +// } + +vector> QueryRemoteScreenInfo() +{ + vector> allScreens; + ScreenManager::GetInstance().GetAllScreens(allScreens); + sptr defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay(); + vector> remoteScreens; + for (const auto &screen : allScreens) { + if (screen == nullptr) { + continue; + } + if (!screen->IsReal() && screen->GetWidth() > 0) { + remoteScreens.push_back(screen); + } + } + cout << "-------------remote screen info---------------" << endl; + cout << "remote screen Num: " << remoteScreens.size() << endl; + for (const auto &screen : remoteScreens) { + if (screen == nullptr) { + continue; + } + cout << endl; + cout << "--------screen id " << screen->GetId() << "---------" << endl; + cout << "screen name: " << GetAnonyString(screen->GetName()).c_str() << endl; + cout << "width: " << screen->GetWidth() << endl; + cout << "height: " << screen->GetHeight() << endl; + cout << "-------------------------------------------" << endl; + } + return remoteScreens; +} + +static int StartMirror() +{ + vector> remoteScreens = QueryRemoteScreenInfo(); + if (remoteScreens.size() == 0) { + cout << "Error: no remote screens enabled" << endl; + return -1; + } + + //cout << "select remote screen id to mirror: " << endl; + //uint64_t mirrorId; + //cin >> mirrorId; + + //bool isMirrorIdValid = false; + for (const auto &screen : remoteScreens) { + if (screen == nullptr) { + continue; + } + vector mirrorIds; + mirrorIds.push_back(static_cast(screen->GetId())); + sptr defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay(); + cout << "------------start mirror----------" << endl; + cout << "mirror screen Id is " << screen->GetId() << endl; + ScreenId screenGroupId; + ScreenManager::GetInstance().MakeMirror(defaultDisplay->GetScreenId(), mirrorIds, screenGroupId); + } + + return 0; + + //sptr defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay(); + //cout << "------------start mirror----------" << endl; + //cout << "mirror screen Id is " << mirrorId << endl; + //vector mirrorIds; + //mirrorIds.push_back(mirrorId); + //ScreenId screenGroupId; + //ScreenManager::GetInstance().MakeMirror(defaultDisplay->GetScreenId(), mirrorIds, screenGroupId); +} + +static int StopMirror() +{ + vector> remoteScreens = QueryRemoteScreenInfo(); + if (remoteScreens.size() == 0) { + cout << "no remote screens enabled, no need stop mirror" << endl; + return -1; + } + + //bool isStopMirrorIdValid = false; + //cout << "select remote screen id to stop mirror: " << endl; + //uint64_t stopMirrorId; + //cin >> stopMirrorId; + + vector stopMirrorIds; + for (const auto &screen : remoteScreens) { + if (screen == nullptr) { + continue; + } + //if (screen->GetId() == stopMirrorId) { + // isStopMirrorIdValid = true; + // break; + //} + stopMirrorIds.push_back(screen->GetId()); + } + //if (!isStopMirrorIdValid) { + // cout << "input screenId is not valid!" << endl; + // return; + //} + + //cout << "-------------- stop mirror ------------" << endl; + //cout << "stop mirror screen id is " << stopMirrorId << endl; + //vector stopMirrorIds; + //stopMirrorIds.push_back(stopMirrorId); + ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(stopMirrorIds); + + return 0; +} + +// static void StartExpand() +// { +// vector> remoteScreens = QueryRemoteScreenInfo(); +// if (remoteScreens.size() == 0) { +// cout << "Error: no remote screens enabled" << endl; +// return; +// } + +// cout << "select remote screen id to expand: " << endl; +// uint64_t expandId; +// cin >> expandId; + +// bool isExpandIdValid = false; +// for (const auto &screen : remoteScreens) { +// if (screen == nullptr) { +// continue; +// } +// if (screen->GetId() == expandId) { +// isExpandIdValid = true; +// break; +// } +// } + +// if (!isExpandIdValid) { +// cout << "input expandId is not valid!" << endl; +// return; +// } + +// sptr defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay(); +// cout << endl << "------------start expand----------" << endl; +// cout << "expand screen Id is " << expandId << endl; +// vector options = {{defaultDisplay->GetScreenId(), 0, 0}, {expandId, defaultDisplay->GetWidth(), 0}}; +// ScreenId screenGroupId; +// ScreenManager::GetInstance().MakeExpand(options, screenGroupId); +// } + +// static void StopExpand() +// { +// vector> remoteScreens = QueryRemoteScreenInfo(); +// if (remoteScreens.size() == 0) { +// cout << "no remote screens enabled, no need stop expand" << endl; +// return; +// } + +// bool isStopExpandIdValid = false; +// cout << "select remote screen id to stop expand: " << endl; +// uint64_t stopExpandId; +// cin >> stopExpandId; + +// for (const auto &screen : remoteScreens) { +// if (screen == nullptr) { +// continue; +// } +// if (screen->GetId() == stopExpandId) { +// isStopExpandIdValid = true; +// break; +// } +// } +// if (!isStopExpandIdValid) { +// cout << "input screenId is not valid!" << endl; +// return; +// } + +// cout << "-------------- stop expand ------------" << endl; +// cout << "stop expand screen id is " << stopExpandId << endl; +// vector stopExpandIds; +// stopExpandIds.push_back(stopExpandId); +// ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(stopExpandIds); +// } + +// static void PrintNodeProperty(NodeBasicInfo *nodeInfo) +// { +// if (nodeInfo == nullptr) { +// cout << "nodeInfo is nullptr" << endl; +// return; +// } + +// printf("DeviceName = %s\n", nodeInfo->deviceName); +// printf("NetworkId = %s\n", GetAnonyString(nodeInfo->networkId).c_str()); +// NodeDeviceInfoKey key = NODE_KEY_UDID; +// unsigned char udid[UDID_BUF_LEN] = {0}; +// if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key, udid, UDID_BUF_LEN) != 0) { +// printf("GetNodeKeyInfo Fail!\n"); +// } else { +// printf("Udid = %s\n", GetAnonyString(reinterpret_cast(udid)).c_str()); +// } +// key = NODE_KEY_UUID; +// unsigned char uuid[UUID_BUF_LEN] = {0}; +// if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key, uuid, UUID_BUF_LEN) != 0) { +// printf("GetNodeKeyInfo Fail!\n"); +// } else { +// printf("Uuid = %s\n", GetAnonyString(reinterpret_cast(udid)).c_str()); +// } +// } + +// static void QueryRemoteDeviceInfo() +// { +// uint64_t tokenId; +// const char *perms[2]; +// perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER; +// perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC; +// NativeTokenInfoParams infoInstance = { +// .dcapsNum = 0, +// .permsNum = 2, +// .aclsNum = 0, +// .dcaps = NULL, +// .perms = perms, +// .acls = NULL, +// .processName = "dscreen_test_demo", +// .aplStr = "system_core", +// }; +// tokenId = GetAccessTokenId(&infoInstance); +// SetSelfTokenID(tokenId); +// OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + +// NodeBasicInfo localNodeinfo; +// NodeBasicInfo *remoteNodeInfo = nullptr; +// int32_t infoNum = 0; +// printf("-----------Local Device Info------\n"); +// if (GetLocalNodeDeviceInfo(g_pkgName, &localNodeinfo) != 0) { +// printf("LnnGetLocalNodeInfo Fail!\n"); +// return; +// } +// PrintNodeProperty(&localNodeinfo); +// printf("-------Remote Device info---------\n"); +// if (GetAllNodeDeviceInfo(g_pkgName, &remoteNodeInfo, &infoNum) != 0) { +// printf("GetAllNodeDeviceInfo Fail!\n"); +// return; +// } +// printf("Device Num = %" PRId32 "\n", infoNum); +// for (int i = 0; i < infoNum; ++i) { +// printf("\n[No.%" PRId32 "]", i + 1); +// PrintNodeProperty(remoteNodeInfo + i); +// } +// FreeNodeInfo(remoteNodeInfo); +// printf("SoftBusDumpDeviceInfo complete!\n"); +// } + +// static void CreateWindow() +// { +// cout << "create window, please input window size" << endl; +// cout << "width: "; +// uint32_t windowWidth; +// cin >> windowWidth; +// cout << "height: "; +// uint32_t windowHeight; +// cin >> windowHeight; + +// if (windowWidth == 0 || windowWidth >= MAX_WINDOW_WIDTH || +// windowHeight == 0 || windowHeight >= MAX_WINDOW_HEIGHT) { +// cout << "Invalid window size." << endl; +// return; +// } + +// sptr defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay(); +// shared_ptr windowProperty = make_shared(); +// windowProperty->displayId = defaultDisplay->GetId(); +// windowProperty->startX = 0; +// windowProperty->startY = 0; +// windowProperty->width = windowWidth; +// windowProperty->height = windowHeight; +// int32_t windowId = ScreenClient::GetInstance().AddWindow(windowProperty); +// ScreenClient::GetInstance().ShowWindow(windowId); +// sptr surface = ScreenClient::GetInstance().GetSurface(windowId); +// cout << "create window success." << endl; + +// auto vdec = make_shared(); + +// vdec->SetWindowSize(DCODE_WIDTH, DCODE_HEIGHT); +// vdec->SetOutputSurface(surface); +// cout << "start run decoder" << endl; +// vdec->RunCase(); +// cout << "create window success, window id: " << windowId +// << ", width: " << windowWidth +// << ", height: " << windowHeight << endl; +// ScreenClient::GetInstance().RemoveWindow(windowId); +// _Exit(0); +// } + +int dscreen_disconnect() +{ + return StopMirror(); +} +int dscreen_connect() +{ + return StartMirror(); +} -- Gitee From c64e72f0ff698f7729a36f2eb84e85293b2dff5c Mon Sep 17 00:00:00 2001 From: "minjie.yu" Date: Wed, 6 Dec 2023 10:06:13 +0800 Subject: [PATCH 2/2] fix: fix screennapi directory Signed-off-by: minjie.yu --- {screennapi => services/screennapi}/BUILD.gn | 0 {screennapi => services/screennapi}/decoder_demo.cpp | 0 {screennapi => services/screennapi}/decoder_demo.h | 0 {screennapi => services/screennapi}/js_screen_demo_manager.cpp | 0 {screennapi => services/screennapi}/js_screen_demo_manager.h | 0 {screennapi => services/screennapi}/js_screen_demo_module.cpp | 0 {screennapi => services/screennapi}/screendemo_manager_hilog.h | 0 {screennapi => services/screennapi}/test.cpp | 0 8 files changed, 0 insertions(+), 0 deletions(-) rename {screennapi => services/screennapi}/BUILD.gn (100%) rename {screennapi => services/screennapi}/decoder_demo.cpp (100%) rename {screennapi => services/screennapi}/decoder_demo.h (100%) rename {screennapi => services/screennapi}/js_screen_demo_manager.cpp (100%) rename {screennapi => services/screennapi}/js_screen_demo_manager.h (100%) rename {screennapi => services/screennapi}/js_screen_demo_module.cpp (100%) rename {screennapi => services/screennapi}/screendemo_manager_hilog.h (100%) rename {screennapi => services/screennapi}/test.cpp (100%) diff --git a/screennapi/BUILD.gn b/services/screennapi/BUILD.gn similarity index 100% rename from screennapi/BUILD.gn rename to services/screennapi/BUILD.gn diff --git a/screennapi/decoder_demo.cpp b/services/screennapi/decoder_demo.cpp similarity index 100% rename from screennapi/decoder_demo.cpp rename to services/screennapi/decoder_demo.cpp diff --git a/screennapi/decoder_demo.h b/services/screennapi/decoder_demo.h similarity index 100% rename from screennapi/decoder_demo.h rename to services/screennapi/decoder_demo.h diff --git a/screennapi/js_screen_demo_manager.cpp b/services/screennapi/js_screen_demo_manager.cpp similarity index 100% rename from screennapi/js_screen_demo_manager.cpp rename to services/screennapi/js_screen_demo_manager.cpp diff --git a/screennapi/js_screen_demo_manager.h b/services/screennapi/js_screen_demo_manager.h similarity index 100% rename from screennapi/js_screen_demo_manager.h rename to services/screennapi/js_screen_demo_manager.h diff --git a/screennapi/js_screen_demo_module.cpp b/services/screennapi/js_screen_demo_module.cpp similarity index 100% rename from screennapi/js_screen_demo_module.cpp rename to services/screennapi/js_screen_demo_module.cpp diff --git a/screennapi/screendemo_manager_hilog.h b/services/screennapi/screendemo_manager_hilog.h similarity index 100% rename from screennapi/screendemo_manager_hilog.h rename to services/screennapi/screendemo_manager_hilog.h diff --git a/screennapi/test.cpp b/services/screennapi/test.cpp similarity index 100% rename from screennapi/test.cpp rename to services/screennapi/test.cpp -- Gitee