1 /*
2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "video_source_screen.h"
17 #include "screen.h"
18 #include "sharing_log.h"
19
20 namespace OHOS {
21 namespace Sharing {
22 using namespace std;
23
OnChange(const std::vector<uint64_t> & screenIds,Rosen::ScreenGroupChangeEvent event)24 void VideoSourceScreen::ScreenGroupListener::OnChange(const std::vector<uint64_t> &screenIds,
25 Rosen::ScreenGroupChangeEvent event)
26 {
27 SHARING_LOGI("%{public}s.", __FUNCTION__);
28 switch (event) {
29 case Rosen::ScreenGroupChangeEvent::ADD_TO_GROUP:
30 SHARING_LOGD("ADD_TO_GROUP done!");
31 break;
32 case Rosen::ScreenGroupChangeEvent::REMOVE_FROM_GROUP:
33 SHARING_LOGD("REMOVE_FROM_GROUP done!");
34 break;
35 case Rosen::ScreenGroupChangeEvent::CHANGE_GROUP:
36 SHARING_LOGD("CHANGE_GROUP done!");
37 break;
38 default:
39 break;
40 }
41 }
42
~VideoSourceScreen()43 VideoSourceScreen::~VideoSourceScreen()
44 {
45 SHARING_LOGI("%{public}s.", __FUNCTION__);
46 encoderSurface_ = nullptr;
47 }
48
InitScreenSource(const VideoSourceConfigure & configure)49 int32_t VideoSourceScreen::InitScreenSource(const VideoSourceConfigure &configure)
50 {
51 SHARING_LOGI("%{public}s.", __FUNCTION__);
52 if (encoderSurface_ == nullptr) {
53 SHARING_LOGE("encoderSurface_ is null!");
54 return ERR_GENERAL_ERROR;
55 }
56
57 RegisterScreenGroupListener();
58 CreateVirtualScreen(configure);
59 srcScreenId_ = configure.srcScreenId_;
60 return ERR_OK;
61 }
62
ReleaseScreenBuffer() const63 int32_t VideoSourceScreen::ReleaseScreenBuffer() const
64 {
65 SHARING_LOGI("%{public}s.", __FUNCTION__);
66 return ERR_OK;
67 }
68
RegisterScreenGroupListener()69 int32_t VideoSourceScreen::RegisterScreenGroupListener()
70 {
71 SHARING_LOGI("%{public}s.", __FUNCTION__);
72 if (screenGroupListener_ == nullptr) {
73 screenGroupListener_ = new ScreenGroupListener();
74 }
75 auto ret = Rosen::ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupListener_);
76 if (ret != OHOS::Rosen::DMError::DM_OK) {
77 SHARING_LOGE("RegisterScreenGroupListener Failed!");
78 return ERR_GENERAL_ERROR;
79 }
80 SHARING_LOGI("Register successed!");
81 return ERR_OK;
82 }
83
UnregisterScreenGroupListener() const84 int32_t VideoSourceScreen::UnregisterScreenGroupListener() const
85 {
86 SHARING_LOGI("%{public}s.", __FUNCTION__);
87 auto ret = Rosen::ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupListener_);
88 if (ret != OHOS::Rosen::DMError::DM_OK) {
89 SHARING_LOGE("UnregisterScreenGroupListener Failed!");
90 return ERR_GENERAL_ERROR;
91 }
92 return ERR_OK;
93 }
94
CreateVirtualScreen(const VideoSourceConfigure & configure)95 uint64_t VideoSourceScreen::CreateVirtualScreen(const VideoSourceConfigure &configure)
96 {
97 SHARING_LOGI("CreateVirtualScreen, width: %{public}u, height: %{public}u.", configure.screenWidth_,
98 configure.screenHeight_);
99 std::string screenName = "MIRACAST_HOME_SCREEN";
100 Rosen::VirtualScreenOption option = {screenName,
101 configure.screenWidth_,
102 configure.screenHeight_,
103 DEFAULT_SCREEN_DENSITY,
104 encoderSurface_,
105 DEFAULT_SCREEN_FLAGS,
106 false,
107 {},
108 Rosen::VirtualScreenType::UNKNOWN,
109 true,
110 Rosen::VirtualScreenFlag::DEFAULT};
111
112 screenId_ = Rosen::ScreenManager::GetInstance().CreateVirtualScreen(option);
113 SHARING_LOGI("virtualScreen id is: %{public}" PRIu64 ".", screenId_);
114
115 return screenId_;
116 }
117
DestroyVirtualScreen() const118 int32_t VideoSourceScreen::DestroyVirtualScreen() const
119 {
120 SHARING_LOGI("%{public}s.", __FUNCTION__);
121 if (screenId_ == SCREEN_ID_INVALID) {
122 SHARING_LOGE("Failed, invalid screenId!");
123 return ERR_GENERAL_ERROR;
124 }
125 SHARING_LOGI("Destroy virtual screen, screenId: %{public}" PRIu64 ".", screenId_);
126 Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screenId_);
127 if (err != Rosen::DMError::DM_OK) {
128 SHARING_LOGE("Destroy virtual screen failed, screenId:%{public}" PRIu64 "!", screenId_);
129 return ERR_GENERAL_ERROR;
130 }
131 return ERR_OK;
132 }
133
StartScreenSourceCapture()134 void VideoSourceScreen::StartScreenSourceCapture()
135 {
136 SHARING_LOGI("StartScreenSourceCapture begin.");
137 std::vector<uint64_t> mirrorIds;
138 mirrorIds.push_back(screenId_);
139 Rosen::ScreenId groupId = 0;
140 Rosen::DMError err = Rosen::ScreenManager::GetInstance().MakeMirror(srcScreenId_, mirrorIds, groupId);
141 if (err != Rosen::DMError::DM_OK) {
142 SHARING_LOGE("MakeMirror failed, screenId:%{public}" PRIu64 "!", screenId_);
143 }
144 SHARING_LOGI("StartScreenSourceCapture end.");
145 }
146
StopScreenSourceCapture()147 void VideoSourceScreen::StopScreenSourceCapture()
148 {
149 SHARING_LOGI("%{public}s.", __FUNCTION__);
150 UnregisterScreenGroupListener();
151 int32_t ret = DestroyVirtualScreen();
152 if (ret != ERR_OK) {
153 SHARING_LOGE("Destroy virtual screen failed!");
154 } else {
155 screenId_ = SCREEN_ID_INVALID;
156 SHARING_LOGI("Destroy virtual screen success!");
157 }
158 }
159
SetEncoderSurface(sptr<OHOS::Surface> surface)160 int32_t VideoSourceScreen::SetEncoderSurface(sptr<OHOS::Surface> surface)
161 {
162 SHARING_LOGI("%{public}s.", __FUNCTION__);
163 if (screenId_ == SCREEN_ID_INVALID) {
164 SHARING_LOGE("Failed, invalid screenId!");
165 }
166 if (surface == nullptr) {
167 SHARING_LOGE("Surface is nullptr!");
168 return ERR_GENERAL_ERROR;
169 }
170 SHARING_LOGI("Set surface for virtual screen, screenId: %{public}" PRIu64 ".", screenId_);
171 Rosen::DMError err = Rosen::ScreenManager::GetInstance().SetVirtualScreenSurface(screenId_, surface);
172 if (err != Rosen::DMError::DM_OK) {
173 SHARING_LOGE("Set surface for virtual screen failed, screenId:%{public}" PRIu64 "!", screenId_);
174 return ERR_GENERAL_ERROR;
175 }
176 return ERR_OK;
177 }
178
RemoveScreenFromGroup() const179 void VideoSourceScreen::RemoveScreenFromGroup() const
180 {
181 SHARING_LOGI("%{public}s.", __FUNCTION__);
182 if (screenId_ != SCREEN_ID_INVALID) {
183 SHARING_LOGE("Failed, invalid screenId!");
184 }
185 SHARING_LOGI("Remove screen from group, screenId: %{publid}" PRIu64 ".", screenId_);
186 std::vector<uint64_t> screenIds;
187 screenIds.push_back(screenId_);
188 Rosen::DMError err = Rosen::ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(screenIds);
189 if (err != Rosen::DMError::DM_OK) {
190 SHARING_LOGE("Remove screen from group failed, screenId:%{public}" PRIu64 "!", screenId_);
191 }
192 }
193 } // namespace Sharing
194 } // namespace OHOS
195