1 /*
2 * Copyright (c) 2022-2025 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 <cstdio>
17
18 #include "napi_avsession.h"
19 #include "avsession_controller.h"
20 #include "napi_utils.h"
21 #include "napi_avcall_meta_data.h"
22 #include "napi_avcall_state.h"
23 #include "napi_meta_data.h"
24 #include "napi_playback_state.h"
25 #include "napi_media_description.h"
26 #include "napi_queue_item.h"
27 #include "want_params.h"
28 #include "want_agent.h"
29 #include "avsession_trace.h"
30 #include "napi_avsession_controller.h"
31 #include "napi_avsession_manager.h"
32 #include "curl/curl.h"
33 #include "image_source.h"
34 #include "pixel_map.h"
35 #include "avsession_pixel_map_adapter.h"
36
37 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
38 #include "avcast_controller.h"
39 #include "napi_avcast_controller.h"
40 #endif
41 namespace OHOS::AVSession {
42
43 static __thread napi_ref AVSessionConstructorRef = nullptr;
44 std::map<std::string, NapiAVSession::OnEventHandlerType> NapiAVSession::onEventHandlers_ = {
45 { "play", OnPlay },
46 { "pause", OnPause },
47 { "stop", OnStop },
48 { "playNext", OnPlayNext },
49 { "playPrevious", OnPlayPrevious },
50 { "fastForward", OnFastForward },
51 { "rewind", OnRewind },
52 { "seek", OnSeek },
53 { "setSpeed", OnSetSpeed },
54 { "setLoopMode", OnSetLoopMode },
55 { "setTargetLoopMode", OnSetTargetLoopMode },
56 { "toggleFavorite", OnToggleFavorite },
57 { "handleKeyEvent", OnMediaKeyEvent },
58 { "outputDeviceChange", OnOutputDeviceChange },
59 { "commonCommand", OnCommonCommand },
60 { "skipToQueueItem", OnSkipToQueueItem },
61 { "answer", OnAVCallAnswer },
62 { "hangUp", OnAVCallHangUp },
63 { "toggleCallMute", OnAVCallToggleCallMute },
64 { "playFromAssetId", OnPlayFromAssetId },
65 { "playWithAssetId", OnPlayWithAssetId },
66 { "castDisplayChange", OnCastDisplayChange },
67 { "castDisplaySizeChange", OnCastDisplaySizeChange },
68 { "customDataChange", OnCustomData },
69 };
70 std::map<std::string, NapiAVSession::OffEventHandlerType> NapiAVSession::offEventHandlers_ = {
71 { "play", OffPlay },
72 { "pause", OffPause },
73 { "stop", OffStop },
74 { "playNext", OffPlayNext },
75 { "playPrevious", OffPlayPrevious },
76 { "fastForward", OffFastForward },
77 { "rewind", OffRewind },
78 { "seek", OffSeek },
79 { "setSpeed", OffSetSpeed },
80 { "setLoopMode", OffSetLoopMode },
81 { "setTargetLoopMode", OffSetTargetLoopMode },
82 { "toggleFavorite", OffToggleFavorite },
83 { "handleKeyEvent", OffMediaKeyEvent },
84 { "outputDeviceChange", OffOutputDeviceChange },
85 { "commonCommand", OffCommonCommand },
86 { "skipToQueueItem", OffSkipToQueueItem },
87 { "answer", OffAVCallAnswer },
88 { "hangUp", OffAVCallHangUp },
89 { "toggleCallMute", OffAVCallToggleCallMute },
90 { "playFromAssetId", OffPlayFromAssetId },
91 { "playWithAssetId", OffPlayWithAssetId },
92 { "castDisplayChange", OffCastDisplayChange },
93 { "customDataChange", OffCustomData },
94 };
95 std::list<int32_t> registerEventList_;
96 std::map<std::string, int32_t> convertEventType_ = {
97 { "play", AVControlCommand::SESSION_CMD_PLAY },
98 { "pause", AVControlCommand::SESSION_CMD_PAUSE },
99 { "stop", AVControlCommand::SESSION_CMD_STOP },
100 { "playNext", AVControlCommand::SESSION_CMD_PLAY_NEXT },
101 { "playPrevious", AVControlCommand::SESSION_CMD_PLAY_PREVIOUS },
102 { "fastForward", AVControlCommand::SESSION_CMD_FAST_FORWARD },
103 { "rewind", AVControlCommand::SESSION_CMD_REWIND },
104 { "seek", AVControlCommand::SESSION_CMD_SEEK },
105 { "setSpeed", AVControlCommand::SESSION_CMD_SET_SPEED },
106 { "setLoopMode", AVControlCommand::SESSION_CMD_SET_LOOP_MODE },
107 { "toggleFavorite", AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE },
108 { "handleKeyEvent", AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT },
109 { "playFromAssetId", AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID },
110 { "playWithAssetId", AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID }
111 };
112
113 std::mutex NapiAVSession::lock_;
114 std::mutex NapiAVSession::syncMutex_;
115 std::mutex NapiAVSession::syncAsyncMutex_;
116 std::condition_variable NapiAVSession::syncCond_;
117 std::condition_variable NapiAVSession::syncAsyncCond_;
118 std::recursive_mutex registerEventLock_;
119 int32_t NapiAVSession::playBackStateRet_ = AVSESSION_ERROR;
120 std::shared_ptr<NapiAVSession> NapiAVSession::napiAVSession_ = nullptr;
121 std::recursive_mutex NapiAVSession::destroyLock_;
122 bool NapiAVSession::isNapiSessionDestroy_ = false;
123
NapiAVSession()124 NapiAVSession::NapiAVSession()
125 {
126 SLOGI("construct");
127 }
128
~NapiAVSession()129 NapiAVSession::~NapiAVSession()
130 {
131 SLOGI("destroy");
132 AVSessionManager::GetInstance().UnregisterServiceStartCallback();
133 std::lock_guard lockGuard(registerEventLock_);
134 registerEventList_.clear();
135 }
136
Init(napi_env env,napi_value exports)137 napi_value NapiAVSession::Init(napi_env env, napi_value exports)
138 {
139 napi_property_descriptor descriptors[] = {
140 DECLARE_NAPI_FUNCTION("setAVMetadata", SetAVMetaData),
141 DECLARE_NAPI_FUNCTION("setCallMetadata", SetAVCallMetaData),
142 DECLARE_NAPI_FUNCTION("setAVPlaybackState", SetAVPlaybackState),
143 DECLARE_NAPI_FUNCTION("setAVCallState", SetAVCallState),
144 DECLARE_NAPI_FUNCTION("setLaunchAbility", SetLaunchAbility),
145 DECLARE_NAPI_FUNCTION("setExtras", SetExtras),
146 DECLARE_NAPI_FUNCTION("setAudioStreamId", SetAudioStreamId),
147 DECLARE_NAPI_FUNCTION("getController", GetController),
148 DECLARE_NAPI_FUNCTION("activate", Activate),
149 DECLARE_NAPI_FUNCTION("deactivate", Deactivate),
150 DECLARE_NAPI_FUNCTION("destroy", Destroy),
151 DECLARE_NAPI_FUNCTION("on", OnEvent),
152 DECLARE_NAPI_FUNCTION("off", OffEvent),
153 DECLARE_NAPI_FUNCTION("getOutputDevice", GetOutputDevice),
154 DECLARE_NAPI_FUNCTION("getOutputDeviceSync", GetOutputDeviceSync),
155 DECLARE_NAPI_FUNCTION("dispatchSessionEvent", SetSessionEvent),
156 DECLARE_NAPI_FUNCTION("setAVQueueItems", SetAVQueueItems),
157 DECLARE_NAPI_FUNCTION("setAVQueueTitle", SetAVQueueTitle),
158 DECLARE_NAPI_FUNCTION("sendCustomData", SendCustomData),
159 DECLARE_NAPI_FUNCTION("getAVCastController", GetAVCastController),
160 DECLARE_NAPI_FUNCTION("stopCasting", ReleaseCast),
161 DECLARE_NAPI_FUNCTION("getAllCastDisplays", GetAllCastDisplays),
162 };
163 auto propertyCount = sizeof(descriptors) / sizeof(napi_property_descriptor);
164 napi_value constructor {};
165 auto status = napi_define_class(env, "AVSession", NAPI_AUTO_LENGTH, ConstructorCallback, nullptr,
166 propertyCount, descriptors, &constructor);
167 if (status != napi_ok) {
168 SLOGE("define class failed");
169 return NapiUtils::GetUndefinedValue(env);
170 }
171 napi_create_reference(env, constructor, 1, &AVSessionConstructorRef);
172 return exports;
173 }
174
ConstructorCallback(napi_env env,napi_callback_info info)175 napi_value NapiAVSession::ConstructorCallback(napi_env env, napi_callback_info info)
176 {
177 napi_value self;
178 NAPI_CALL_BASE(env, napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr), nullptr);
179 auto finalize = [](napi_env env, void* data, void* hint) {
180 auto* napiSession = reinterpret_cast<NapiAVSession*>(data);
181 napi_delete_reference(env, napiSession->wrapperRef_);
182 delete napiSession;
183 napiSession = nullptr;
184 };
185 auto* napiSession = new(std::nothrow) NapiAVSession();
186 if (napiSession == nullptr) {
187 SLOGE("no memory");
188 return nullptr;
189 }
190 if (napi_wrap(env, self, static_cast<void*>(napiSession), finalize, nullptr, nullptr) != napi_ok) {
191 SLOGE("wrap failed");
192 delete napiSession;
193 napiSession = nullptr;
194 return nullptr;
195 }
196 return self;
197 }
198
ReCreateInstance()199 napi_status NapiAVSession::ReCreateInstance()
200 {
201 if (napiAVSession_ == nullptr) {
202 SLOGE("napiAVSession is null");
203 return napi_generic_failure;
204 }
205 {
206 std::lock_guard lockGuard(destroyLock_);
207 if (isNapiSessionDestroy_) {
208 SLOGE("isNapiSessionDestroy_=%{public}d", isNapiSessionDestroy_);
209 return napi_generic_failure;
210 }
211 }
212 SLOGI("sessionId=%{public}s***", napiAVSession_->sessionId_.substr(0, UNMASK_CHAR_NUM).c_str());
213 std::shared_ptr<AVSession> nativeSession;
214 int32_t ret = AVSessionManager::GetInstance().CreateSession(napiAVSession_->sessionTag_,
215 NapiUtils::ConvertSessionType(napiAVSession_->sessionType_), napiAVSession_->elementName_, nativeSession);
216 CHECK_RETURN(ret == AVSESSION_SUCCESS, "create native session fail", napi_generic_failure);
217 napiAVSession_->session_ = std::move(nativeSession);
218 napiAVSession_->sessionId_ = napiAVSession_->session_->GetSessionId();
219 napiAVSession_->sessionType_ = napiAVSession_->session_->GetSessionType();
220 if (napiAVSession_->callback_ == nullptr) {
221 napiAVSession_->callback_ = std::make_shared<NapiAVSessionCallback>();
222 }
223 int32_t res = napiAVSession_->session_->RegisterCallback(napiAVSession_->callback_);
224 CHECK_RETURN(res == AVSESSION_SUCCESS, "register session callback fail", napi_generic_failure);
225 {
226 std::lock_guard lockGuard(registerEventLock_);
227 for (int32_t event : registerEventList_) {
228 int32_t result = napiAVSession_->session_->AddSupportCommand(event);
229 if (result != AVSESSION_SUCCESS) {
230 SLOGE("AddSupportCommand fail, ret=%{public}d", res);
231 continue;
232 }
233 }
234 }
235 napiAVSession_->session_->Activate();
236 return napi_ok;
237 }
238
NewInstance(napi_env env,std::shared_ptr<AVSession> & nativeSession,napi_value & out,std::string tag,AppExecFwk::ElementName elementName)239 napi_status NapiAVSession::NewInstance(napi_env env, std::shared_ptr<AVSession>& nativeSession, napi_value& out,
240 std::string tag, AppExecFwk::ElementName elementName)
241 {
242 napi_value constructor {};
243 NAPI_CALL_BASE(env, napi_get_reference_value(env, AVSessionConstructorRef, &constructor), napi_generic_failure);
244 napi_value instance{};
245 NAPI_CALL_BASE(env, napi_new_instance(env, constructor, 0, nullptr, &instance), napi_generic_failure);
246 napiAVSession_ = std::make_shared<NapiAVSession>();
247 NAPI_CALL_BASE(env, napi_unwrap(env, instance, reinterpret_cast<void**>(&napiAVSession_)), napi_generic_failure);
248 napiAVSession_->session_ = std::move(nativeSession);
249 napiAVSession_->sessionId_ = napiAVSession_->session_->GetSessionId();
250 napiAVSession_->sessionType_ = napiAVSession_->session_->GetSessionType();
251 napiAVSession_->sessionTag_ = tag;
252 napiAVSession_->elementName_ = elementName;
253 SLOGI("sessionId=%{public}s***, sessionType:%{public}s",
254 napiAVSession_->sessionId_.substr(0, UNMASK_CHAR_NUM).c_str(),
255 napiAVSession_->sessionType_.c_str());
256
257 napi_value property {};
258 auto status = NapiUtils::SetValue(env, napiAVSession_->sessionId_, property);
259 CHECK_RETURN(status == napi_ok, "create object failed", napi_generic_failure);
260 NAPI_CALL_BASE(env, napi_set_named_property(env, instance, "sessionId", property), napi_generic_failure);
261
262 status = NapiUtils::SetValue(env, napiAVSession_->sessionType_, property);
263 CHECK_RETURN(status == napi_ok, "create object failed", napi_generic_failure);
264 NAPI_CALL_BASE(env, napi_set_named_property(env, instance, "sessionType", property), napi_generic_failure);
265 out = instance;
266 return napi_ok;
267 }
268
AddRegisterEvent(std::string eventName)269 void AddRegisterEvent(std::string eventName)
270 {
271 std::lock_guard lockGuard(registerEventLock_);
272 if (convertEventType_.find(eventName) == convertEventType_.end()) {
273 SLOGE("eventName is invalid: eventName = %{public}s", eventName.c_str());
274 return;
275 }
276 registerEventList_.push_back(convertEventType_[eventName]);
277 }
278
RemoveRegisterEvent(std::string eventName)279 void RemoveRegisterEvent(std::string eventName)
280 {
281 std::lock_guard lockGuard(registerEventLock_);
282 if (convertEventType_.find(eventName) == convertEventType_.end()) {
283 SLOGE("eventName is invalid: eventName = %{public}s", eventName.c_str());
284 return;
285 }
286 registerEventList_.remove(convertEventType_[eventName]);
287 }
288
OnEvent(napi_env env,napi_callback_info info)289 napi_value NapiAVSession::OnEvent(napi_env env, napi_callback_info info)
290 {
291 auto context = std::make_shared<ContextBase>();
292 if (context == nullptr) {
293 SLOGE("OnEvent failed : no memory");
294 return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
295 }
296 std::string eventName;
297 napi_value callback {};
298 auto input = [&eventName, &callback, env, &context](size_t argc, napi_value* argv) {
299 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_TWO, "invalid argument number",
300 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
301 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], eventName);
302 CHECK_STATUS_RETURN_VOID(context, "get event name failed", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
303 napi_valuetype type = napi_undefined;
304 context->status = napi_typeof(env, argv[ARGV_SECOND], &type);
305 CHECK_ARGS_RETURN_VOID(context, (context->status == napi_ok) && (type == napi_function),
306 "callback type invalid", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
307 callback = argv[ARGV_SECOND];
308 };
309 context->GetCbInfo(env, info, input, true);
310 if (context->status != napi_ok) {
311 NapiUtils::ThrowError(env, context->errMessage.c_str(), context->errCode);
312 return NapiUtils::GetUndefinedValue(env);
313 }
314 auto it = onEventHandlers_.find(eventName);
315 if (it == onEventHandlers_.end()) {
316 SLOGE("event name invalid");
317 return ThrowErrorAndReturn(env, "event name invalid", ERR_INVALID_PARAM);
318 }
319 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
320 if (napiSession->session_ == nullptr) {
321 SLOGE("OnEvent failed : session is nullptr");
322 return ThrowErrorAndReturn(env, "OnEvent failed : session is nullptr", ERR_SESSION_NOT_EXIST);
323 }
324 if (napiSession->callback_ == nullptr) {
325 napiSession->callback_ = std::make_shared<NapiAVSessionCallback>();
326 if (napiSession->callback_ == nullptr) {
327 return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
328 }
329 int32_t ret = napiSession->session_->RegisterCallback(napiSession->callback_);
330 if (ret != AVSESSION_SUCCESS) {
331 return ThrowErrorAndReturnByErrCode(env, "OnEvent", ret);
332 }
333 }
334 if (it->second(env, napiSession, callback) != napi_ok) {
335 NapiUtils::ThrowError(env, "add event callback failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
336 }
337 AddRegisterEvent(eventName);
338 return NapiUtils::GetUndefinedValue(env);
339 }
340
ThrowErrorAndReturn(napi_env env,const std::string & message,int32_t errCode)341 napi_value NapiAVSession::ThrowErrorAndReturn(napi_env env, const std::string& message, int32_t errCode)
342 {
343 std::string tempMessage = message;
344 NapiUtils::ThrowError(env, tempMessage.c_str(), NapiAVSessionManager::errcode_[errCode]);
345 return NapiUtils::GetUndefinedValue(env);
346 }
347
ThrowErrorAndReturnByErrCode(napi_env env,const std::string & message,int32_t errCode)348 napi_value NapiAVSession::ThrowErrorAndReturnByErrCode(napi_env env, const std::string& message, int32_t errCode)
349 {
350 std::string tempMessage = message;
351 if (errCode == ERR_SESSION_NOT_EXIST) {
352 tempMessage.append(" failed : native session not exist");
353 } else if (errCode == ERR_INVALID_PARAM) {
354 tempMessage.append(" failed : native invalid parameters");
355 } else if (errCode == ERR_NO_PERMISSION) {
356 tempMessage.append(" failed : native no permission");
357 } else {
358 tempMessage.append(" failed : native server exception");
359 }
360 SLOGI("throw error message: %{public}s", tempMessage.c_str());
361 NapiUtils::ThrowError(env, tempMessage.c_str(), NapiAVSessionManager::errcode_[errCode]);
362 return NapiUtils::GetUndefinedValue(env);
363 }
364
OffEvent(napi_env env,napi_callback_info info)365 napi_value NapiAVSession::OffEvent(napi_env env, napi_callback_info info)
366 {
367 auto context = std::make_shared<ContextBase>();
368 if (context == nullptr) {
369 SLOGE("OffEvent failed : no memory");
370 NapiUtils::ThrowError(env, "OffEvent failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
371 return NapiUtils::GetUndefinedValue(env);
372 }
373 std::string eventName;
374 napi_value callback = nullptr;
375 auto input = [&eventName, env, &context, &callback](size_t argc, napi_value* argv) {
376 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE || argc == ARGC_TWO,
377 "invalid argument number", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
378 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], eventName);
379 CHECK_STATUS_RETURN_VOID(context, "get event name failed", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
380 if (argc == ARGC_TWO) {
381 callback = argv[ARGV_SECOND];
382 }
383 };
384 context->GetCbInfo(env, info, input, true);
385 if (context->status != napi_ok) {
386 NapiUtils::ThrowError(env, context->errMessage.c_str(), context->errCode);
387 return NapiUtils::GetUndefinedValue(env);
388 }
389 auto it = offEventHandlers_.find(eventName);
390 if (it == offEventHandlers_.end()) {
391 SLOGE("event name invalid");
392 NapiUtils::ThrowError(env, "event name invalid", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
393 return NapiUtils::GetUndefinedValue(env);
394 }
395 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
396 if (napiSession == nullptr) {
397 SLOGE("OffEvent failed : napiSession is nullptr");
398 NapiUtils::ThrowError(env, "OffEvent failed : napiSession is nullptr",
399 NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
400 return NapiUtils::GetUndefinedValue(env);
401 }
402 if (napiSession->session_ == nullptr) {
403 SLOGE("OffEvent failed : session is nullptr");
404 NapiUtils::ThrowError(env, "OffEvent failed : session is nullptr",
405 NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
406 return NapiUtils::GetUndefinedValue(env);
407 }
408 if (napiSession != nullptr && it->second(env, napiSession, callback) != napi_ok) {
409 NapiUtils::ThrowError(env, "remove event callback failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
410 }
411 RemoveRegisterEvent(eventName);
412 return NapiUtils::GetUndefinedValue(env);
413 }
414
SetAVCallMetaData(napi_env env,napi_callback_info info)415 napi_value NapiAVSession::SetAVCallMetaData(napi_env env, napi_callback_info info)
416 {
417 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVCallMetadata");
418 struct ConcreteContext : public ContextBase {
419 AVCallMetaData avCallMetaData;
420 };
421 auto context = std::make_shared<ConcreteContext>();
422 if (context == nullptr) {
423 SLOGE("SetAVCallMetaData failed : no memory");
424 NapiUtils::ThrowError(env, "SetAVCallMetaData failed : no memory",
425 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
426 return NapiUtils::GetUndefinedValue(env);
427 }
428
429 auto inputParser = [env, context](size_t argc, napi_value* argv) {
430 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
431 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
432 context->status = NapiAVCallMetaData::GetValue(env, argv[ARGV_FIRST], context->avCallMetaData);
433 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get av call meta data failed",
434 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
435 };
436 context->GetCbInfo(env, info, inputParser);
437 context->taskId = NAPI_SET_AVCALL_META_DATA_TASK_ID;
438
439 auto executor = [context]() {
440 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
441 if (napiSession->session_ == nullptr) {
442 context->status = napi_generic_failure;
443 context->errMessage = "SetAVCallMetaData failed : session is nullptr";
444 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
445 return;
446 }
447 int32_t ret = napiSession->session_->SetAVCallMetaData(context->avCallMetaData);
448 if (ret != AVSESSION_SUCCESS) {
449 if (ret == ERR_SESSION_NOT_EXIST) {
450 context->errMessage = "SetAVCallMetaData failed : native session not exist";
451 } else if (ret == ERR_INVALID_PARAM) {
452 context->errMessage = "SetAVCallMetaData failed : native invalid parameters";
453 } else if (ret == ERR_NO_PERMISSION) {
454 context->errMessage = "SetAVCallMetaData failed : native no permission";
455 } else {
456 context->errMessage = "SetAVCallMetaData failed : native server exception";
457 }
458 context->status = napi_generic_failure;
459 context->errCode = NapiAVSessionManager::errcode_[ret];
460 }
461 };
462 auto complete = [env](napi_value& output) {
463 output = NapiUtils::GetUndefinedValue(env);
464 };
465 return NapiAsyncWork::Enqueue(env, context, "SetAVCallMetaData", executor, complete);
466 }
467
SetAVCallState(napi_env env,napi_callback_info info)468 napi_value NapiAVSession::SetAVCallState(napi_env env, napi_callback_info info)
469 {
470 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVCallState");
471 struct ConcreteContext : public ContextBase {
472 AVCallState avCallState;
473 };
474 auto context = std::make_shared<ConcreteContext>();
475 if (context == nullptr) {
476 SLOGE("SetAVCallState failed : no memory");
477 NapiUtils::ThrowError(env, "SetAVCallState failed : no memory",
478 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
479 return NapiUtils::GetUndefinedValue(env);
480 }
481
482 auto inputParser = [env, context](size_t argc, napi_value* argv) {
483 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
484 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
485 context->status = NapiAVCallState::GetValue(env, argv[ARGV_FIRST], context->avCallState);
486 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get avCallState failed",
487 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
488 };
489 context->GetCbInfo(env, info, inputParser);
490 context->taskId = NAPI_SET_AV_CALL_STATE_TASK_ID;
491
492 auto executor = [context]() {
493 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
494 if (napiSession->session_ == nullptr) {
495 context->status = napi_generic_failure;
496 context->errMessage = "SetAVCallState failed : session is nullptr";
497 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
498 return;
499 }
500 int32_t ret = napiSession->session_->SetAVCallState(context->avCallState);
501 if (ret != AVSESSION_SUCCESS) {
502 if (ret == ERR_SESSION_NOT_EXIST) {
503 context->errMessage = "SetAVCallState failed : native session not exist";
504 } else if (ret == ERR_INVALID_PARAM) {
505 context->errMessage = "SetAVCallState failed : native invalid parameters";
506 } else if (ret == ERR_NO_PERMISSION) {
507 context->errMessage = "SetAVCallState failed : native no permission";
508 } else {
509 context->errMessage = "SetAVCallState failed : native server exception";
510 }
511 context->status = napi_generic_failure;
512 context->errCode = NapiAVSessionManager::errcode_[ret];
513 }
514 };
515 auto complete = [env](napi_value& output) {
516 output = NapiUtils::GetUndefinedValue(env);
517 };
518 return NapiAsyncWork::Enqueue(env, context, "SetAVCallState", executor, complete);
519 }
520
DoDownload(AVMetaData & meta,const std::string uri)521 int32_t DoDownload(AVMetaData& meta, const std::string uri)
522 {
523 SLOGI("DoDownload with title %{public}s", meta.GetTitle().c_str());
524
525 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
526 bool ret = NapiUtils::DoDownloadInCommon(pixelMap, uri);
527 SLOGI("DoDownload with ret %{public}d, %{public}d", static_cast<int>(ret), static_cast<int>(pixelMap == nullptr));
528 if (ret && pixelMap != nullptr) {
529 SLOGI("DoDownload success and ResetToBaseMeta");
530 meta.ResetToBaseMeta();
531 meta.SetMediaImage(AVSessionPixelMapAdapter::ConvertToInner(pixelMap));
532 return AVSESSION_SUCCESS;
533 }
534 return AVSESSION_ERROR;
535 }
536
processErrMsg(std::shared_ptr<ContextBase> context,int32_t ret)537 void processErrMsg(std::shared_ptr<ContextBase> context, int32_t ret)
538 {
539 if (ret == ERR_SESSION_NOT_EXIST) {
540 context->errMessage = "SetAVMetaData failed : native session not exist";
541 } else if (ret == ERR_INVALID_PARAM) {
542 context->errMessage = "SetAVMetaData failed : native invalid parameters";
543 } else if (ret == ERR_NO_PERMISSION) {
544 context->errMessage = "SetAVMetaData failed : native no permission";
545 } else {
546 context->errMessage = "SetAVMetaData failed : native server exception";
547 }
548 context->status = napi_generic_failure;
549 context->errCode = NapiAVSessionManager::errcode_[ret];
550 }
551
doMetaDataSetNapi(std::shared_ptr<ContextBase> context,std::shared_ptr<AVSession> sessionPtr,AVMetaData & data,bool isRepeatDownload)552 bool doMetaDataSetNapi(std::shared_ptr<ContextBase> context, std::shared_ptr<AVSession> sessionPtr, AVMetaData& data,
553 bool isRepeatDownload)
554 {
555 SLOGI("do metadata set with check uri alive:%{public}d, pixel alive:%{public}d, session alive:%{public}d",
556 static_cast<int>(!data.GetMediaImageUri().empty()),
557 static_cast<int>(data.GetMediaImage() != nullptr),
558 static_cast<int>(sessionPtr != nullptr));
559 if (sessionPtr == nullptr) {
560 context->status = napi_generic_failure;
561 context->errMessage = "SetAVMetaData failed : session is nullptr";
562 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
563 return false;
564 }
565 auto uri = data.GetMediaImageUri();
566 int32_t ret = sessionPtr->SetAVMetaData(data);
567 if (ret != AVSESSION_SUCCESS) {
568 SLOGE("do metadata set fail, ret:%{public}d", ret);
569 processErrMsg(context, ret);
570 } else if (data.GetMediaImageUri().empty()) {
571 SLOGE("do metadata set with img uri empty");
572 } else if (isRepeatDownload) {
573 SLOGI("do metadata set with repeat uriSize:%{public}d.", static_cast<int>(uri.size()));
574 } else if (data.GetMediaImage() == nullptr) {
575 ret = DoDownload(data, uri);
576 SLOGI("DoDownload uriSize:%{public}d complete with ret %{public}d", static_cast<int>(uri.size()), ret);
577 CHECK_AND_RETURN_RET_LOG(sessionPtr != nullptr, false, "doMetaDataSet without session");
578 if (ret != AVSESSION_SUCCESS) {
579 SLOGE("DoDownload failed but not repeat setmetadata again");
580 } else {
581 return true;
582 }
583 }
584 return false;
585 }
586
DoLastMetaDataRefresh(NapiAVSession * napiAVSession)587 void NapiAVSession::DoLastMetaDataRefresh(NapiAVSession* napiAVSession)
588 {
589 CHECK_AND_RETURN_LOG(napiAVSession != nullptr, "context nullptr!");
590 napiAVSession->latestDownloadedAssetId_ = (napiAVSession->metaData_.GetAssetId() !=
591 napiAVSession->latestMetadataAssetId_) ? "" : napiAVSession->latestDownloadedAssetId_;
592 napiAVSession->latestDownloadedUri_ = (napiAVSession->metaData_.GetMediaImage() != nullptr) ?
593 "" : napiAVSession->latestDownloadedUri_;
594 napiAVSession->latestMetadataUri_ = napiAVSession->metaData_.GetMediaImageUri();
595 napiAVSession->latestMetadataAssetId_ = napiAVSession->metaData_.GetAssetId();
596 }
597
CheckMetaOutOfDate(NapiAVSession * napiAVSession,OHOS::AVSession::AVMetaData & curMeta)598 bool NapiAVSession::CheckMetaOutOfDate(NapiAVSession* napiAVSession, OHOS::AVSession::AVMetaData& curMeta)
599 {
600 CHECK_AND_RETURN_RET_LOG(napiAVSession != nullptr, true, "context nullptr!");
601 return (curMeta.GetAssetId() != napiAVSession->latestMetadataAssetId_) ||
602 (!napiAVSession->latestMetadataUri_.empty() &&
603 curMeta.GetMediaImageUri() != napiAVSession->latestMetadataUri_) ||
604 (napiAVSession->latestDownloadedAssetId_ == napiAVSession->latestMetadataAssetId_ &&
605 napiAVSession->latestDownloadedUri_ == napiAVSession->latestMetadataUri_);
606 }
607
SetAVMetaData(napi_env env,napi_callback_info info)608 napi_value NapiAVSession::SetAVMetaData(napi_env env, napi_callback_info info)
609 {
610 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVMetadata");
611 struct ConcreteContext : public ContextBase {
612 AVMetaData metaData;
613 };
614 auto context = std::make_shared<ConcreteContext>();
615 CHECK_AND_RETURN_RET_LOG(context != nullptr, NapiUtils::GetUndefinedValue(env), "SetAVMetaData failed: no memory");
616 auto inputParser = [env, context](size_t argc, napi_value* argv) {
617 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
618 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
619 context->status = NapiMetaData::GetValue(env, argv[ARGV_FIRST], context->metaData);
620 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get metaData failed",
621 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
622 };
623 context->GetCbInfo(env, info, inputParser);
624 auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
625 auto* napiAvSession = reinterpret_cast<NapiAVSession*>(context->native);
626 if (napiAvSession == nullptr || napiAvSession->metaData_.EqualWithUri((context->metaData))) {
627 SLOGI("Session nullptr or metadata all same");
628 auto executor = []() {};
629 return NapiAsyncWork::Enqueue(env, context, "SetAVMetaData", executor, complete);
630 }
631 napiAvSession->metaData_ = context->metaData;
632 context->taskId = NAPI_SET_AV_META_DATA_TASK_ID;
633 DoLastMetaDataRefresh(napiAvSession);
634
635 auto syncExecutor = AVQueueImgDownloadSyncExecutor(reinterpret_cast<NapiAVSession*>(context->native),
636 context->metaData);
637 CHECK_AND_PRINT_LOG(AVSessionEventHandler::GetInstance()
638 .AVSessionPostTask(syncExecutor, "AVQueueImgDownload"),
639 "NapiAVSession AVQueueImgDownload handler postTask failed");
640 auto executor = [context]() {
641 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
642 bool isRepeatDownload = napiSession->latestDownloadedAssetId_ == napiSession->latestMetadataAssetId_ &&
643 napiSession->latestDownloadedUri_ == napiSession->latestMetadataUri_;
644 bool res = doMetaDataSetNapi(context, napiSession->session_, context->metaData, isRepeatDownload);
645 {
646 std::lock_guard<std::mutex> lockGuard(lock_);
647 bool isOutOfDate = CheckMetaOutOfDate(napiSession, context->metaData);
648 SLOGI("doMetaDataSet res:%{public}d|%{public}d", static_cast<int>(res), !isOutOfDate);
649 if (res && !isOutOfDate && napiSession->session_ != nullptr) {
650 napiSession->latestDownloadedUri_ = context->metaData.GetMediaImageUri();
651 napiSession->latestDownloadedAssetId_ = context->metaData.GetAssetId();
652 napiSession->session_->SetAVMetaData(context->metaData);
653 }
654 }
655 context->metaData.Reset();
656 };
657 return NapiAsyncWork::Enqueue(env, context, "SetAVMetaData", executor, complete);
658 }
659
PlaybackStateSyncExecutor(std::shared_ptr<AVSession> session,AVPlaybackState playBackState)660 std::function<void()> NapiAVSession::PlaybackStateSyncExecutor(std::shared_ptr<AVSession> session,
661 AVPlaybackState playBackState)
662 {
663 return [session, playBackState]() {
664 if (session == nullptr) {
665 playBackStateRet_ = ERR_SESSION_NOT_EXIST;
666 return;
667 }
668 playBackStateRet_ = session->SetAVPlaybackState(playBackState);
669 syncCond_.notify_one();
670 std::unique_lock<std::mutex> lock(syncAsyncMutex_);
671 auto waitStatus = syncAsyncCond_.wait_for(lock, std::chrono::milliseconds(100));
672 if (waitStatus == std::cv_status::timeout) {
673 SLOGE("SetAVPlaybackState:%{public}d in syncExecutor timeout after err:%{public}d",
674 playBackState.GetState(), playBackStateRet_);
675 return;
676 }
677 };
678 }
679
PlaybackStateAsyncExecutor(std::shared_ptr<ContextBase> context)680 std::function<void()> NapiAVSession::PlaybackStateAsyncExecutor(std::shared_ptr<ContextBase> context)
681 {
682 return [context]() {
683 std::unique_lock<std::mutex> lock(syncMutex_);
684 auto waitStatus = syncCond_.wait_for(lock, std::chrono::milliseconds(100));
685
686 if (playBackStateRet_ != AVSESSION_SUCCESS) {
687 if (playBackStateRet_ == ERR_SESSION_NOT_EXIST) {
688 context->errMessage = "SetAVPlaybackState failed : native session not exist";
689 } else if (playBackStateRet_ == ERR_INVALID_PARAM) {
690 context->errMessage = "SetAVPlaybackState failed : native invalid parameters";
691 } else if (playBackStateRet_ == ERR_NO_PERMISSION) {
692 context->errMessage = "SetAVPlaybackState failed : native no permission";
693 } else {
694 context->errMessage = "SetAVPlaybackState failed : native server exception";
695 }
696 context->status = napi_generic_failure;
697 context->errCode = NapiAVSessionManager::errcode_[playBackStateRet_];
698 }
699 if (waitStatus == std::cv_status::timeout) {
700 SLOGE("SetAVPlaybackState in asyncExecutor timeout after err:%{public}d", playBackStateRet_);
701 return;
702 }
703 syncAsyncCond_.notify_one();
704 };
705 }
706
AVQueueImgDownloadSyncExecutor(NapiAVSession * napiSession,OHOS::AVSession::AVMetaData metaData)707 std::function<void()> NapiAVSession::AVQueueImgDownloadSyncExecutor(NapiAVSession* napiSession,
708 OHOS::AVSession::AVMetaData metaData)
709 {
710 return [napiSession, metaData]() {
711 AVQueueInfo info = AVQueueInfo();
712 CHECK_AND_RETURN_LOG(napiSession != nullptr && napiSession->session_ != nullptr, "avqImg download NoSession");
713 CHECK_AND_RETURN_LOG(!metaData.GetAVQueueImageUri().empty() && metaData.GetAVQueueImage() == nullptr,
714 "avqImg not match download conditions");
715
716 CHECK_AND_RETURN_LOG(napiSession->latestDownloadedAVQueueId_ != metaData.GetAVQueueId(), "repeat avqId return");
717 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
718 bool ret = NapiUtils::DoDownloadInCommon(pixelMap, metaData.GetAVQueueImageUri());
719 CHECK_AND_RETURN_LOG(napiSession != nullptr && napiSession->session_ != nullptr, "aft avq download NoSession");
720 CHECK_AND_RETURN_LOG(ret && pixelMap != nullptr, "download avqImg fail");
721 napiSession->latestDownloadedAVQueueId_ = metaData.GetAVQueueId();
722 info.SetAVQueueImage(AVSessionPixelMapAdapter::ConvertToInner(pixelMap));
723 info.SetAVQueueId(metaData.GetAVQueueId());
724 info.SetAVQueueName(metaData.GetAVQueueName());
725 napiSession->session_->UpdateAVQueueInfo(info);
726 };
727 }
728
SendCustomData(napi_env env,napi_callback_info info)729 napi_value NapiAVSession::SendCustomData(napi_env env, napi_callback_info info)
730 {
731 AVSESSION_TRACE_SYNC_START("NapiAVSession::SendCustomData");
732 struct ConcreteContext : public ContextBase {
733 AAFwk::WantParams data_;
734 };
735 auto context = std::make_shared<ConcreteContext>();
736 if (context == nullptr) {
737 SLOGE("SendCustomData failed : no memory");
738 NapiUtils::ThrowError(env, "SendCustomData failed : no memory",
739 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
740 return NapiUtils::GetUndefinedValue(env);
741 }
742 auto inputParser = [env, context](size_t argc, napi_value* argv) {
743 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
744 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
745 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->data_);
746 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get customData failed",
747 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
748 };
749 context->GetCbInfo(env, info, inputParser);
750 context->taskId = NAPI_SEND_CUSTOM_DATA_TASK_ID;
751 auto executor = [context]() {
752 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
753 if (napiSession->session_ == nullptr) {
754 context->status = napi_generic_failure;
755 context->errMessage = "SendCustomData failed : session is nullptr";
756 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
757 return;
758 }
759 int32_t ret = napiSession->session_->SendCustomData(context->data_);
760 if (ret != AVSESSION_SUCCESS) {
761 if (ret == ERR_SESSION_NOT_EXIST) {
762 context->errMessage = "SendCustomData failed : native session not exist";
763 } else if (ret == ERR_INVALID_PARAM) {
764 context->errMessage = "SendCustomData failed : native invalid parameters";
765 } else if (ret == ERR_NO_PERMISSION) {
766 context->errMessage = "SendCustomData failed : native no permission";
767 } else {
768 context->errMessage = "SendCustomData failed : native server exception, \
769 you are advised to : 1.scheduled retry.\
770 2.destroy the current session or session controller and re-create it.";
771 }
772 context->status = napi_generic_failure;
773 context->errCode = NapiAVSessionManager::errcode_[ret];
774 }
775 };
776 auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
777 return NapiAsyncWork::Enqueue(env, context, "SendCustomData", executor, complete);
778 }
779
SetAVPlaybackState(napi_env env,napi_callback_info info)780 napi_value NapiAVSession::SetAVPlaybackState(napi_env env, napi_callback_info info)
781 {
782 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVPlaybackState");
783 struct ConcreteContext : public ContextBase {
784 AVPlaybackState playBackState_;
785 };
786 auto context = std::make_shared<ConcreteContext>();
787 if (context == nullptr) {
788 SLOGE("SetAVPlaybackState failed : no memory");
789 NapiUtils::ThrowError(env, "SetAVPlaybackState failed : no memory",
790 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
791 return NapiUtils::GetUndefinedValue(env);
792 }
793
794 auto inputParser = [env, context](size_t argc, napi_value* argv) {
795 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
796 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
797 context->status = NapiPlaybackState::GetValue(env, argv[ARGV_FIRST], context->playBackState_);
798 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get playBackState failed",
799 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
800 };
801 context->GetCbInfo(env, info, inputParser);
802 context->taskId = NAPI_SET_AV_PLAYBACK_STATE_TASK_ID;
803
804 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
805 if (napiSession->session_ == nullptr) {
806 SLOGE("SetAVPlaybackState failed : session is nullptr");
807 context->status = napi_generic_failure;
808 context->errMessage = "SetAVPlaybackState failed : session is nullptr";
809 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
810 auto executor = []() {};
811 auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
812 return NapiAsyncWork::Enqueue(env, context, "SetAVPlaybackState", executor, complete);
813 }
814
815 auto syncExecutor = PlaybackStateSyncExecutor(napiSession->session_, context->playBackState_);
816 CHECK_AND_PRINT_LOG(AVSessionEventHandler::GetInstance()
817 .AVSessionPostTask(syncExecutor, "SetAVPlaybackState"),
818 "NapiAVSession SetAVPlaybackState handler postTask failed");
819
820 auto asyncExecutor = PlaybackStateAsyncExecutor(context);
821 auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
822 return NapiAsyncWork::Enqueue(env, context, "SetAVPlayback", asyncExecutor, complete);
823 }
824
SetAVQueueItems(napi_env env,napi_callback_info info)825 napi_value NapiAVSession::SetAVQueueItems(napi_env env, napi_callback_info info)
826 {
827 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVQueueItems");
828 struct ConcreteContext : public ContextBase { std::vector<AVQueueItem> items_; };
829 auto context = std::make_shared<ConcreteContext>();
830 if (context == nullptr) {
831 NapiUtils::ThrowError(env, "SetAVQueueItems failed : no memory",
832 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
833 return NapiUtils::GetUndefinedValue(env);
834 }
835 auto inputParser = [env, context](size_t argc, napi_value* argv) {
836 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
837 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
838 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->items_);
839 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get queueItems failed",
840 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
841 for (auto &item : context->items_) {
842 CHECK_ARGS_RETURN_VOID(context, item.IsValid(), "invalid queue item content",
843 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
844 }
845 };
846 context->GetCbInfo(env, info, inputParser);
847 context->taskId = NAPI_SET_AV_QUEUE_ITEMS_TASK_ID;
848 auto executor = [context]() {
849 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
850 if (napiSession->session_ == nullptr) {
851 context->status = napi_generic_failure;
852 context->errMessage = "SetAVQueueItems failed : session is nullptr";
853 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
854 return;
855 }
856 int32_t ret = napiSession->session_->SetAVQueueItems(context->items_);
857 if (ret != AVSESSION_SUCCESS) {
858 if (ret == ERR_SESSION_NOT_EXIST) {
859 context->errMessage = "SetAVQueueItems failed : native session not exist";
860 } else if (ret == ERR_INVALID_PARAM) {
861 context->errMessage = "SetAVQueueItems failed : native invalid parameters";
862 } else if (ret == ERR_NO_PERMISSION) {
863 context->errMessage = "SetAVQueueItems failed : native no permission";
864 } else if (ret == ERR_MARSHALLING) {
865 context->errMessage = "SetAVQueueItems failed : item number is out of range";
866 } else {
867 context->errMessage = "SetAVQueueItems failed : native server exception";
868 }
869 context->status = napi_generic_failure;
870 context->errCode = NapiAVSessionManager::errcode_[ret];
871 }
872 };
873 auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
874 return NapiAsyncWork::Enqueue(env, context, "SetAVQueueItems", executor, complete);
875 }
876
SetAVQueueTitle(napi_env env,napi_callback_info info)877 napi_value NapiAVSession::SetAVQueueTitle(napi_env env, napi_callback_info info)
878 {
879 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVQueueTitle");
880 struct ConcreteContext : public ContextBase {
881 std::string title;
882 };
883 auto context = std::make_shared<ConcreteContext>();
884 if (context == nullptr) {
885 SLOGE("SetAVQueueTitle failed : no memory");
886 NapiUtils::ThrowError(env, "SetAVQueueTitle failed : no memory",
887 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
888 return NapiUtils::GetUndefinedValue(env);
889 }
890
891 auto inputParser = [env, context](size_t argc, napi_value* argv) {
892 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
893 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
894 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->title);
895 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get queueItems failed",
896 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
897 };
898 context->GetCbInfo(env, info, inputParser);
899 context->taskId = NAPI_SET_AV_QUEUE_TITLE_TASK_ID;
900
901 auto executor = [context]() {
902 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
903 if (napiSession->session_ == nullptr) {
904 context->status = napi_generic_failure;
905 context->errMessage = "SetAVQueueTitle failed : session is nullptr";
906 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
907 return;
908 }
909 int32_t ret = napiSession->session_->SetAVQueueTitle(context->title);
910 if (ret != AVSESSION_SUCCESS) {
911 if (ret == ERR_SESSION_NOT_EXIST) {
912 context->errMessage = "SetAVQueueTitle failed : native session not exist";
913 } else if (ret == ERR_INVALID_PARAM) {
914 context->errMessage = "SetAVQueueTitle failed : native invalid parameters";
915 } else if (ret == ERR_NO_PERMISSION) {
916 context->errMessage = "SetAVQueueTitle failed : native no permission";
917 } else {
918 context->errMessage = "SetAVQueueTitle failed : native server exception";
919 }
920 context->status = napi_generic_failure;
921 context->errCode = NapiAVSessionManager::errcode_[ret];
922 }
923 };
924 auto complete = [env](napi_value& output) {
925 output = NapiUtils::GetUndefinedValue(env);
926 };
927 return NapiAsyncWork::Enqueue(env, context, "SetAVQueueTitle", executor, complete);
928 }
929
SetLaunchAbility(napi_env env,napi_callback_info info)930 napi_value NapiAVSession::SetLaunchAbility(napi_env env, napi_callback_info info)
931 {
932 struct ConcreteContext : public ContextBase {
933 AbilityRuntime::WantAgent::WantAgent* wantAgent_;
934 };
935 auto context = std::make_shared<ConcreteContext>();
936 if (context == nullptr) {
937 SLOGE("SetLaunchAbility failed : no memory");
938 NapiUtils::ThrowError(env, "SetLaunchAbility failed : no memory",
939 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
940 return NapiUtils::GetUndefinedValue(env);
941 }
942
943 auto inputParser = [env, context](size_t argc, napi_value* argv) {
944 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
945 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
946 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->wantAgent_);
947 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get wantAgent failed",
948 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
949 };
950 context->GetCbInfo(env, info, inputParser);
951
952 auto executor = [context]() {
953 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
954 if (napiSession->session_ == nullptr) {
955 context->status = napi_generic_failure;
956 context->errMessage = "SetLaunchAbility failed : session is nullptr";
957 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
958 return;
959 }
960 int32_t ret = napiSession->session_->SetLaunchAbility(*context->wantAgent_);
961 if (ret != AVSESSION_SUCCESS) {
962 if (ret == ERR_SESSION_NOT_EXIST) {
963 context->errMessage = "SetLaunchAbility failed : native session not exist";
964 } else if (ret == ERR_NO_PERMISSION) {
965 context->errMessage = "SetLaunchAbility failed : native no permission";
966 } else {
967 context->errMessage = "SetLaunchAbility failed : native server exception";
968 }
969 context->status = napi_generic_failure;
970 context->errCode = NapiAVSessionManager::errcode_[ret];
971 }
972 };
973 auto complete = [env](napi_value& output) {
974 output = NapiUtils::GetUndefinedValue(env);
975 };
976 return NapiAsyncWork::Enqueue(env, context, "SetLaunchAbility", executor, complete);
977 }
978
SetExtras(napi_env env,napi_callback_info info)979 napi_value NapiAVSession::SetExtras(napi_env env, napi_callback_info info)
980 {
981 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetExtras");
982 struct ConcreteContext : public ContextBase {
983 AAFwk::WantParams extras_;
984 };
985 auto context = std::make_shared<ConcreteContext>();
986 if (context == nullptr) {
987 SLOGE("SetExtras failed : no memory");
988 NapiUtils::ThrowError(env, "SetExtras failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
989 return NapiUtils::GetUndefinedValue(env);
990 }
991
992 auto inputParser = [env, context](size_t argc, napi_value* argv) {
993 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
994 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
995 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->extras_);
996 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get extras failed",
997 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
998 };
999 context->GetCbInfo(env, info, inputParser);
1000 context->taskId = NAPI_SET_EXTRAS_TASK_ID;
1001
1002 auto executor = [context]() {
1003 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1004 if (napiSession->session_ == nullptr) {
1005 context->status = napi_generic_failure;
1006 context->errMessage = "SetExtras failed : session is nullptr";
1007 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1008 return;
1009 }
1010 int32_t ret = napiSession->session_->SetExtras(context->extras_);
1011 if (ret != AVSESSION_SUCCESS) {
1012 if (ret == ERR_SESSION_NOT_EXIST) {
1013 context->errMessage = "SetExtras failed : native session not exist";
1014 } else if (ret == ERR_INVALID_PARAM) {
1015 context->errMessage = "SetExtras failed : native invalid parameters";
1016 } else {
1017 context->errMessage = "SetExtras failed : native server exception";
1018 }
1019 context->status = napi_generic_failure;
1020 context->errCode = NapiAVSessionManager::errcode_[ret];
1021 }
1022 };
1023 auto complete = [env](napi_value& output) {
1024 output = NapiUtils::GetUndefinedValue(env);
1025 };
1026 return NapiAsyncWork::Enqueue(env, context, "SetExtras", executor, complete);
1027 }
1028
SetAudioStreamId(napi_env env,napi_callback_info info)1029 napi_value NapiAVSession::SetAudioStreamId(napi_env env, napi_callback_info info)
1030 {
1031 struct ConcreteContext : public ContextBase {
1032 std::vector<int32_t> streamIds_;
1033 };
1034 auto context = std::make_shared<ConcreteContext>();
1035 if (context == nullptr) {
1036 SLOGE("SetAudioStreamId failed : no memory");
1037 NapiUtils::ThrowError(env, "SetAudioStreamId failed : no memory",
1038 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1039 return NapiUtils::GetUndefinedValue(env);
1040 }
1041
1042 auto inputParser = [env, context](size_t argc, napi_value* argv) {
1043 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
1044 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
1045 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->streamIds_);
1046 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get streamIds_ failed",
1047 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
1048 };
1049 context->GetCbInfo(env, info, inputParser);
1050
1051 auto executor = [context]() {
1052 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1053 if (napiSession->session_ == nullptr) {
1054 context->status = napi_generic_failure;
1055 context->errMessage = "SetAudioStreamId failed : session is nullptr";
1056 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1057 return;
1058 }
1059 };
1060 auto complete = [env](napi_value& output) {
1061 output = NapiUtils::GetUndefinedValue(env);
1062 };
1063 return NapiAsyncWork::Enqueue(env, context, "SetAudioStreamId", executor, complete);
1064 }
1065
GetController(napi_env env,napi_callback_info info)1066 napi_value NapiAVSession::GetController(napi_env env, napi_callback_info info)
1067 {
1068 struct ConcreteContext : public ContextBase {
1069 std::shared_ptr<AVSessionController> controller_;
1070 };
1071 auto context = std::make_shared<ConcreteContext>();
1072 if (context == nullptr) {
1073 SLOGE("GetController failed : no memory");
1074 NapiUtils::ThrowError(env, "GetController failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1075 return NapiUtils::GetUndefinedValue(env);
1076 }
1077
1078 context->GetCbInfo(env, info);
1079
1080 auto executor = [context]() {
1081 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1082 if (napiSession->session_ == nullptr) {
1083 context->status = napi_generic_failure;
1084 context->errMessage = "GetController failed : session is nullptr";
1085 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1086 return;
1087 }
1088 context->controller_ = napiSession->session_->GetController();
1089 if (context->controller_ == nullptr) {
1090 context->status = napi_generic_failure;
1091 context->errMessage = "GetController failed : native get controller failed";
1092 context->errCode = NapiAVSessionManager::errcode_[AVSESSION_ERROR];
1093 }
1094 };
1095 auto complete = [env, context](napi_value& output) {
1096 CHECK_STATUS_RETURN_VOID(context, "get controller failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1097 CHECK_ARGS_RETURN_VOID(context, context->controller_ != nullptr, "controller is nullptr",
1098 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1099 context->status = NapiAVSessionController::NewInstance(env, context->controller_, output);
1100 CHECK_STATUS_RETURN_VOID(context, "convert native object to js object failed",
1101 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1102 };
1103 return NapiAsyncWork::Enqueue(env, context, "GetController", executor, complete);
1104 }
1105
GetAVCastController(napi_env env,napi_callback_info info)1106 napi_value NapiAVSession::GetAVCastController(napi_env env, napi_callback_info info)
1107 {
1108 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1109 struct ConcreteContext : public ContextBase {
1110 std::shared_ptr<AVCastController> castController_;
1111 };
1112 auto context = std::make_shared<ConcreteContext>();
1113 if (context == nullptr) {
1114 SLOGE("GetAVCastController failed : no memory");
1115 NapiUtils::ThrowError(env, "GetAVCastController failed : no memory",
1116 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1117 return NapiUtils::GetUndefinedValue(env);
1118 }
1119
1120 context->GetCbInfo(env, info);
1121
1122 auto executor = [context]() {
1123 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1124 if (napiSession->session_ == nullptr) {
1125 context->status = napi_generic_failure;
1126 context->errMessage = "GetAVCastController failed : session is nullptr";
1127 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1128 return;
1129 }
1130 context->castController_ = napiSession->session_->GetAVCastController();
1131 if (context->castController_ == nullptr) {
1132 context->status = napi_generic_failure;
1133 context->errMessage = "GetAVCastController failed : native get controller failed";
1134 context->errCode = NapiAVSessionManager::errcode_[AVSESSION_ERROR];
1135 }
1136 };
1137 auto complete = [env, context](napi_value& output) {
1138 CHECK_STATUS_RETURN_VOID(context, "get controller failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1139 CHECK_ARGS_RETURN_VOID(context, context->castController_ != nullptr, "controller is nullptr",
1140 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1141 context->status = NapiAVCastController::NewInstance(env, context->castController_, output);
1142 CHECK_STATUS_RETURN_VOID(context, "convert native object to js object failed",
1143 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1144 };
1145 return NapiAsyncWork::Enqueue(env, context, "GetAVCastController", executor, complete);
1146 #else
1147 return nullptr;
1148 #endif
1149 }
1150
GetOutputDevice(napi_env env,napi_callback_info info)1151 napi_value NapiAVSession::GetOutputDevice(napi_env env, napi_callback_info info)
1152 {
1153 struct ConcreteContext : public ContextBase {
1154 OutputDeviceInfo outputDeviceInfo_;
1155 };
1156 auto context = std::make_shared<ConcreteContext>();
1157 if (context == nullptr) {
1158 SLOGE("GetOutputDevice failed : no memory");
1159 NapiUtils::ThrowError(env, "GetOutputDevice failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1160 return NapiUtils::GetUndefinedValue(env);
1161 }
1162
1163 context->GetCbInfo(env, info);
1164
1165 auto executor = [context]() {
1166 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1167 if (napiSession->session_ == nullptr) {
1168 context->status = napi_generic_failure;
1169 context->errMessage = "GetOutputDevice failed : session is nullptr";
1170 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1171 return;
1172 }
1173 AVSessionDescriptor descriptor;
1174 AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(napiSession->session_->GetSessionId(),
1175 descriptor);
1176 context->outputDeviceInfo_ = descriptor.outputDeviceInfo_;
1177 };
1178
1179 auto complete = [env, context](napi_value& output) {
1180 context->status = NapiUtils::SetValue(env, context->outputDeviceInfo_, output);
1181 CHECK_STATUS_RETURN_VOID(context, "convert native object to javascript object failed",
1182 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1183 };
1184 return NapiAsyncWork::Enqueue(env, context, "GetOutputDevice", executor, complete);
1185 }
1186
GetOutputDeviceSync(napi_env env,napi_callback_info info)1187 napi_value NapiAVSession::GetOutputDeviceSync(napi_env env, napi_callback_info info)
1188 {
1189 SLOGD("Start GetOutputDeviceSync");
1190 auto context = std::make_shared<ContextBase>();
1191 if (context == nullptr) {
1192 SLOGE("GetOutputDeviceSync failed : no memory");
1193 NapiUtils::ThrowError(env, "GetOutputDeviceSync failed : no memory",
1194 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1195 return NapiUtils::GetUndefinedValue(env);
1196 }
1197
1198 context->GetCbInfo(env, info, NapiCbInfoParser(), true);
1199
1200 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1201 if (napiSession->session_ == nullptr) {
1202 SLOGE("NapiAVSession GetOutputDeviceSync fail:session nullptr");
1203 NapiUtils::ThrowError(env, "NapiAVSession GetOutputDeviceSync failed : session is nullptr",
1204 NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
1205 return NapiUtils::GetUndefinedValue(env);
1206 }
1207
1208 AVSessionDescriptor descriptor;
1209 AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(napiSession->session_->GetSessionId(),
1210 descriptor);
1211 napi_value output {};
1212 auto status = NapiUtils::SetValue(env, descriptor.outputDeviceInfo_, output);
1213 if (status != napi_ok) {
1214 SLOGE("convert native object to javascript object failed");
1215 NapiUtils::ThrowError(env, "convert native object to javascript object failed",
1216 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1217 return NapiUtils::GetUndefinedValue(env);
1218 }
1219 return output;
1220 }
1221
Activate(napi_env env,napi_callback_info info)1222 napi_value NapiAVSession::Activate(napi_env env, napi_callback_info info)
1223 {
1224 auto context = std::make_shared<ContextBase>();
1225 if (context == nullptr) {
1226 SLOGE("Activate failed : no memory");
1227 NapiUtils::ThrowError(env, "Activate failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1228 return NapiUtils::GetUndefinedValue(env);
1229 }
1230
1231 context->GetCbInfo(env, info);
1232
1233 auto executor = [context]() {
1234 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1235 if (napiSession->session_ == nullptr) {
1236 context->status = napi_generic_failure;
1237 context->errMessage = "Activate session failed : session is nullptr";
1238 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1239 return;
1240 }
1241 int32_t ret = napiSession->session_->Activate();
1242 if (ret != AVSESSION_SUCCESS) {
1243 if (ret == ERR_SESSION_NOT_EXIST) {
1244 context->errMessage = "Activate session failed : native session not exist";
1245 } else if (ret == ERR_NO_PERMISSION) {
1246 context->errMessage = "Activate failed : native no permission";
1247 } else {
1248 context->errMessage = "Activate session failed : native server exception";
1249 }
1250 context->status = napi_generic_failure;
1251 context->errCode = NapiAVSessionManager::errcode_[ret];
1252 }
1253 };
1254 auto complete = [env](napi_value& output) {
1255 output = NapiUtils::GetUndefinedValue(env);
1256 };
1257 return NapiAsyncWork::Enqueue(env, context, "Activate", executor, complete);
1258 }
1259
Deactivate(napi_env env,napi_callback_info info)1260 napi_value NapiAVSession::Deactivate(napi_env env, napi_callback_info info)
1261 {
1262 auto context = std::make_shared<ContextBase>();
1263 if (context == nullptr) {
1264 SLOGE("Deactivate failed : no memory");
1265 NapiUtils::ThrowError(env, "Deactivate failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1266 return NapiUtils::GetUndefinedValue(env);
1267 }
1268
1269 context->GetCbInfo(env, info);
1270
1271 auto executor = [context]() {
1272 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1273 if (napiSession->session_ == nullptr) {
1274 context->status = napi_generic_failure;
1275 context->errMessage = "Deactivate session failed : session is nullptr";
1276 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1277 return;
1278 }
1279 int32_t ret = napiSession->session_->Deactivate();
1280 if (ret != AVSESSION_SUCCESS) {
1281 if (ret == ERR_SESSION_NOT_EXIST) {
1282 context->errMessage = "Deactivate session failed : native session not exist";
1283 } else if (ret == ERR_NO_PERMISSION) {
1284 context->errMessage = "Deactivate failed : native no permission";
1285 } else {
1286 context->errMessage = "Deactivate session failed : native server exception";
1287 }
1288 context->status = napi_generic_failure;
1289 context->errCode = NapiAVSessionManager::errcode_[ret];
1290 }
1291 };
1292 auto complete = [env](napi_value& output) {
1293 output = NapiUtils::GetUndefinedValue(env);
1294 };
1295 return NapiAsyncWork::Enqueue(env, context, "Deactivate", executor, complete);
1296 }
1297
Destroy(napi_env env,napi_callback_info info)1298 napi_value NapiAVSession::Destroy(napi_env env, napi_callback_info info)
1299 {
1300 auto context = std::make_shared<ContextBase>();
1301 if (context == nullptr) {
1302 SLOGE("Destroy failed : no memory");
1303 NapiUtils::ThrowError(env, "Destroy failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1304 return NapiUtils::GetUndefinedValue(env);
1305 }
1306
1307 context->GetCbInfo(env, info);
1308
1309 SLOGI("Destroy session begin");
1310 {
1311 std::lock_guard lockGuard(destroyLock_);
1312 isNapiSessionDestroy_ = true;
1313 }
1314 auto executor = [context]() {
1315 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1316 if (napiSession->session_ == nullptr) {
1317 context->status = napi_generic_failure;
1318 context->errMessage = "Destroy session failed : session is nullptr";
1319 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1320 return;
1321 }
1322 int32_t ret = napiSession->session_->Destroy();
1323 if (ret == AVSESSION_SUCCESS) {
1324 napiSession->session_ = nullptr;
1325 napiSession->callback_ = nullptr;
1326 } else if (ret == ERR_SESSION_NOT_EXIST) {
1327 context->status = napi_generic_failure;
1328 context->errMessage = "Destroy session failed : native session not exist";
1329 context->errCode = NapiAVSessionManager::errcode_[ret];
1330 } else if (ret == ERR_NO_PERMISSION) {
1331 context->status = napi_generic_failure;
1332 context->errMessage = "Destroy failed : native no permission";
1333 context->errCode = NapiAVSessionManager::errcode_[ret];
1334 } else {
1335 context->status = napi_generic_failure;
1336 context->errMessage = "Destroy session failed : native server exception";
1337 context->errCode = NapiAVSessionManager::errcode_[ret];
1338 }
1339 };
1340 auto complete = [env](napi_value& output) {
1341 output = NapiUtils::GetUndefinedValue(env);
1342 };
1343 return NapiAsyncWork::Enqueue(env, context, "Destroy", executor, complete);
1344 }
1345
SetSessionEvent(napi_env env,napi_callback_info info)1346 napi_value NapiAVSession::SetSessionEvent(napi_env env, napi_callback_info info)
1347 {
1348 AVSESSION_TRACE_SYNC_START("NapiAVSession::SetSessionEvent");
1349 struct ConcreteContext : public ContextBase {
1350 std::string event_;
1351 AAFwk::WantParams args_;
1352 };
1353 auto context = std::make_shared<ConcreteContext>();
1354 if (context == nullptr) {
1355 SLOGE("SetSessionEvent failed : no memory");
1356 NapiUtils::ThrowError(env, "SetSessionEvent failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1357 return NapiUtils::GetUndefinedValue(env);
1358 }
1359
1360 auto inputParser = [env, context](size_t argc, napi_value* argv) {
1361 CHECK_ARGS_RETURN_VOID(context, argc == ARGC_TWO, "invalid arguments",
1362 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
1363 context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->event_);
1364 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get event failed",
1365 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
1366 context->status = NapiUtils::GetValue(env, argv[ARGV_SECOND], context->args_);
1367 CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get args failed",
1368 NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
1369 };
1370 context->GetCbInfo(env, info, inputParser);
1371 context->taskId = NAPI_SET_AV_META_DATA_TASK_ID;
1372
1373 auto executor = [context]() {
1374 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1375 if (napiSession->session_ == nullptr) {
1376 context->status = napi_generic_failure;
1377 context->errMessage = "SetSessionEvent failed : session is nullptr";
1378 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1379 return;
1380 }
1381 int32_t ret = napiSession->session_->SetSessionEvent(context->event_, context->args_);
1382 if (ret != AVSESSION_SUCCESS) {
1383 ErrCodeToMessage(ret, context->errMessage);
1384 context->status = napi_generic_failure;
1385 context->errCode = NapiAVSessionManager::errcode_[ret];
1386 }
1387 };
1388 auto complete = [env](napi_value& output) {
1389 output = NapiUtils::GetUndefinedValue(env);
1390 };
1391 return NapiAsyncWork::Enqueue(env, context, "SetSessionEvent", executor, complete);
1392 }
1393
ReleaseCast(napi_env env,napi_callback_info info)1394 napi_value NapiAVSession::ReleaseCast(napi_env env, napi_callback_info info)
1395 {
1396 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1397 auto context = std::make_shared<ContextBase>();
1398 if (context == nullptr) {
1399 SLOGE("ReleaseCast failed : no memory");
1400 NapiUtils::ThrowError(env, "ReleaseCast failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1401 return NapiUtils::GetUndefinedValue(env);
1402 }
1403
1404 context->GetCbInfo(env, info);
1405
1406 auto executor = [context]() {
1407 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1408 if (napiSession->session_ == nullptr) {
1409 context->status = napi_generic_failure;
1410 context->errMessage = "ReleaseCast failed : session is nullptr";
1411 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1412 return;
1413 }
1414 int32_t ret = napiSession->session_->ReleaseCast();
1415 if (ret != AVSESSION_SUCCESS) {
1416 if (ret == ERR_SESSION_NOT_EXIST) {
1417 context->errMessage = "ReleaseCast failed : native session not exist";
1418 } else if (ret == ERR_NO_PERMISSION) {
1419 context->errMessage = "ReleaseCast failed : native no permission";
1420 } else {
1421 context->errMessage = "ReleaseCast failed : native server exception";
1422 }
1423 context->status = napi_generic_failure;
1424 context->errCode = NapiAVSessionManager::errcode_[ret];
1425 }
1426 };
1427 auto complete = [env](napi_value& output) {
1428 output = NapiUtils::GetUndefinedValue(env);
1429 };
1430 return NapiAsyncWork::Enqueue(env, context, "ReleaseCast", executor, complete);
1431 #else
1432 return nullptr;
1433 #endif
1434 }
1435
GetAllCastDisplays(napi_env env,napi_callback_info info)1436 napi_value NapiAVSession::GetAllCastDisplays(napi_env env, napi_callback_info info)
1437 {
1438 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1439 struct ConcreteContext : public ContextBase {
1440 std::vector<CastDisplayInfo> castDisplays_;
1441 };
1442 auto context = std::make_shared<ConcreteContext>();
1443 if (context == nullptr) {
1444 SLOGE("GetAllCastDisplays failed : no memory");
1445 NapiUtils::ThrowError(env, "GetAllCastDisplays failed : no memory",
1446 NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
1447 return NapiUtils::GetUndefinedValue(env);
1448 }
1449
1450 context->GetCbInfo(env, info);
1451
1452 auto executor = [context]() {
1453 auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
1454 if (napiSession->session_ == nullptr) {
1455 context->status = napi_generic_failure;
1456 context->errMessage = "GetAllCastDisplays failed : session is nullptr";
1457 context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
1458 return;
1459 }
1460 int32_t ret = napiSession->session_->GetAllCastDisplays(context->castDisplays_);
1461 if (ret != AVSESSION_SUCCESS) {
1462 if (ret == ERR_SESSION_NOT_EXIST) {
1463 context->errMessage = "GetAllCastDisplays failed : native session not exist";
1464 } else if (ret == ERR_NO_PERMISSION) {
1465 context->errMessage = "GetAllCastDisplays failed : native no permission";
1466 } else {
1467 context->errMessage = "GetAllCastDisplays failed : native server exception";
1468 }
1469 context->status = napi_generic_failure;
1470 context->errCode = NapiAVSessionManager::errcode_[ret];
1471 }
1472 };
1473
1474 auto complete = [env, context](napi_value& output) {
1475 context->status = NapiUtils::SetValue(env, context->castDisplays_, output);
1476 CHECK_STATUS_RETURN_VOID(context, "convert native object to javascript object failed",
1477 NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
1478 };
1479 return NapiAsyncWork::Enqueue(env, context, "GetAllCastDisplays", executor, complete);
1480 #else
1481 SLOGE("GetAllCastDisplays CASTPLUS_CAST_ENGINE_ENABLE is not support");
1482 return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
1483 #endif
1484 }
1485
ErrCodeToMessage(int32_t errCode,std::string & message)1486 void NapiAVSession::ErrCodeToMessage(int32_t errCode, std::string& message)
1487 {
1488 switch (errCode) {
1489 case ERR_SESSION_NOT_EXIST:
1490 message = "SetSessionEvent failed : native session not exist";
1491 break;
1492 case ERR_INVALID_PARAM:
1493 message = "SetSessionEvent failed : native invalid parameters";
1494 break;
1495 case ERR_NO_PERMISSION:
1496 message = "SetSessionEvent failed : native no permission";
1497 break;
1498 default:
1499 message = "SetSessionEvent failed : native server exception";
1500 break;
1501 }
1502 }
1503
OnPlay(napi_env env,NapiAVSession * napiSession,napi_value callback)1504 napi_status NapiAVSession::OnPlay(napi_env env, NapiAVSession* napiSession, napi_value callback)
1505 {
1506 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1507 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY);
1508 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1509 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1510 "NapiAVSessionCallback object is nullptr");
1511 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY, callback);
1512 }
1513
OnPause(napi_env env,NapiAVSession * napiSession,napi_value callback)1514 napi_status NapiAVSession::OnPause(napi_env env, NapiAVSession* napiSession, napi_value callback)
1515 {
1516 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1517 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE);
1518 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1519 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1520 "NapiAVSessionCallback object is nullptr");
1521 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PAUSE, callback);
1522 }
1523
OnStop(napi_env env,NapiAVSession * napiSession,napi_value callback)1524 napi_status NapiAVSession::OnStop(napi_env env, NapiAVSession* napiSession, napi_value callback)
1525 {
1526 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1527 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_STOP);
1528 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1529 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1530 "NapiAVSessionCallback object is nullptr");
1531 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_STOP, callback);
1532 }
1533
OnPlayNext(napi_env env,NapiAVSession * napiSession,napi_value callback)1534 napi_status NapiAVSession::OnPlayNext(napi_env env, NapiAVSession* napiSession, napi_value callback)
1535 {
1536 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1537 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
1538 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1539 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1540 "NapiAVSessionCallback object is nullptr");
1541 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_NEXT, callback);
1542 }
1543
OnPlayPrevious(napi_env env,NapiAVSession * napiSession,napi_value callback)1544 napi_status NapiAVSession::OnPlayPrevious(napi_env env, NapiAVSession* napiSession, napi_value callback)
1545 {
1546 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1547 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
1548 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1549 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1550 "NapiAVSessionCallback object is nullptr");
1551 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_PREVIOUS, callback);
1552 }
1553
OnFastForward(napi_env env,NapiAVSession * napiSession,napi_value callback)1554 napi_status NapiAVSession::OnFastForward(napi_env env, NapiAVSession* napiSession, napi_value callback)
1555 {
1556 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1557 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_FAST_FORWARD);
1558 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1559 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1560 "NapiAVSessionCallback object is nullptr");
1561 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_FAST_FORWARD, callback);
1562 }
1563
OnRewind(napi_env env,NapiAVSession * napiSession,napi_value callback)1564 napi_status NapiAVSession::OnRewind(napi_env env, NapiAVSession* napiSession, napi_value callback)
1565 {
1566 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1567 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_REWIND);
1568 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1569 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1570 "NapiAVSessionCallback object is nullptr");
1571 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_REWIND, callback);
1572 }
1573
OnSeek(napi_env env,NapiAVSession * napiSession,napi_value callback)1574 napi_status NapiAVSession::OnSeek(napi_env env, NapiAVSession* napiSession, napi_value callback)
1575 {
1576 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1577 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SEEK);
1578 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1579 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1580 "NapiAVSessionCallback object is nullptr");
1581 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SEEK, callback);
1582 }
1583
OnSetSpeed(napi_env env,NapiAVSession * napiSession,napi_value callback)1584 napi_status NapiAVSession::OnSetSpeed(napi_env env, NapiAVSession* napiSession, napi_value callback)
1585 {
1586 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1587 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_SPEED);
1588 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1589 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1590 "NapiAVSessionCallback object is nullptr");
1591 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_SPEED, callback);
1592 }
1593
OnSetLoopMode(napi_env env,NapiAVSession * napiSession,napi_value callback)1594 napi_status NapiAVSession::OnSetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
1595 {
1596 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1597 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE);
1598 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1599 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1600 "NapiAVSessionCallback object is nullptr");
1601 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_LOOP_MODE, callback);
1602 }
1603
OnSetTargetLoopMode(napi_env env,NapiAVSession * napiSession,napi_value callback)1604 napi_status NapiAVSession::OnSetTargetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
1605 {
1606 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1607 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE);
1608 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1609 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1610 "NapiAVSessionCallback object is nullptr");
1611 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE, callback);
1612 }
1613
OnToggleFavorite(napi_env env,NapiAVSession * napiSession,napi_value callback)1614 napi_status NapiAVSession::OnToggleFavorite(napi_env env, NapiAVSession* napiSession, napi_value callback)
1615 {
1616 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1617 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE);
1618 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1619 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1620 "NapiAVSessionCallback object is nullptr");
1621 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE, callback);
1622 }
1623
OnCustomData(napi_env env,NapiAVSession * napiSession,napi_value callback)1624 napi_status NapiAVSession::OnCustomData(napi_env env, NapiAVSession* napiSession, napi_value callback)
1625 {
1626 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1627 CHECK_AND_RETURN_RET_LOG(callback != nullptr, napi_generic_failure, "callback is nullptr");
1628 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1629 "NapiAVSessionCallback object is nullptr");
1630 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_CUSTOM_DATA, callback);
1631 }
1632
OnMediaKeyEvent(napi_env env,NapiAVSession * napiSession,napi_value callback)1633 napi_status NapiAVSession::OnMediaKeyEvent(napi_env env, NapiAVSession* napiSession, napi_value callback)
1634 {
1635 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1636 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT);
1637 SLOGI("add media key event listen ret %{public}d", static_cast<int>(ret));
1638 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1639 "NapiAVSessionCallback object is nullptr");
1640 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT, callback);
1641 }
1642
OnOutputDeviceChange(napi_env env,NapiAVSession * napiSession,napi_value callback)1643 napi_status NapiAVSession::OnOutputDeviceChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
1644 {
1645 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1646 "NapiAVSessionCallback object is nullptr");
1647 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_OUTPUT_DEVICE_CHANGE, callback);
1648 }
1649
OnCommonCommand(napi_env env,NapiAVSession * napiSession,napi_value callback)1650 napi_status NapiAVSession::OnCommonCommand(napi_env env, NapiAVSession* napiSession, napi_value callback)
1651 {
1652 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SEND_COMMON_COMMAND, callback);
1653 }
1654
OnSkipToQueueItem(napi_env env,NapiAVSession * napiSession,napi_value callback)1655 napi_status NapiAVSession::OnSkipToQueueItem(napi_env env, NapiAVSession* napiSession, napi_value callback)
1656 {
1657 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SKIP_TO_QUEUE_ITEM, callback);
1658 }
1659
OnAVCallAnswer(napi_env env,NapiAVSession * napiSession,napi_value callback)1660 napi_status NapiAVSession::OnAVCallAnswer(napi_env env, NapiAVSession* napiSession, napi_value callback)
1661 {
1662 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1663 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_ANSWER);
1664 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1665 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1666 "NapiAVSessionCallback object is nullptr");
1667 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_ANSWER, callback);
1668 }
1669
OnAVCallHangUp(napi_env env,NapiAVSession * napiSession,napi_value callback)1670 napi_status NapiAVSession::OnAVCallHangUp(napi_env env, NapiAVSession* napiSession, napi_value callback)
1671 {
1672 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1673 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_HANG_UP);
1674 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1675 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1676 "NapiAVSessionCallback object is nullptr");
1677 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_HANG_UP, callback);
1678 }
1679
OnAVCallToggleCallMute(napi_env env,NapiAVSession * napiSession,napi_value callback)1680 napi_status NapiAVSession::OnAVCallToggleCallMute(napi_env env, NapiAVSession* napiSession, napi_value callback)
1681 {
1682 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1683 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_TOGGLE_CALL_MUTE);
1684 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1685 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1686 "NapiAVSessionCallback object is nullptr");
1687 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_TOGGLE_CALL_MUTE, callback);
1688 }
1689
OnPlayFromAssetId(napi_env env,NapiAVSession * napiSession,napi_value callback)1690 napi_status NapiAVSession::OnPlayFromAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
1691 {
1692 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1693 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID);
1694 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1695 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1696 "NapiAVSessionCallback object is nullptr");
1697 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID, callback);
1698 }
1699
OnPlayWithAssetId(napi_env env,NapiAVSession * napiSession,napi_value callback)1700 napi_status NapiAVSession::OnPlayWithAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
1701 {
1702 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1703 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
1704 int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID);
1705 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
1706 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1707 "NapiAVSessionCallback object is nullptr");
1708 return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID, callback);
1709 }
1710
OnCastDisplayChange(napi_env env,NapiAVSession * napiSession,napi_value callback)1711 napi_status NapiAVSession::OnCastDisplayChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
1712 {
1713 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1714 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1715 "NapiAVSessionCallback object is nullptr");
1716 auto status = napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_CHANGE, callback);
1717 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "AddCallback failed");
1718 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1719 "NapiAVSession object is nullptr");
1720 napiSession->session_->StartCastDisplayListener();
1721 #else
1722 return napi_generic_failure;
1723 #endif
1724 return napi_ok;
1725 }
1726
OnCastDisplaySizeChange(napi_env env,NapiAVSession * napiSession,napi_value callback)1727 napi_status NapiAVSession::OnCastDisplaySizeChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
1728 {
1729 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1730 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1731 "NapiAVSessionCallback object is nullptr");
1732 auto status = napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_SIZE_CHANGE, callback);
1733 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "AddCallback failed");
1734 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1735 "NapiAVSession object is nullptr");
1736 napiSession->session_->StartCastDisplayListener();
1737 #else
1738 return napi_generic_failure;
1739 #endif
1740 return napi_ok;
1741 }
1742
OffPlay(napi_env env,NapiAVSession * napiSession,napi_value callback)1743 napi_status NapiAVSession::OffPlay(napi_env env, NapiAVSession* napiSession, napi_value callback)
1744 {
1745 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1746 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1747 "NapiAVSessionCallback object is nullptr");
1748 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY, callback);
1749 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1750 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY)) {
1751 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1752 "NapiAVSession object is nullptr");
1753 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY);
1754 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1755 }
1756 return napi_ok;
1757 }
1758
OffPause(napi_env env,NapiAVSession * napiSession,napi_value callback)1759 napi_status NapiAVSession::OffPause(napi_env env, NapiAVSession* napiSession, napi_value callback)
1760 {
1761 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1762 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1763 "NapiAVSessionCallback object is nullptr");
1764 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PAUSE, callback);
1765 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1766 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PAUSE)) {
1767 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1768 "NapiAVSession object is nullptr");
1769 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PAUSE);
1770 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1771 }
1772 return napi_ok;
1773 }
1774
OffStop(napi_env env,NapiAVSession * napiSession,napi_value callback)1775 napi_status NapiAVSession::OffStop(napi_env env, NapiAVSession* napiSession, napi_value callback)
1776 {
1777 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1778 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1779 "NapiAVSessionCallback object is nullptr");
1780 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_STOP, callback);
1781 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1782 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_STOP)) {
1783 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1784 "NapiAVSession object is nullptr");
1785 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_STOP);
1786 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1787 }
1788 return napi_ok;
1789 }
1790
OffPlayNext(napi_env env,NapiAVSession * napiSession,napi_value callback)1791 napi_status NapiAVSession::OffPlayNext(napi_env env, NapiAVSession* napiSession, napi_value callback)
1792 {
1793 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1794 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1795 "NapiAVSessionCallback object is nullptr");
1796 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_NEXT, callback);
1797 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1798 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_NEXT)) {
1799 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1800 "NapiAVSession object is nullptr");
1801 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
1802 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1803 }
1804 return napi_ok;
1805 }
1806
OffPlayPrevious(napi_env env,NapiAVSession * napiSession,napi_value callback)1807 napi_status NapiAVSession::OffPlayPrevious(napi_env env, NapiAVSession* napiSession, napi_value callback)
1808 {
1809 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1810 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1811 "NapiAVSessionCallback object is nullptr");
1812 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_PREVIOUS, callback);
1813 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1814
1815 if (napiSession->callback_ &&
1816 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_PREVIOUS)) {
1817 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1818 "NapiAVSession object is nullptr");
1819 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
1820 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1821 }
1822 return napi_ok;
1823 }
1824
OffFastForward(napi_env env,NapiAVSession * napiSession,napi_value callback)1825 napi_status NapiAVSession::OffFastForward(napi_env env, NapiAVSession* napiSession, napi_value callback)
1826 {
1827 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1828 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1829 "NapiAVSessionCallback object is nullptr");
1830 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_FAST_FORWARD, callback);
1831 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1832 if (napiSession->callback_ &&
1833 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_FAST_FORWARD)) {
1834 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1835 "NapiAVSession object is nullptr");
1836 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_FAST_FORWARD);
1837 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1838 }
1839 return napi_ok;
1840 }
1841
OffRewind(napi_env env,NapiAVSession * napiSession,napi_value callback)1842 napi_status NapiAVSession::OffRewind(napi_env env, NapiAVSession* napiSession, napi_value callback)
1843 {
1844 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1845 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1846 "NapiAVSessionCallback object is nullptr");
1847 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_REWIND, callback);
1848 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1849 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_REWIND)) {
1850 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1851 "NapiAVSession object is nullptr");
1852 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_REWIND);
1853 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1854 }
1855 return napi_ok;
1856 }
1857
OffSeek(napi_env env,NapiAVSession * napiSession,napi_value callback)1858 napi_status NapiAVSession::OffSeek(napi_env env, NapiAVSession* napiSession, napi_value callback)
1859 {
1860 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1861 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1862 "NapiAVSessionCallback object is nullptr");
1863 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SEEK, callback);
1864 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1865 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SEEK)) {
1866 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1867 "NapiAVSession object is nullptr");
1868 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SEEK);
1869 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1870 }
1871 return napi_ok;
1872 }
1873
OffSetSpeed(napi_env env,NapiAVSession * napiSession,napi_value callback)1874 napi_status NapiAVSession::OffSetSpeed(napi_env env, NapiAVSession* napiSession, napi_value callback)
1875 {
1876 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1877 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1878 "NapiAVSessionCallback object is nullptr");
1879 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SET_SPEED, callback);
1880 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1881 if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_SPEED)) {
1882 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1883 "NapiAVSession_session is nullptr");
1884 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_SPEED);
1885 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1886 }
1887 return napi_ok;
1888 }
1889
OffSetLoopMode(napi_env env,NapiAVSession * napiSession,napi_value callback)1890 napi_status NapiAVSession::OffSetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
1891 {
1892 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1893 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1894 "NapiAVSessionCallback object is nullptr");
1895 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SET_LOOP_MODE, callback);
1896 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1897 if (napiSession->callback_ &&
1898 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_LOOP_MODE)) {
1899 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1900 "NapiAVSession object is nullptr");
1901 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE);
1902 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1903 }
1904 return napi_ok;
1905 }
1906
OffSetTargetLoopMode(napi_env env,NapiAVSession * napiSession,napi_value callback)1907 napi_status NapiAVSession::OffSetTargetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
1908 {
1909 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1910 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1911 "NapiAVSessionCallback object is nullptr");
1912 auto status = napiSession->callback_->RemoveCallback(env,
1913 NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE, callback);
1914 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1915 if (napiSession->callback_ &&
1916 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE)) {
1917 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1918 "NapiAVSession object is nullptr");
1919 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE);
1920 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1921 }
1922 return napi_ok;
1923 }
1924
OffToggleFavorite(napi_env env,NapiAVSession * napiSession,napi_value callback)1925 napi_status NapiAVSession::OffToggleFavorite(napi_env env, NapiAVSession* napiSession, napi_value callback)
1926 {
1927 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1928 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1929 "NapiAVSessionCallback object is nullptr");
1930 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE, callback);
1931 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1932 if (napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE)) {
1933 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1934 "NapiAVSession object is nullptr");
1935 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE);
1936 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1937 }
1938 return napi_ok;
1939 }
1940
OffMediaKeyEvent(napi_env env,NapiAVSession * napiSession,napi_value callback)1941 napi_status NapiAVSession::OffMediaKeyEvent(napi_env env, NapiAVSession* napiSession, napi_value callback)
1942 {
1943 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1944 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1945 "NapiAVSessionCallback object is nullptr");
1946 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT, callback);
1947 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
1948 if (napiSession->callback_ &&
1949 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT)) {
1950 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
1951 "NapiAVSession object is nullptr");
1952 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT);
1953 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
1954 }
1955 return napi_ok;
1956 }
1957
OffCustomData(napi_env env,NapiAVSession * napiSession,napi_value callback)1958 napi_status NapiAVSession::OffCustomData(napi_env env, NapiAVSession* napiSession, napi_value callback)
1959 {
1960 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1961 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1962 "NapiAVSessionCallback object is nullptr");
1963 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_CUSTOM_DATA, callback);
1964 }
1965
OffOutputDeviceChange(napi_env env,NapiAVSession * napiSession,napi_value callback)1966 napi_status NapiAVSession::OffOutputDeviceChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
1967 {
1968 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1969 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1970 "NapiAVSessionCallback object is nullptr");
1971 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_OUTPUT_DEVICE_CHANGE, callback);
1972 }
1973
OffCommonCommand(napi_env env,NapiAVSession * napiSession,napi_value callback)1974 napi_status NapiAVSession::OffCommonCommand(napi_env env, NapiAVSession* napiSession, napi_value callback)
1975 {
1976 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1977 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1978 "NapiAVSessionCallback object is nullptr");
1979 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SEND_COMMON_COMMAND, callback);
1980 }
1981
OffSkipToQueueItem(napi_env env,NapiAVSession * napiSession,napi_value callback)1982 napi_status NapiAVSession::OffSkipToQueueItem(napi_env env, NapiAVSession* napiSession, napi_value callback)
1983 {
1984 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1985 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1986 "NapiAVSessionCallback object is nullptr");
1987 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SKIP_TO_QUEUE_ITEM, callback);
1988 }
1989
OffAVCallAnswer(napi_env env,NapiAVSession * napiSession,napi_value callback)1990 napi_status NapiAVSession::OffAVCallAnswer(napi_env env, NapiAVSession* napiSession, napi_value callback)
1991 {
1992 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
1993 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
1994 "NapiAVSessionCallback object is nullptr");
1995 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_ANSWER, callback);
1996 }
1997
OffAVCallHangUp(napi_env env,NapiAVSession * napiSession,napi_value callback)1998 napi_status NapiAVSession::OffAVCallHangUp(napi_env env, NapiAVSession* napiSession, napi_value callback)
1999 {
2000 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
2001 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
2002 "NapiAVSessionCallback object is nullptr");
2003 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_HANG_UP, callback);
2004 }
2005
OffAVCallToggleCallMute(napi_env env,NapiAVSession * napiSession,napi_value callback)2006 napi_status NapiAVSession::OffAVCallToggleCallMute(napi_env env, NapiAVSession* napiSession, napi_value callback)
2007 {
2008 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
2009 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
2010 "NapiAVSessionCallback object is nullptr");
2011 return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_TOGGLE_CALL_MUTE, callback);
2012 }
2013
OffPlayFromAssetId(napi_env env,NapiAVSession * napiSession,napi_value callback)2014 napi_status NapiAVSession::OffPlayFromAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
2015 {
2016 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
2017 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
2018 "NapiAVSessionCallback object is nullptr");
2019 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID, callback);
2020 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
2021
2022 if (napiSession->callback_ &&
2023 napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID)) {
2024 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
2025 "NapiAVSession object is nullptr");
2026 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID);
2027 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
2028 }
2029 return napi_ok;
2030 }
2031
OffPlayWithAssetId(napi_env env,NapiAVSession * napiSession,napi_value callback)2032 napi_status NapiAVSession::OffPlayWithAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
2033 {
2034 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
2035 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
2036 "NapiAVSessionCallback object is nullptr");
2037 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID, callback);
2038 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
2039
2040 if (napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID)) {
2041 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
2042 "NapiAVSession object is nullptr");
2043 int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID);
2044 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
2045 }
2046 return napi_ok;
2047 }
2048
OffCastDisplayChange(napi_env env,NapiAVSession * napiSession,napi_value callback)2049 napi_status NapiAVSession::OffCastDisplayChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
2050 {
2051 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
2052 CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
2053 CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
2054 "NapiAVSessionCallback object is nullptr");
2055 auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_CHANGE, callback);
2056 CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
2057 CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
2058 "NapiAVSession object is nullptr");
2059 napiSession->session_->StopCastDisplayListener();
2060 #else
2061 return napi_generic_failure;
2062 #endif
2063 return napi_ok;
2064 }
2065 }
2066