1 /*
2 * Copyright (c) 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 #ifndef LOG_TAG
16 #define LOG_TAG "NapiAudioSessionDeviceCallback"
17 #endif
18 #include <thread>
19 #include "js_native_api.h"
20 #include "napi_audio_session_device_callback.h"
21 #include "napi_param_utils.h"
22 #include "napi/native_api.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
NapiAudioSessionDeviceCallback(napi_env env)26 NapiAudioSessionDeviceCallback::NapiAudioSessionDeviceCallback(napi_env env)
27 :env_(env)
28 {
29 AUDIO_DEBUG_LOG("NapiAudioSessionDeviceCallback::Constructor");
30 }
31
~NapiAudioSessionDeviceCallback()32 NapiAudioSessionDeviceCallback::~NapiAudioSessionDeviceCallback()
33 {
34 if (regAmSessionDeviceChgTsfn_) {
35 napi_release_threadsafe_function(amSessionDeviceChgTsfn_, napi_tsfn_abort);
36 }
37 AUDIO_DEBUG_LOG("NapiAudioSessionDeviceCallback::Destructor");
38 }
39
OnAudioSessionCurrentDeviceChanged(const CurrentOutputDeviceChangedEvent & deviceEvent)40 void NapiAudioSessionDeviceCallback::OnAudioSessionCurrentDeviceChanged(
41 const CurrentOutputDeviceChangedEvent &deviceEvent)
42 {
43 AUDIO_INFO_LOG("OnAudioSessionCurrentDeviceChanged is called changeReason=%{public}d, "
44 "recommendedAction=%{public}d", deviceEvent.changeReason, deviceEvent.recommendedAction);
45 CHECK_AND_RETURN_LOG(audioSessionDeviceJsCallback_ != nullptr,
46 "OnAudioSessionCurrentDeviceChanged:No JS callback registered return");
47 std::unique_ptr<AudioSessionDeviceJsCallback> cb = std::make_unique<AudioSessionDeviceJsCallback>();
48 CHECK_AND_RETURN_LOG(cb != nullptr, "No memory");
49 cb->callback = audioSessionDeviceJsCallback_;
50 cb->callbackName = AUDIO_SESSION_DEVICE_CALLBACK_NAME;
51 cb->audioSessionDeviceEvent.devices = deviceEvent.devices;
52 cb->audioSessionDeviceEvent.changeReason = deviceEvent.changeReason;
53 cb->audioSessionDeviceEvent.recommendedAction = deviceEvent.recommendedAction;
54
55 return OnJsCallbackAudioSessionDevice(cb);
56 }
57
SaveCallbackReference(napi_value args)58 void NapiAudioSessionDeviceCallback::SaveCallbackReference(napi_value args)
59 {
60 std::lock_guard<std::mutex> lock(mutex_);
61 napi_ref callback = nullptr;
62 const int32_t refCount = 1;
63 napi_status status = napi_create_reference(env_, args, refCount, &callback);
64 CHECK_AND_RETURN_LOG(status == napi_ok && callback != nullptr,
65 "NapiAudioSessionDeviceCallback: creating reference for callback fail");
66 callback_ = callback;
67 std::shared_ptr<AutoRef> cb = std::make_shared<AutoRef>(env_, callback);
68 audioSessionDeviceJsCallback_ = cb;
69 }
70
CreateAudioSessionDeviceTsfn(napi_env env)71 void NapiAudioSessionDeviceCallback::CreateAudioSessionDeviceTsfn(napi_env env)
72 {
73 regAmSessionDeviceChgTsfn_ = true;
74 std::string callbackName = "currentOutputDeviceChanged";
75 napi_value cbName;
76 napi_create_string_utf8(env, callbackName.c_str(), callbackName.length(), &cbName);
77 napi_create_threadsafe_function(env, nullptr, nullptr, cbName, 0, 1, nullptr, AudioSessionDeviceTsfnFinalize,
78 nullptr, SafeJsCallbackAudioSessionDeviceWork, &amSessionDeviceChgTsfn_);
79 }
80
GetAudioSessionDeviceTsfnFlag() const81 bool NapiAudioSessionDeviceCallback::GetAudioSessionDeviceTsfnFlag() const
82 {
83 return regAmSessionDeviceChgTsfn_;
84 }
85
SafeJsCallbackAudioSessionDeviceWork(napi_env env,napi_value js_cb,void * context,void * data)86 void NapiAudioSessionDeviceCallback::SafeJsCallbackAudioSessionDeviceWork(
87 napi_env env, napi_value js_cb, void *context, void *data)
88 {
89 AudioSessionDeviceJsCallback *event = reinterpret_cast<AudioSessionDeviceJsCallback *>(data);
90 CHECK_AND_RETURN_LOG((event != nullptr) && (event->callback != nullptr),
91 "OnJsCallbackAudioSessionDevice: no memory");
92
93 std::string request = event->callbackName;
94 napi_ref callback = event->callback->cb_;
95 napi_handle_scope scope = nullptr;
96 napi_open_handle_scope(env, &scope);
97 CHECK_AND_RETURN_LOG(scope != nullptr, "scope is nullptr");
98 AUDIO_INFO_LOG("SafeJsCallbackAudioSessionDeviceWork: safe js callback working.");
99 do {
100 napi_value jsCallback = nullptr;
101 napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
102 CHECK_AND_BREAK_LOG(nstatus == napi_ok && jsCallback != nullptr, "%{public}s get reference value fail",
103 request.c_str());
104
105 napi_value args[ARGS_ONE] = { nullptr };
106 napi_create_object(env, &args[PARAM0]);
107 napi_value deviceObj = nullptr;
108 nstatus = NapiParamUtils::SetDeviceDescriptors(env, event->audioSessionDeviceEvent.devices, deviceObj);
109 CHECK_AND_BREAK_LOG(nstatus == napi_ok && deviceObj != nullptr, "fail to convert to jsobj");
110 napi_set_named_property(env, args[PARAM0], "devices", deviceObj);
111 nstatus = NapiParamUtils::SetValueInt32(env, "changeReason",
112 static_cast<int32_t>(event->audioSessionDeviceEvent.changeReason), args[PARAM0]);
113 CHECK_AND_BREAK_LOG(nstatus == napi_ok && args[PARAM0] != nullptr,
114 "%{public}s fail to changeReason callback", request.c_str());
115 nstatus = NapiParamUtils::SetValueInt32(env, "recommendedAction",
116 static_cast<int32_t>(event->audioSessionDeviceEvent.recommendedAction), args[PARAM0]);
117 CHECK_AND_BREAK_LOG(nstatus == napi_ok && args[PARAM0] != nullptr,
118 "%{public}s fail to recommendedAction callback", request.c_str());
119
120 const size_t argCount = ARGS_ONE;
121 napi_value result = nullptr;
122 nstatus = napi_call_function(env, nullptr, jsCallback, argCount, args, &result);
123 CHECK_AND_BREAK_LOG(nstatus == napi_ok, "%{public}s fail to call SetaudioSessionDevice callback",
124 request.c_str());
125 } while (0);
126 napi_close_handle_scope(env, scope);
127 }
128
AudioSessionDeviceTsfnFinalize(napi_env env,void * data,void * hint)129 void NapiAudioSessionDeviceCallback::AudioSessionDeviceTsfnFinalize(napi_env env, void *data, void *hint)
130 {
131 AUDIO_INFO_LOG("AudioSessionDeviceTsfnFinalize: safe thread resource release.");
132 }
133
OnJsCallbackAudioSessionDevice(std::unique_ptr<AudioSessionDeviceJsCallback> & jsCb)134 void NapiAudioSessionDeviceCallback::OnJsCallbackAudioSessionDevice(
135 std::unique_ptr<AudioSessionDeviceJsCallback> &jsCb)
136 {
137 if (jsCb.get() == nullptr) {
138 AUDIO_ERR_LOG("NapiAudioSessionDeviceCallback: OnJsCallbackAudioSessionDevice: jsCb.get() is null");
139 return;
140 }
141
142 AudioSessionDeviceJsCallback *event = jsCb.release();
143 CHECK_AND_RETURN_LOG((event != nullptr) && (event->callback != nullptr), "event is nullptr.");
144
145 napi_acquire_threadsafe_function(amSessionDeviceChgTsfn_);
146 napi_call_threadsafe_function(amSessionDeviceChgTsfn_, event, napi_tsfn_blocking);
147 }
148
ContainSameJsCallback(napi_value args)149 bool NapiAudioSessionDeviceCallback::ContainSameJsCallback(napi_value args)
150 {
151 bool isEquals = false;
152 napi_value copyValue = nullptr;
153
154 napi_get_reference_value(env_, callback_, ©Value);
155 CHECK_AND_RETURN_RET_LOG(args != nullptr, false, "args is nullptr");
156 CHECK_AND_RETURN_RET_LOG(napi_strict_equals(env_, copyValue, args, &isEquals) == napi_ok, false,
157 "Get napi_strict_equals failed");
158
159 return isEquals;
160 }
161 } // namespace AudioStandard
162 } // namespace OHOS