1 /*
2 * Copyright (c) 2023 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 "NapiAudioManagerMicStateChangeCallback"
17 #endif
18
19 #include "js_native_api.h"
20 #include "napi_audio_micstatechange_callback.h"
21 #include "napi_param_utils.h"
22 #include "napi_audio_error.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
NapiAudioManagerMicStateChangeCallback(napi_env env)26 NapiAudioManagerMicStateChangeCallback::NapiAudioManagerMicStateChangeCallback(napi_env env)
27 : env_(env)
28 {
29 AUDIO_DEBUG_LOG("NapiAudioManagerMicStateChangeCallback: instance create");
30 }
31
~NapiAudioManagerMicStateChangeCallback()32 NapiAudioManagerMicStateChangeCallback::~NapiAudioManagerMicStateChangeCallback()
33 {
34 if (regAmMicStateChgTsfn_) {
35 napi_release_threadsafe_function(amMicStateChgTsfn_, napi_tsfn_abort);
36 }
37 AUDIO_DEBUG_LOG("NapiAudioManagerMicStateChangeCallback: instance destroy");
38 }
39
SaveCallbackReference(const std::string & callbackName,napi_value args)40 void NapiAudioManagerMicStateChangeCallback::SaveCallbackReference(const std::string &callbackName, napi_value args)
41 {
42 std::lock_guard<std::mutex> lock(mutex_);
43 napi_ref callback = nullptr;
44 const int32_t refCount = ARGS_ONE;
45 napi_status status = napi_create_reference(env_, args, refCount, &callback);
46 CHECK_AND_RETURN_LOG(status == napi_ok && callback != nullptr,
47 "NapiAudioManagerMicStateChangeCallback: creating reference for callback fail");
48 std::shared_ptr<AutoRef> cb = std::make_shared<AutoRef>(env_, callback);
49 CHECK_AND_RETURN_LOG(callbackName == MIC_STATE_CHANGE_CALLBACK_NAME,
50 "NapiAudioManagerMicStateChangeCallback: Unknown callback type: %{public}s", callbackName.c_str());
51 micStateChangeCallback_ = cb;
52 }
53
CreateManagerMicStateChangeTsfn(napi_env env)54 void NapiAudioManagerMicStateChangeCallback::CreateManagerMicStateChangeTsfn(napi_env env)
55 {
56 regAmMicStateChgTsfn_ = true;
57 napi_value cbName;
58 std::string callbackName = "ManagerMicStateChange";
59 napi_create_string_utf8(env, callbackName.c_str(), callbackName.length(), &cbName);
60 napi_create_threadsafe_function(env, nullptr, nullptr, cbName, 0, 1, nullptr,
61 MicStateChangeTsfnFinalize, nullptr, SafeJsCallbackMicStateChangeWork, &amMicStateChgTsfn_);
62 }
63
GetManagerMicStateChangeTsfnFlag()64 bool NapiAudioManagerMicStateChangeCallback::GetManagerMicStateChangeTsfnFlag()
65 {
66 return regAmMicStateChgTsfn_;
67 }
68
RemoveCallbackReference(const napi_value args)69 void NapiAudioManagerMicStateChangeCallback::RemoveCallbackReference(const napi_value args)
70 {
71 if (!IsSameCallback(args)) {
72 return;
73 }
74 std::lock_guard<std::mutex> lock(mutex_);
75 napi_delete_reference(env_, micStateChangeCallback_->cb_);
76 micStateChangeCallback_->cb_ = nullptr;
77 micStateChangeCallback_ = nullptr;
78 AUDIO_INFO_LOG("Remove callback reference successful.");
79 }
80
IsSameCallback(const napi_value args)81 bool NapiAudioManagerMicStateChangeCallback::IsSameCallback(const napi_value args)
82 {
83 std::lock_guard<std::mutex> lock(mutex_);
84 if (micStateChangeCallback_ == nullptr) {
85 return false;
86 }
87 if (args == nullptr) {
88 return true;
89 }
90 napi_value micStateChangeCallback = nullptr;
91 napi_get_reference_value(env_, micStateChangeCallback_->cb_, &micStateChangeCallback);
92 bool isEquals = false;
93 CHECK_AND_RETURN_RET_LOG(napi_strict_equals(env_, args, micStateChangeCallback, &isEquals) == napi_ok, false,
94 "get napi_strict_equals failed");
95 return isEquals;
96 }
97
OnMicStateUpdated(const MicStateChangeEvent & micStateChangeEvent)98 void NapiAudioManagerMicStateChangeCallback::OnMicStateUpdated(const MicStateChangeEvent &micStateChangeEvent)
99 {
100 std::lock_guard<std::mutex> lock(mutex_);
101 CHECK_AND_RETURN_LOG(micStateChangeCallback_ != nullptr, "callback not registered by JS client");
102
103 std::unique_ptr<AudioManagerMicStateChangeJsCallback> cb = std::make_unique<AudioManagerMicStateChangeJsCallback>();
104 CHECK_AND_RETURN_LOG(cb != nullptr, "No memory");
105
106 cb->callback = micStateChangeCallback_;
107 cb->callbackName = MIC_STATE_CHANGE_CALLBACK_NAME;
108 cb->micStateChangeEvent = micStateChangeEvent;
109 return OnJsCallbackMicStateChange(cb);
110 }
111
SafeJsCallbackMicStateChangeWork(napi_env env,napi_value js_cb,void * context,void * data)112 void NapiAudioManagerMicStateChangeCallback::SafeJsCallbackMicStateChangeWork(
113 napi_env env, napi_value js_cb, void *context, void *data)
114 {
115 AudioManagerMicStateChangeJsCallback *event = reinterpret_cast<AudioManagerMicStateChangeJsCallback *>(data);
116 CHECK_AND_RETURN_LOG((event != nullptr) && (event->callback != nullptr),
117 "OnJsCallbackMicStateChange: no memory");
118 std::shared_ptr<AudioManagerMicStateChangeJsCallback> safeContext(
119 static_cast<AudioManagerMicStateChangeJsCallback*>(data),
120 [](AudioManagerMicStateChangeJsCallback *ptr) {
121 delete ptr;
122 });
123 std::string request = event->callbackName;
124 napi_ref callback = event->callback->cb_;
125 napi_handle_scope scope = nullptr;
126 napi_open_handle_scope(env, &scope);
127 CHECK_AND_RETURN_LOG(scope != nullptr, "scope is nullptr");
128 AUDIO_INFO_LOG("SafeJsCallbackMicStateChangeWork: safe js callback working.");
129
130 do {
131 napi_value jsCallback = nullptr;
132 napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
133 CHECK_AND_BREAK_LOG(nstatus == napi_ok && jsCallback != nullptr, "%{public}s get reference value fail",
134 request.c_str());
135 napi_value args[ARGS_ONE] = { nullptr };
136 NapiParamUtils::SetValueMicStateChange(env, event->micStateChangeEvent, args[PARAM0]);
137 CHECK_AND_BREAK_LOG(nstatus == napi_ok && args[0] != nullptr,
138 "%{public}s fail to create DeviceChange callback", request.c_str());
139 const size_t argCount = ARGS_ONE;
140 napi_value result = nullptr;
141 nstatus = napi_call_function(env, nullptr, jsCallback, argCount, args, &result);
142 CHECK_AND_BREAK_LOG(nstatus == napi_ok, "%{public}s fail to call DeviceChange callback",
143 request.c_str());
144 } while (0);
145 napi_close_handle_scope(env, scope);
146 }
147
MicStateChangeTsfnFinalize(napi_env env,void * data,void * hint)148 void NapiAudioManagerMicStateChangeCallback::MicStateChangeTsfnFinalize(napi_env env, void *data, void *hint)
149 {
150 AUDIO_INFO_LOG("MicStateChangeTsfnFinalize: safe thread resource release.");
151 }
152
OnJsCallbackMicStateChange(std::unique_ptr<AudioManagerMicStateChangeJsCallback> & jsCb)153 void NapiAudioManagerMicStateChangeCallback::OnJsCallbackMicStateChange(
154 std::unique_ptr<AudioManagerMicStateChangeJsCallback> &jsCb)
155 {
156 if (jsCb.get() == nullptr) {
157 AUDIO_ERR_LOG("OnJsCallbackMicStateChange: jsCb.get() is null");
158 return;
159 }
160 AudioManagerMicStateChangeJsCallback *event = jsCb.release();
161 CHECK_AND_RETURN_LOG((event != nullptr) && (event->callback != nullptr), "event is nullptr.");
162
163 napi_acquire_threadsafe_function(amMicStateChgTsfn_);
164 napi_call_threadsafe_function(amMicStateChgTsfn_, event, napi_tsfn_blocking);
165 }
166 } // namespace AudioStandard
167 } // namespace OHOS