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 "screen_capture_session.h"
17 #include "common/common.h"
18 #include "common/common_macro.h"
19 #include "common/reflect_registration.h"
20 #include "common/sharing_log.h"
21 #include "extend/magic_enum/magic_enum.hpp"
22 #include "screen_capture_def.h"
23
24 namespace OHOS {
25 namespace Sharing {
ScreenCaptureSession()26 ScreenCaptureSession::ScreenCaptureSession()
27 {
28 SHARING_LOGD("id: %{public}u.", GetId());
29 }
30
~ScreenCaptureSession()31 ScreenCaptureSession::~ScreenCaptureSession()
32 {
33 SHARING_LOGD("id: %{public}u.", GetId());
34 }
35
HandleEvent(SharingEvent & event)36 int32_t ScreenCaptureSession::HandleEvent(SharingEvent &event)
37 {
38 SHARING_LOGD("trace.");
39 RETURN_INVALID_IF_NULL(event.eventMsg);
40
41 SHARING_LOGI("eventType: %{public}s, capture sessionId: %{public}u.",
42 std::string(magic_enum::enum_name(event.eventMsg->type)).c_str(), GetId());
43 switch (event.eventMsg->type) {
44 case EventType::EVENT_SESSION_INIT:
45 HandleSessionInit(event);
46 break;
47 case EventType::EVENT_AGENT_STATE_PROSUMER_INIT:
48 HandleProsumerInitState(event);
49 break;
50 default:
51 SHARING_LOGI("none process case.");
52 break;
53 }
54
55 return 0;
56 }
57
HandleSessionInit(SharingEvent & event)58 void ScreenCaptureSession::HandleSessionInit(SharingEvent &event)
59 {
60 SHARING_LOGD("trace.");
61 RETURN_IF_NULL(event.eventMsg);
62
63 auto inputMsg = ConvertEventMsg<ScreenCaptureSessionEventMsg>(event);
64 if (inputMsg) {
65 captureType_ = inputMsg->mediaType;
66 videoFormat_ = inputMsg->videoFormat;
67 audioFormat_ = inputMsg->audioFormat;
68 screenId_ = inputMsg->screenId;
69 SHARING_LOGI("videoFormat_: %{public}d, type: %{public}d, screenId: %{public}" SCNu64
70 ", audioFormat_: %{public}d.",
71 videoFormat_, captureType_, screenId_, audioFormat_);
72 } else {
73 SHARING_LOGE("unknow event msg.");
74 }
75 }
76
HandleProsumerInitState(SharingEvent & event)77 void ScreenCaptureSession::HandleProsumerInitState(SharingEvent &event)
78 {
79 SHARING_LOGD("trace.");
80 RETURN_IF_NULL(event.eventMsg);
81
82 auto inputMsg = ConvertEventMsg<ScreenCaptureSessionEventMsg>(event);
83 auto statusMsg = std::make_shared<SessionStatusMsg>();
84 statusMsg->msg = std::make_shared<EventMsg>();
85 statusMsg->status = STATE_SESSION_ERROR;
86 statusMsg->msg->errorCode = ERR_SESSION_START;
87
88 if (inputMsg) {
89 statusMsg->msg->requestId = inputMsg->requestId;
90
91 if (inputMsg->errorCode == ERR_OK) {
92 statusMsg->status = STATE_SESSION_STARTED;
93 statusMsg->msg->errorCode = ERR_OK;
94 } else {
95 SHARING_LOGE("consumer inited failed, id: %{public}u.", inputMsg->prosumerId);
96 }
97 } else {
98 SHARING_LOGE("consumer inited failed: unknow msg.");
99 return;
100 }
101
102 NotifyAgentSessionStatus(statusMsg);
103 }
104
UpdateOperation(SessionStatusMsg::Ptr & statusMsg)105 void ScreenCaptureSession::UpdateOperation(SessionStatusMsg::Ptr &statusMsg)
106 {
107 SHARING_LOGD("trace.");
108 RETURN_IF_NULL(statusMsg);
109 RETURN_IF_NULL(statusMsg->msg);
110
111 status_ = static_cast<SessionRunningStatus>(statusMsg->status);
112 SHARING_LOGI("status: %{public}s.", std::string(magic_enum::enum_name(status_)).c_str());
113 switch (status_) {
114 case SESSION_START:
115 statusMsg->status = NOTIFY_PROSUMER_CREATE;
116 break;
117 case SESSION_STOP:
118 statusMsg->status = STATE_SESSION_STOPED;
119 break;
120 case SESSION_PAUSE:
121 statusMsg->status = STATE_SESSION_PAUSED;
122 break;
123 case SESSION_RESUME:
124 statusMsg->status = STATE_SESSION_RESUMED;
125 break;
126 case SESSION_DESTROY:
127 statusMsg->status = STATE_SESSION_DESTROYED;
128 break;
129 default:
130 SHARING_LOGI("none process case.");
131 break;
132 }
133
134 NotifyAgentSessionStatus(statusMsg);
135 }
136
NotifyProsumerInit(SessionStatusMsg::Ptr & statusMsg)137 void ScreenCaptureSession::NotifyProsumerInit(SessionStatusMsg::Ptr &statusMsg)
138 {
139 SHARING_LOGD("trace.");
140 auto eventMsg = std::make_shared<ScreenCaptureConsumerEventMsg>();
141 eventMsg->type = EventType::EVENT_SCREEN_CAPTURE_INIT;
142 eventMsg->toMgr = ModuleType::MODULE_MEDIACHANNEL;
143 eventMsg->screenId = screenId_;
144 switch (captureType_) {
145 case MEDIA_TYPE_AV:
146 Common::SetVideoTrack(eventMsg->videoTrack, videoFormat_);
147 Common::SetAudioTrack(eventMsg->audioTrack, audioFormat_);
148 break;
149 case MEDIA_TYPE_VIDEO:
150 Common::SetVideoTrack(eventMsg->videoTrack, videoFormat_);
151 break;
152 case MEDIA_TYPE_AUDIO:
153 Common::SetAudioTrack(eventMsg->audioTrack, audioFormat_);
154 break;
155 default:
156 SHARING_LOGI("none process case.");
157 break;
158 }
159 SHARING_LOGI("afer SetVideoTrack, vtype:%{public}d, vFormat:%{public}d, vcodecId:%{public}d.", captureType_,
160 videoFormat_, eventMsg->videoTrack.codecId);
161 statusMsg->msg = std::move(eventMsg);
162 statusMsg->status = NOTIFY_SESSION_PRIVATE_EVENT;
163
164 NotifyAgentSessionStatus(statusMsg);
165 }
166
UpdateMediaStatus(SessionStatusMsg::Ptr & statusMsg)167 void ScreenCaptureSession::UpdateMediaStatus(SessionStatusMsg::Ptr &statusMsg)
168 {
169 SHARING_LOGD("trace.");
170 RETURN_IF_NULL(statusMsg);
171 RETURN_IF_NULL(statusMsg->msg);
172
173 SHARING_LOGI("update media notify status: %{public}s.",
174 std::string(magic_enum::enum_name(static_cast<MediaNotifyStatus>(statusMsg->status))).c_str());
175 switch (statusMsg->status) {
176 case STATE_PROSUMER_CREATE_SUCCESS:
177 NotifyProsumerInit(statusMsg);
178 break;
179 case STATE_PROSUMER_START_SUCCESS:
180 break;
181 case STATE_PROSUMER_STOP_SUCCESS:
182 break;
183 case STATE_PROSUMER_DESTROY_SUCCESS:
184 break;
185 default:
186 SHARING_LOGI("none process case.");
187 break;
188 }
189 }
190
NotifyAgentSessionStatus(SessionStatusMsg::Ptr & statusMsg)191 void ScreenCaptureSession::NotifyAgentSessionStatus(SessionStatusMsg::Ptr &statusMsg)
192 {
193 SHARING_LOGD("trace.");
194 RETURN_IF_NULL(statusMsg);
195
196 if (statusMsg->status == NOTIFY_PROSUMER_CREATE) {
197 statusMsg->className = "ScreenCaptureConsumer";
198 }
199
200 Notify(statusMsg);
201 }
202
203 REGISTER_CLASS_REFLECTOR(ScreenCaptureSession);
204 } // namespace Sharing
205 } // namespace OHOS
206