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 screenId_ = Rosen::ScreenManager::GetInstance().CreateVirtualScreen(option);
109 SHARING_LOGI("virtualScreen id is: %{public}" PRIu64 ".", screenId_);
110
111 return screenId_;
112 }
113
DestroyVirtualScreen() const114 int32_t VideoSourceScreen::DestroyVirtualScreen() const
115 {
116 SHARING_LOGI("%{public}s.", __FUNCTION__);
117 if (screenId_ == SCREEN_ID_INVALID) {
118 SHARING_LOGE("Failed, invalid screenId!");
119 return ERR_GENERAL_ERROR;
120 }
121 SHARING_LOGI("Destroy virtual screen, screenId: %{public}" PRIu64 ".", screenId_);
122 Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screenId_);
123 if (err != Rosen::DMError::DM_OK) {
124 SHARING_LOGE("Destroy virtual screen failed, screenId:%{public}" PRIu64 "!", screenId_);
125 return ERR_GENERAL_ERROR;
126 }
127 return ERR_OK;
128 }
129
StartScreenSourceCapture()130 void VideoSourceScreen::StartScreenSourceCapture()
131 {
132 SHARING_LOGI("StartScreenSourceCapture begin.");
133 std::vector<uint64_t> mirrorIds;
134 mirrorIds.push_back(screenId_);
135 Rosen::ScreenId groupId = 0;
136 Rosen::DMError err = Rosen::ScreenManager::GetInstance().MakeMirror(srcScreenId_, mirrorIds, groupId);
137 if (err != Rosen::DMError::DM_OK) {
138 SHARING_LOGE("MakeMirror failed, screenId:%{public}" PRIu64 "!", screenId_);
139 }
140 SHARING_LOGI("StartScreenSourceCapture end.");
141 }
142
StopScreenSourceCapture()143 void VideoSourceScreen::StopScreenSourceCapture()
144 {
145 SHARING_LOGI("%{public}s.", __FUNCTION__);
146 UnregisterScreenGroupListener();
147 int32_t ret = DestroyVirtualScreen();
148 if (ret != ERR_OK) {
149 SHARING_LOGE("Destroy virtual screen failed!");
150 } else {
151 screenId_ = SCREEN_ID_INVALID;
152 SHARING_LOGI("Destroy virtual screen success!");
153 }
154 }
155
SetEncoderSurface(sptr<OHOS::Surface> surface)156 int32_t VideoSourceScreen::SetEncoderSurface(sptr<OHOS::Surface> surface)
157 {
158 SHARING_LOGI("%{public}s.", __FUNCTION__);
159 if (screenId_ == SCREEN_ID_INVALID) {
160 SHARING_LOGE("Failed, invalid screenId!");
161 }
162 if (surface == nullptr) {
163 SHARING_LOGE("Surface is nullptr!");
164 return ERR_GENERAL_ERROR;
165 }
166 SHARING_LOGI("Set surface for virtual screen, screenId: %{public}" PRIu64 ".", screenId_);
167 Rosen::DMError err = Rosen::ScreenManager::GetInstance().SetVirtualScreenSurface(screenId_, surface);
168 if (err != Rosen::DMError::DM_OK) {
169 SHARING_LOGE("Set surface for virtual screen failed, screenId:%{public}" PRIu64 "!", screenId_);
170 return ERR_GENERAL_ERROR;
171 }
172 return ERR_OK;
173 }
174
RemoveScreenFromGroup() const175 void VideoSourceScreen::RemoveScreenFromGroup() const
176 {
177 SHARING_LOGI("%{public}s.", __FUNCTION__);
178 if (screenId_ != SCREEN_ID_INVALID) {
179 SHARING_LOGE("Failed, invalid screenId!");
180 }
181 SHARING_LOGI("Remove screen from group, screenId: %{publid}" PRIu64 ".", screenId_);
182 std::vector<uint64_t> screenIds;
183 screenIds.push_back(screenId_);
184 Rosen::DMError err = Rosen::ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(screenIds);
185 if (err != Rosen::DMError::DM_OK) {
186 SHARING_LOGE("Remove screen from group failed, screenId:%{public}" PRIu64 "!", screenId_);
187 }
188 }
189 } // namespace Sharing
190 } // namespace OHOS
191