<bianjianliang1@huawei.com>

Signed-off-by: bjliang <bianjianliang1@huawei.com>

distributedhardware/BUILD.gn

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Huawei Device Co., Ltd.
+# 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
@@ -10,11 +10,15 @@
 # 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_var.gni")
 
-group("distributedcameratest") {
+group("distributedhardware") {
   testonly = true
   if (is_standard_system) {
-    deps = [ "distributedcameratest:DctsdisCameraTest" ]
+    deps = [
+      "distributedcameratest:DctsdisCameraTest",
+      "distributedscreentest:DctsdisSreenTest",
+    ]
   }
 }

distributedhardware/distributedscreentest/BUILD.gn

@@ -0,0 +1,75 @@
+# 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.
+
+import("//test/xts/tools/build/suite.gni")
+
+module_output_path = "dcts/distributedhardware"
+
+ohos_moduletest_suite("DctsdisSreenTest") {
+  module_out_path = module_output_path
+  include_dirs = [
+    "//foundation/distributedhardware/distributed_screen/services/common/utils/include",
+    "//foundation/distributedhardware/distributed_screen/interfaces/innerkits/native_cpp/screen_sink/include",
+    "///foundation/distributedhardware/distributed_screen/interfaces/innerkits/native_cpp/screen_source/include",
+    "//foundation/distributedhardware/distributed_screen/interfaces/innerkits/native_cpp/screen_source/include/callback",
+    "//foundation/distributedhardware/distributed_hardware_fwk/common/utils/include",
+    "//foundation/window/window_manager//interfaces/innerkits/dm",
+    "//foundation/distributedhardware/distributed_screen/services/screenclient/include",
+    "//foundation/window/window_manager//interfaces/innerkits/wm",
+    "//foundation/distributedhardware/distributed_screen/common/include",
+    "//foundation/distributedhardware/distributed_hardware_fwk/common/log/include",
+    "//foundation/distributedhardware/distributed_hardware_fwk/utils/include/log",
+    "//base/security/access_token/interfaces/innerkits/accesstoke/include",
+    "//base/security/access_token/interfaces/innerkits/nativetoken/include",
+    "//base/security/access_token/interfaces/innerkits/token_setproc/include",
+    "//foundation/communication/dsoftbus/interfaces/kits/common",
+  ]
+
+  include_dirs +=
+      [ "foundation/multimedia/player_framework/interfaces/inner_api/native" ]
+
+  sources = [
+    "decoder_demo.cpp",
+    "dsreen_automat_test.cpp",
+    "test.cpp",
+  ]
+
+  defines = [
+    "HI_LOG_ENABLE",
+    "DH_LOG_TAG=\"DSreenClientTest\"",
+    "LOG_DOMAIN=0xD004100",
+  ]
+
+  deps = [
+    "//base/security/access_token/interfaces/innerkits/nativetoken:libnativetoken",
+    "//base/security/access_token/interfaces/innerkits/token_setproc:libtoken_setproc",
+    "//foundation/communication/dsoftbus/adapter:softbus_adapter",
+    "//foundation/communication/dsoftbus/sdk:softbus_client",
+    "//foundation/distributedhardware/distributed_screen/common:distributed_screen_utils",
+    "//foundation/distributedhardware/distributed_screen/interfaces/innerkits/native_cpp/screen_sink:distributed_screen_sink_sdk",
+    "//foundation/distributedhardware/distributed_screen/interfaces/innerkits/native_cpp/screen_source:distributed_screen_source_sdk",
+    "//foundation/distributedhardware/distributed_screen/services/screenclient:distributed_screen_client",
+    "//foundation/graphic/graphic_2d/rosen/modules/render_service_client:librender_service_client",
+    "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy",
+    "//foundation/window/window_manager/dm:libdm",
+    "//foundation/window/window_manager/wm:libwm",
+  ]
+
+  external_deps = [
+    "hiviewdfx_hilog_native:libhilog",
+    "multimedia_player_framework:media_client",
+  ]
+
+  subsystem_name = "distributedhardware"
+  part_name = "distributed_screen"
+}

distributedhardware/distributedscreentest/Test.json

@@ -0,0 +1,22 @@
+{
+    "description": "Config for disSreen test cases",
+    "driver": {
+        "module-name": "DctsdisSreenTest",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "1s",
+        "type": "CppTest"
+    },
+    "kits": [
+     {
+        "post-push" : [
+        "chmod -R 777 /data/local/tmp/*"
+     ],
+        "push": [
+          "DctsdisSreenTest->/data/local/tmp/DctsdisSreenTest"
+	],
+      "type": "PushKit"
+       }
+    ]
+}
+

distributedhardware/distributedscreentest/decoder_demo.cpp

@@ -0,0 +1,344 @@
+/*
+ * 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 "decoder_demo.h"
+
+#include <iostream>
+#include <unistd.h>
+
+#include "avcodec_list.h"
+#include "securec.h"
+#include "ui/rs_surface_node.h"
+#include "wm_common.h"
+#include "window.h"
+#include "window_option.h"
+
+using namespace OHOS::DistributedHardware;
+
+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<VDecSignal>();
+    cb_ = make_unique<VDecDemoCallback>(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<std::ifstream>();
+    testFile_->open("/data/media/video.es", std::ios::in | std::ios::binary);
+
+    inputLoop_ = make_unique<thread>(&VDecDemo::InputFunc, this);
+    outputLoop_ = make_unique<thread>(&VDecDemo::OutputFunc, this);
+    return vdec_->Start();
+}
+
+int32_t VDecDemo::Stop()
+{
+    isRunning_.store(false);
+
+    if (inputLoop_ != nullptr && inputLoop_->joinable()) {
+        {
+            unique_lock<mutex> inLock(signal_->inMutex_);
+            signal_->inQueue_.push(INDEX_CONSTANT);
+            signal_->inCond_.notify_all();
+        }
+        inputLoop_->join();
+        inputLoop_.reset();
+    }
+
+    if (outputLoop_ != nullptr && outputLoop_->joinable()) {
+        {
+            unique_lock<mutex> 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_ = 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<std::string> localCodecArray;
+    std::shared_ptr<Media::AVCodecList> codecList = Media::AVCodecListFactory::CreateAVCodecList();
+    std::vector<std::shared_ptr<Media::VideoCaps>> caps = codecList->GetVideoEncoderCaps();
+    for (const auto &cap : caps) {
+        std::shared_ptr<Media::AVCodecInfo> codecInfo = cap->GetCodecInfo();
+        localCodecArray.push_back(codecInfo->GetName());
+    }
+
+    if (std::find(localCodecArray.begin(), localCodecArray.end(),
+        CODEC_NAME_H264) != localCodecArray.end()) {
+        DHLOGI("device is W");
+        isW = true;
+    } else if (std::find(localCodecArray.begin(), localCodecArray.end(),
+        CODEC_NAME_MPEG4) != localCodecArray.end()) {
+        DHLOGI("device is R");
+        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<mutex> 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 = (char *)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);
+            DHLOGI("Fatal: memcpy fail");
+            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_) {
+            DHLOGI("Finish decode, exit");
+            break;
+        }
+
+        if (ret != 0) {
+            DHLOGI("Fatal error, exit");
+            break;
+        }
+    }
+}
+
+void VDecDemo::OutputFunc()
+{
+    while (true) {
+        if (!isRunning_.load()) {
+            break;
+        }
+
+        unique_lock<mutex> 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) {
+            DHLOGI("Fatal: ReleaseOutputBuffer fail");
+            break;
+        }
+
+        signal_->outQueue_.pop();
+    }
+}
+
+VDecDemoCallback::VDecDemoCallback(shared_ptr<VDecSignal> signal)
+    : signal_(signal)
+{
+}
+
+void VDecDemoCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
+{
+    DHLOGI("Error received, errorType: %s, errorCode: %d", errorType, errorCode);
+}
+
+void VDecDemoCallback::OnOutputFormatChanged(const Format &format)
+{
+    DHLOGI("OnOutputFormatChanged received");
+}
+
+void VDecDemoCallback::OnInputBufferAvailable(uint32_t index)
+{
+    DHLOGI("OnInputBufferAvailable received, index: %d", index);
+    unique_lock<mutex> lock(signal_->inMutex_);
+    signal_->inQueue_.push(index);
+    signal_->inCond_.notify_all();
+}
+
+void VDecDemoCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag)
+{
+    DHLOGI("OnOutputBufferAvailable received, index: %d", index);
+    unique_lock<mutex> lock(signal_->outMutex_);
+    signal_->outQueue_.push(index);
+    signal_->outCond_.notify_all();
+}

distributedhardware/distributedscreentest/decoder_demo.h

@@ -0,0 +1,104 @@
+/*
+ * 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 <atomic>
+#include <fstream>
+#include <queue>
+#include <string>
+#include <thread>
+
+#include "avcodec_video_decoder.h"
+#include "nocopyable.h"
+#include "distributed_hardware_log.h"
+
+namespace OHOS {
+namespace Media {
+class VDecSignal {
+public:
+    std::mutex inMutex_;
+    std::mutex outMutex_;
+    std::condition_variable inCond_;
+    std::condition_variable outCond_;
+    std::queue<uint32_t> inQueue_;
+    std::queue<uint32_t> outQueue_;
+};
+
+class VDecDemoCallback : public AVCodecCallback, public NoCopyable {
+public:
+    explicit VDecDemoCallback(std::shared_ptr<VDecSignal> 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<VDecSignal> signal_;
+};
+
+class VDecDemo : public NoCopyable {
+public:
+    VDecDemo() = default;
+    virtual ~VDecDemo() = default;
+    void RunCase();
+    void SetOutputSurface(sptr<Surface> 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<bool> isRunning_ = false;
+    sptr<Surface> surface_ = nullptr;
+    uint32_t width_ = 0;
+    uint32_t height_ = 0;
+    std::unique_ptr<std::ifstream> testFile_;
+    std::unique_ptr<std::thread> inputLoop_;
+    std::unique_ptr<std::thread> outputLoop_;
+    std::shared_ptr<Media::AVCodecVideoDecoder> vdec_;
+    std::shared_ptr<VDecSignal> signal_;
+    std::shared_ptr<VDecDemoCallback> cb_;
+    bool isFirstFrame_ = true;
+    bool isW = true;
+    int64_t timeStamp_ = 0;
+    uint32_t frameCount_ = 0;
+    uint32_t defaultFrameCount_ = 0;
+};
+} // namespace Media
+} // namespace OHOS
+
+int StartMirror(void);
+int StopMirror(void);
+int StartExpand(void);
+int StopExpand(void);
+int CreateWindow(void);
+int QueryRemoteDeviceInfo(void);
+int QueryRemoteScreenInfo(void);
+#endif // AVCODEC_VDEC_DEMO_H

distributedhardware/distributedscreentest/dsreen_automat_test.cpp

@@ -0,0 +1,103 @@
+/*
+ * 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 <gtest/gtest.h>
+#include "decoder_demo.h"
+#include "nativetoken_kit.h"
+#include "token_setproc.h"
+#include "softbus_common.h"
+
+using namespace testing::ext;
+
+int32_t g_dSreenOk = 0;
+int32_t g_dSleepOk = 1;
+
+class DSreenAutomatTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    DSreenAutomatTest();
+};
+void DSreenAutomatTest::SetUpTestCase(void)
+{
+    uint64_t tokenId;
+    const char *perms[2];
+    perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
+    perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
+    NativeTokenInfoParams infoTnstance = {
+        .dcapsNum = 0,
+        .permsNum = 2,
+        .aclsNum = 0,
+        .dcaps = NULL,
+        .perms = perms,
+        .acls = NULL,
+        .processName = "dsoftbus_service",
+        .aplStr = "system_core",
+    };
+    tokenId = GetAccessTokenId(&infoTnstance);
+    SetSelfTokenID(tokenId);
+    sleep(g_dSleepOk);
+    system("pidof accesstoken_ser | xargs kill -9");
+}
+
+void DSreenAutomatTest::TearDownTestCase(void) {}
+void DSreenAutomatTest::SetUp(void) {}
+
+void DSreenAutomatTest::TearDown(void) {}
+DSreenAutomatTest::DSreenAutomatTest(void) {}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0100, TestSize.Level1)
+{
+    int ret = StartMirror();
+    EXPECT_EQ(g_dSreenOk, ret) << "StartMirror fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0200, TestSize.Level1)
+{
+    int ret = StopMirror();
+    EXPECT_EQ(g_dSreenOk, ret) << "StopMirror fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0300, TestSize.Level1)
+{
+    int ret = StartExpand();
+    EXPECT_EQ(g_dSreenOk, ret) << "StartExpand fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0400, TestSize.Level1)
+{
+    int ret = StopExpand();
+    EXPECT_EQ(g_dSreenOk, ret) << "StopExpand fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0500, TestSize.Level1)
+{
+    int ret = CreateWindow();
+    EXPECT_EQ(g_dSreenOk, ret) << "CreateWindow fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0600, TestSize.Level1)
+{
+    int ret = QueryRemoteDeviceInfo();
+    EXPECT_EQ(g_dSreenOk, ret) << "QueryRemoteDeviceInfo fail";
+}
+
+HWTEST_F(DSreenAutomatTest, DSreenTest_0700, TestSize.Level1)
+{
+    int ret = QueryRemoteScreenInfo();
+    EXPECT_EQ(g_dSreenOk, ret) << "QueryRemoteScreenInfo fail";
+}

distributedhardware/distributedscreentest/test.cpp

@@ -0,0 +1,300 @@
+/*
+ * 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 <iostream>
+
+#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 "decoder_demo.h"
+#include "softbus_adapter_mem.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;
+
+namespace {
+    static char const *g_pkgName = "ohos.dsoftbus.tool";
+}
+
+constexpr int32_t SLEEP_FIVE_SECOND = 10;
+static vector<sptr<Screen>> remoteScreens;
+static uint64_t g_screenId = 0;
+
+int QueryRemoteScreenInfo(void)
+{
+    vector<sptr<Screen>> allScreens = ScreenManager::GetInstance().GetAllScreens();
+    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay();
+    for (const auto &screen : allScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        if (!screen->IsReal() && screen->GetWidth() > 0) {
+            remoteScreens.push_back(screen);
+        }
+    }
+    DHLOGE("-------------remote screen info---------------");
+    DHLOGE("remote screen Num: %d", remoteScreens.size());
+    for (const auto &screen : remoteScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        g_screenId = screen->GetId();
+        DHLOGE("--------screen id: %d ---------", screen->GetId());
+        DHLOGE("screen name: : %s", GetAnonyString(screen->GetName()).c_str());
+        DHLOGE("width: : %d", screen->GetWidth());
+        DHLOGE("height : %d", screen->GetHeight());
+        DHLOGE("-------------------------------------------");
+    }
+
+    return 0;
+}
+
+int StartMirror(void)
+{
+    uint64_t ret = QueryRemoteScreenInfo();
+    if (ret != 0) {
+        DHLOGE("Error: no remote screens enabled");
+        return -1;
+    }
+
+    DHLOGE("select remote screen id to mirror");
+    
+    bool isMirrorIdValid = false;
+    for (const auto &screen : remoteScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        if (screen->GetId() == g_screenId) {
+            isMirrorIdValid = true;
+            break;
+        }
+    }
+
+    if (!isMirrorIdValid) {
+        DHLOGE("input mirrorId is not valid!");
+        return -1;
+    }
+
+    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay();
+    DHLOGE("------------start mirror----------");
+    DHLOGE("mirror screen Id is: %d", g_screenId);
+    vector<uint64_t> mirrorIds;
+    mirrorIds.push_back(g_screenId);
+    ScreenManager::GetInstance().MakeMirror(defaultDisplay->GetScreenId(), mirrorIds);
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}
+
+int StopMirror(void)
+{
+    uint64_t ret = QueryRemoteScreenInfo();
+    if (ret != 0) {
+        DHLOGE("no remote screens enabled, no need stop mirror ");
+        return -1;
+    }
+
+    bool isStopMirrorIdValid = false;
+    for (const auto &screen : remoteScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        if (screen->GetId() == g_screenId) {
+            isStopMirrorIdValid = true;
+            break;
+        }
+    }
+    if (!isStopMirrorIdValid) {
+        DHLOGE("input g_screenId is not valid! ");
+        return -1;
+    }
+
+    DHLOGE("-------------- stop mirror ------------");
+    DHLOGE("stop mirror screen id is: %d", g_screenId);
+    vector<uint64_t> stopMirrorIds;
+    stopMirrorIds.push_back(g_screenId);
+    ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(stopMirrorIds);
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}
+
+int StartExpand(void)
+{
+    uint64_t ret = QueryRemoteScreenInfo();
+    if (ret != 0) {
+        DHLOGE("Error: no remote screens enabled");
+        return -1;
+    }
+
+    bool isExpandIdValid = false;
+    for (const auto &screen : remoteScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        if (screen->GetId() == g_screenId) {
+            isExpandIdValid = true;
+            break;
+        }
+    }
+
+    if (!isExpandIdValid) {
+        DHLOGE("input expandId is not valid!");
+        return -1;
+    }
+
+    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay();
+    DHLOGE("------------start expand----------");
+    DHLOGE("expand screen Id is: %d", g_screenId);
+    vector<ExpandOption> options = {{defaultDisplay->GetScreenId(), 0, 0}, {g_screenId, defaultDisplay->GetWidth(), 0}};
+    ScreenManager::GetInstance().MakeExpand(options);
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}
+
+int StopExpand(void)
+{
+    uint64_t ret = QueryRemoteScreenInfo();
+    if (ret != 0) {
+        DHLOGE("no remote screens enabled, no need stop expand");
+        return -1;
+    }
+
+    bool isStopExpandIdValid = false;
+    for (const auto &screen : remoteScreens) {
+        if (screen == nullptr) {
+            continue;
+        }
+        if (screen->GetId() == g_screenId) {
+            isStopExpandIdValid = true;
+            break;
+        }
+    }
+    if (!isStopExpandIdValid) {
+        DHLOGE("input g_screenId is not valid!");
+        return -1;
+    }
+
+    DHLOGE("-------------- stop expand ------------");
+    DHLOGE("stop expand screen id is : %d", g_screenId);
+    vector<uint64_t> stopExpandIds;
+    stopExpandIds.push_back(g_screenId);
+    ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(stopExpandIds);
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}
+
+static void PrintNodeProperty(NodeBasicInfo *nodeInfo)
+{
+    if (nodeInfo == nullptr) {
+        DHLOGE("nodeInfo is nullptr");
+        return;
+    }
+
+    DHLOGE("DeviceName = %s", nodeInfo->deviceName);
+    DHLOGE("NetworkId = %s", 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) {
+        DHLOGE("GetNodeKeyInfo Fail!");
+    }
+    key = NODE_KEY_UUID;
+    unsigned char uuid[UUID_BUF_LEN] = {0};
+    if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key, uuid, UUID_BUF_LEN) != 0) {
+        DHLOGE("GetNodeKeyInfo Fail!");
+    }
+}
+
+int QueryRemoteDeviceInfo(void)
+{
+    NodeBasicInfo localNodeinfo;
+    NodeBasicInfo *remoteNodeInfo = nullptr;
+    int32_t infoNum = 0;
+
+    DHLOGE("-----------Local Device Info------");
+
+    if (GetLocalNodeDeviceInfo(g_pkgName, &localNodeinfo) != 0) {
+        printf("LnnGetLocalNodeInfo Fail!\n");
+        DHLOGE("LnnGetLocalNodeInfo Fail!");
+        return -1;
+    }
+
+    PrintNodeProperty(&localNodeinfo);
+    DHLOGE("-------Remote Device info---------");
+    if (GetAllNodeDeviceInfo(g_pkgName, &remoteNodeInfo, &infoNum) != 0) {
+        DHLOGE("GetAllNodeDeviceInfo Fail!");
+        return -1;
+    }
+
+    DHLOGE("Device Num = %d", infoNum);
+    for (int i = 0; i < infoNum; ++i) {
+        DHLOGE("[No.%d]", i + 1);
+        PrintNodeProperty(remoteNodeInfo + i);
+    }
+
+    FreeNodeInfo(remoteNodeInfo);
+    DHLOGE("SoftBusDumpDeviceInfo complete");
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}
+
+int CreateWindow(void)
+{
+    DHLOGE("create window, please input window size");
+
+    uint32_t windowWidth = 640;
+    uint32_t windowHeight = 480;
+   
+    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDefaultDisplay();
+    shared_ptr<WindowProperty> windowProperty = make_shared<WindowProperty>();
+    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> surface = ScreenClient::GetInstance().GetSurface(windowId);
+    DHLOGE("create window success.");
+
+    auto vdec = make_shared<VDecDemo>();
+    if (vdec == nullptr) {
+        DHLOGE("videoDecoder is nullptr");
+        return -1;
+    }
+    vdec->SetWindowSize(windowWidth, windowHeight);
+    vdec->SetOutputSurface(surface);
+    DHLOGE("start run decoder");
+    vdec->RunCase();
+    DHLOGE("create window success, window id: %d, width: %d, height: %d", windowId, windowWidth, windowHeight);
+    ScreenClient::GetInstance().RemoveWindow(windowId);
+    sleep(SLEEP_FIVE_SECOND);
+    return 0;
+}

test_packages.gni

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 Huawei Device Co., Ltd.
+# 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
@@ -14,7 +14,7 @@
 import("//test/xts/tools/build/suite.gni")
 
 _all_test_packages = [
-  "${DCTS_ROOT}/distributedhardware:distributedcameratest",
+  "${DCTS_ROOT}/distributedhardware:distributedhardware",
   "${DCTS_ROOT}/distributeddatamgr:distributeddatatest",
   "${DCTS_ROOT}/communication:communication",
   "${DCTS_ROOT}/filemanagement:filemanagement",