1 /*
2 * Copyright (c) 2024 Huawei Device 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 "cj_avsession_impl.h"
17
18 #include "want_agent.h"
19 #include "avsession_log.h"
20 #include "avsession_manager.h"
21 #include "avsession_errors.h"
22 #include "cj_avsession_utils.h"
23 #include "cj_avsession_manager_impl.h"
24 #include "cj_avsession_controller_impl.h"
25 #include "cj_avsession_cast_controller_impl.h"
26
27 namespace OHOS::AVSession {
28
CJAVSessionImpl(std::shared_ptr<AVSession> session)29 CJAVSessionImpl::CJAVSessionImpl(std::shared_ptr<AVSession> session)
30 {
31 session_ = session;
32 sessionId_ = session_->GetSessionId();
33 sessionType_ = session_->GetSessionType();
34 }
35
OnEvent(int32_t type,int64_t id)36 int32_t CJAVSessionImpl::OnEvent(int32_t type, int64_t id)
37 {
38 if (session_ == nullptr) {
39 SLOGE("OnEvent failed : session is nullptr");
40 return ERR_SESSION_NOT_EXIST;
41 }
42 int32_t ret = AVSESSION_SUCCESS;
43 if (callback_ == nullptr) {
44 callback_ = std::make_shared<CJAVSessionCallback>();
45 ret = session_->RegisterCallback(callback_);
46 if (ret != AVSESSION_SUCCESS) { //in avsession_errors.h
47 SLOGE("OnEvent failed : register callback failed");
48 return ret;
49 }
50 }
51 callback_->RegisterCallback(type, id);
52 return ret;
53 }
54
OffEvent(int32_t type)55 int32_t CJAVSessionImpl::OffEvent(int32_t type)
56 {
57 int32_t ret = AVSESSION_SUCCESS;
58 if (session_ == nullptr) {
59 SLOGE("OffEvent failed : session is nullptr");
60 return ERR_SESSION_NOT_EXIST;
61 }
62 if (callback_ == nullptr) {
63 return ret;
64 }
65 callback_->UnRegisterCallback(type);
66 return ret;
67 }
68
SetAVMetaData(CAVMetaData & data)69 int32_t CJAVSessionImpl::SetAVMetaData(CAVMetaData& data)
70 {
71 auto call = [&](AVMetaData& native) {
72 return session_->SetAVMetaData(native);
73 };
74 return CJAVSessionSetterCStruct<AVMetaData, CAVMetaData>(call, data, "SetAVMetaData");
75 }
76
SetAVCallMetaData(CAVCallMetaData & data)77 int32_t CJAVSessionImpl::SetAVCallMetaData(CAVCallMetaData& data)
78 {
79 auto call = [&](AVCallMetaData& native) {
80 return session_->SetAVCallMetaData(native);
81 };
82 return CJAVSessionSetterCStruct<AVCallMetaData, CAVCallMetaData>(call, data, "SetAVCallMetaData");
83 }
84
SetAVCallState(CAVCallState & state)85 int32_t CJAVSessionImpl::SetAVCallState(CAVCallState& state)
86 {
87 auto call = [&](AVCallState& native) {
88 return session_->SetAVCallState(native);
89 };
90 return CJAVSessionSetterCStruct<AVCallState, CAVCallState>(call, state, "SetAVCallState");
91 }
92
SetAVPlaybackState(CAVPlaybackState & state)93 int32_t CJAVSessionImpl::SetAVPlaybackState(CAVPlaybackState& state)
94 {
95 auto call = [&](AVPlaybackState& native) {
96 return session_->SetAVPlaybackState(native);
97 };
98 return CJAVSessionSetterCStruct<AVPlaybackState, CAVPlaybackState>(call, state, "SetAVPlaybackState");
99 }
100
SetAVQueueItems(CArray & items)101 int32_t CJAVSessionImpl::SetAVQueueItems(CArray& items)
102 {
103 auto call = [&](std::vector<AVQueueItem>& native) {
104 return session_->SetAVQueueItems(native);
105 };
106 return CJAVSessionSetterCStruct<std::vector<AVQueueItem>, CArray>(call, items, "SetAVQueueItems");
107 }
108
SetAVQueueTitle(char * & title)109 int32_t CJAVSessionImpl::SetAVQueueTitle(char*& title)
110 {
111 int32_t ret = session_->SetAVQueueTitle(std::string(title));
112 if (ret != CJNO_ERROR) {
113 SLOGE("controller SetAVQueueTitle failed:%{public}d", ret);
114 }
115 return ret;
116 }
117
SetExtras(CArray & extras)118 int32_t CJAVSessionImpl::SetExtras(CArray& extras)
119 {
120 auto call = [&](AAFwk::WantParams& native) {
121 return session_->SetExtras(native);
122 };
123 return CJAVSessionSetterCStruct<AAFwk::WantParams, CArray>(call, extras, "SetExtras");
124 }
125
SetLaunchAbility(int64_t abilityId)126 int32_t CJAVSessionImpl::SetLaunchAbility(int64_t abilityId)
127 {
128 auto call = [&](std::shared_ptr<AbilityRuntime::WantAgent::WantAgent>& native) {
129 return session_->SetLaunchAbility(*native);
130 };
131 return CJAVSessionSetterCStruct<std::shared_ptr<AbilityRuntime::WantAgent::WantAgent>, int64_t>(
132 call, abilityId, "SetLaunchAbility");
133 }
134
GetController()135 int32_t CJAVSessionImpl::GetController()
136 {
137 auto controller = CJAVSessionControllerImpl::GetInstance(sessionId_);
138 if (controller->Exists()) {
139 return CJNO_ERROR;
140 } else {
141 auto nativeController = session_->GetController();
142 if (nativeController == nullptr) {
143 return AVSESSION_ERROR;
144 }
145 auto ret = CJAVSessionControllerImpl::NewInstance(nativeController);
146 if (ret) {
147 return AVSESSION_SUCCESS;
148 }
149 return AVSESSION_ERROR;
150 }
151 }
152
GetAVCastController()153 int32_t CJAVSessionImpl::GetAVCastController()
154 {
155 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
156 std::shared_ptr<AVCastController> nativeController = session_->GetAVCastController();
157 if (nativeController == nullptr) {
158 SLOGE("GetAVCastController failed : native get controller failed");
159 return AVSESSION_ERROR;
160 }
161 auto controller = CJAVCastControllerImpl::NewInstance(nativeController, sessionId_);
162 if (controller) {
163 return CJNO_ERROR;
164 } else {
165 return ERR_NO_MEMORY;
166 }
167 #else
168 SLOGE("Cast Engine is disabled!");
169 return AVSESSION_ERROR;
170 #endif
171 }
172
GetOutputDevice(COutputDeviceInfo & outputDeviceInfo)173 int32_t CJAVSessionImpl::GetOutputDevice(COutputDeviceInfo& outputDeviceInfo)
174 {
175 AVSessionDescriptor descriptor;
176 int32_t ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(sessionId_, descriptor);
177 if (ret != CJNO_ERROR) {
178 SLOGE("controller GetOutputDevice failed:%{public}d", ret);
179 return ret;
180 }
181 return ConvertNativeToCJStruct(descriptor.outputDeviceInfo_, outputDeviceInfo);
182 }
183
GetAllCastDisplays(CArray & infos)184 int32_t CJAVSessionImpl::GetAllCastDisplays(CArray& infos)
185 {
186 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
187 auto call = [&](std::vector<CastDisplayInfo>& castDisplays) {
188 return session_->GetAllCastDisplays(castDisplays);
189 };
190 return CJControllerGetterCStruct<std::vector<CastDisplayInfo>, CArray>(call, infos, "GetAllCastDisplays");
191 #else
192 SLOGE("Cast Engine is disabled!");
193 return AVSESSION_ERROR;
194 #endif
195 }
196
Activate()197 int32_t CJAVSessionImpl::Activate()
198 {
199 auto call = [&]() {
200 return session_->Activate();
201 };
202 return CJExecMethod(call, "Activate");
203 }
204
Deactivate()205 int32_t CJAVSessionImpl::Deactivate()
206 {
207 auto call = [&]() {
208 return session_->Deactivate();
209 };
210 return CJExecMethod(call, "Deactivate");
211 }
212
Destroy()213 int32_t CJAVSessionImpl::Destroy()
214 {
215 auto call = [&]() {
216 return session_->Destroy();
217 };
218 return CJExecMethod(call, "Destroy");
219 }
220
StopCasting()221 int32_t CJAVSessionImpl::StopCasting()
222 {
223 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
224 auto call = [&]() {
225 return session_->ReleaseCast();
226 };
227 return CJExecMethod(call, "StopCasting");
228 #else
229 return CJNO_ERROR;
230 #endif
231 }
232
DispatchSessionEvent(char * & event,CArray & args)233 int32_t CJAVSessionImpl::DispatchSessionEvent(char*& event, CArray& args)
234 {
235 AAFwk::WantParams paras;
236 int ret = convertCJStructToNative(args, paras);
237 if (ret != CJNO_ERROR) {
238 SLOGE("Convert CParameters to WantParams Failed!");
239 return ret;
240 }
241 return session_->SetSessionEvent(std::string(event), paras);
242 }
243 } // namespace AVSession::OHOS