1 /*
2 * Copyright (c) 2022 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 "napi_avcontroller_callback.h"
17 #include "avsession_log.h"
18 #include "avsession_trace.h"
19 #include "napi_control_command.h"
20 #include "napi_meta_data.h"
21 #include "napi_playback_state.h"
22 #include "napi_utils.h"
23
24 namespace OHOS::AVSession {
NapiAVControllerCallback()25 NapiAVControllerCallback::NapiAVControllerCallback()
26 {
27 SLOGI("construct");
28 }
29
~NapiAVControllerCallback()30 NapiAVControllerCallback::~NapiAVControllerCallback()
31 {
32 SLOGI("destroy");
33 }
34
HandleEvent(int32_t event)35 void NapiAVControllerCallback::HandleEvent(int32_t event)
36 {
37 std::lock_guard<std::mutex> lockGuard(lock_);
38 if (callbacks_[event].empty()) {
39 SLOGE("not register callback event=%{public}d", event);
40 return;
41 }
42 for (auto ref = callbacks_[event].begin(); ref != callbacks_[event].end(); ++ref) {
43 asyncCallback_->Call(*ref);
44 }
45 }
46
47 template<typename T>
HandleEvent(int32_t event,const T & param)48 void NapiAVControllerCallback::HandleEvent(int32_t event, const T& param)
49 {
50 std::lock_guard<std::mutex> lockGuard(lock_);
51 if (callbacks_[event].empty()) {
52 SLOGE("not register callback event=%{public}d", event);
53 return;
54 }
55 for (auto ref = callbacks_[event].begin(); ref != callbacks_[event].end(); ++ref) {
56 asyncCallback_->Call(*ref, [param](napi_env env, int& argc, napi_value *argv) {
57 argc = NapiUtils::ARGC_ONE;
58 auto status = NapiUtils::SetValue(env, param, *argv);
59 CHECK_RETURN_VOID(status == napi_ok, "ControllerCallback SetValue invalid");
60 });
61 }
62 }
63
OnSessionDestroy()64 void NapiAVControllerCallback::OnSessionDestroy()
65 {
66 HandleEvent(EVENT_SESSION_DESTROY);
67 }
68
OnPlaybackStateChange(const AVPlaybackState & state)69 void NapiAVControllerCallback::OnPlaybackStateChange(const AVPlaybackState& state)
70 {
71 AVSESSION_TRACE_SYNC_START("NapiAVControllerCallback::OnPlaybackStateChange");
72 HandleEvent(EVENT_PLAYBACK_STATE_CHANGE, state);
73 }
74
OnMetaDataChange(const AVMetaData & data)75 void NapiAVControllerCallback::OnMetaDataChange(const AVMetaData& data)
76 {
77 AVSESSION_TRACE_SYNC_START("NapiAVControllerCallback::OnMetaDataChange");
78 HandleEvent(EVENT_META_DATA_CHANGE, data);
79 }
80
OnActiveStateChange(bool isActive)81 void NapiAVControllerCallback::OnActiveStateChange(bool isActive)
82 {
83 HandleEvent(EVENT_ACTIVE_STATE_CHANGE, isActive);
84 }
85
OnValidCommandChange(const std::vector<int32_t> & cmds)86 void NapiAVControllerCallback::OnValidCommandChange(const std::vector<int32_t>& cmds)
87 {
88 std::vector<std::string> stringCmds = NapiControlCommand::ConvertCommands(cmds);
89 HandleEvent(EVENT_VALID_COMMAND_CHANGE, stringCmds);
90 }
91
OnOutputDeviceChange(const OutputDeviceInfo & info)92 void NapiAVControllerCallback::OnOutputDeviceChange(const OutputDeviceInfo& info)
93 {
94 HandleEvent(EVENT_OUTPUT_DEVICE_CHANGE, info);
95 }
96
AddCallback(napi_env env,int32_t event,napi_value callback)97 napi_status NapiAVControllerCallback::AddCallback(napi_env env, int32_t event, napi_value callback)
98 {
99 std::lock_guard<std::mutex> lockGuard(lock_);
100 napi_ref ref = nullptr;
101
102 CHECK_AND_RETURN_RET_LOG(napi_ok == NapiUtils::GetRefByCallback(env, callbacks_[event], callback, ref),
103 napi_generic_failure, "get callback reference failed");
104 CHECK_AND_RETURN_RET_LOG(ref == nullptr, napi_ok, "callback has been registered");
105 napi_status status = napi_create_reference(env, callback, NapiUtils::ARGC_ONE, &ref);
106 if (status != napi_ok) {
107 SLOGE("napi_create_reference failed");
108 return status;
109 }
110 if (asyncCallback_ == nullptr) {
111 asyncCallback_ = std::make_shared<NapiAsyncCallback>(env);
112 if (asyncCallback_ == nullptr) {
113 SLOGE("no memory");
114 return napi_generic_failure;
115 }
116 }
117 callbacks_[event].push_back(ref);
118 return napi_ok;
119 }
120
RemoveCallback(napi_env env,int32_t event,napi_value callback)121 napi_status NapiAVControllerCallback::RemoveCallback(napi_env env, int32_t event, napi_value callback)
122 {
123 std::lock_guard<std::mutex> lockGuard(lock_);
124 if (callback == nullptr) {
125 for (auto callbackRef = callbacks_[event].begin(); callbackRef != callbacks_[event].end(); ++callbackRef) {
126 napi_status ret = napi_delete_reference(env, *callbackRef);
127 CHECK_AND_RETURN_RET_LOG(ret == napi_ok, ret, "delete callback reference failed");
128 }
129 callbacks_[event].clear();
130 return napi_ok;
131 }
132 napi_ref ref = nullptr;
133 CHECK_AND_RETURN_RET_LOG(napi_ok == NapiUtils::GetRefByCallback(env, callbacks_[event], callback, ref),
134 napi_generic_failure, "get callback reference failed");
135 CHECK_AND_RETURN_RET_LOG(ref != nullptr, napi_ok, "callback has been remove");
136 callbacks_[event].remove(ref);
137 return napi_delete_reference(env, ref);
138 }
139 }