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 AUDIO_SPATIALIZATION_MANAGER_CALLBACK_NAPI_H 16 #define AUDIO_SPATIALIZATION_MANAGER_CALLBACK_NAPI_H 17 18 #include <uv.h> 19 #include "napi/native_api.h" 20 #include "napi/native_node_api.h" 21 #include "napi_async_work.h" 22 #include "napi_audio_manager.h" 23 #include "audio_system_manager.h" 24 #include "audio_spatialization_manager.h" 25 26 namespace OHOS { 27 namespace AudioStandard { 28 const std::string SPATIALIZATION_ENABLED_CHANGE_CALLBACK_NAME = "spatializationEnabledChange"; 29 const std::string SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICES_CALLBACK_NAME = 30 "spatializationEnabledChangeForAnyDevice"; 31 const std::string SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE_CALLBACK_NAME = 32 "spatializationEnabledChangeForCurrentDevice"; 33 const std::string HEAD_TRACKING_ENABLED_CHANGE_CALLBACK_NAME = "headTrackingEnabledChange"; 34 const std::string HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICES_CALLBACK_NAME = 35 "headTrackingEnabledChangeForAnyDevice"; 36 class NapiAudioSpatializationEnabledChangeCallback : public AudioSpatializationEnabledChangeCallback { 37 public: 38 explicit NapiAudioSpatializationEnabledChangeCallback(napi_env env); 39 virtual ~NapiAudioSpatializationEnabledChangeCallback(); 40 void SaveSpatializationEnabledChangeCallbackReference(napi_value args, const std::string &cbName); 41 void RemoveSpatializationEnabledChangeCallbackReference(napi_env env, napi_value args, const std::string &cbName); 42 void RemoveAllSpatializationEnabledChangeCallbackReference(const std::string &cbName); 43 int32_t GetSpatializationEnabledChangeCbListSize(const std::string &cbName); 44 void OnSpatializationEnabledChange(const bool &enabled) override; 45 void OnSpatializationEnabledChangeForAnyDevice(const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor, 46 const bool &enabled) override; 47 void CreateSpatEnableTsfn(napi_env env); 48 bool GetSpatEnableTsfnFlag(); 49 50 private: 51 struct AudioSpatializationEnabledJsCallback { 52 std::shared_ptr<AutoRef> callback = nullptr; 53 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor; 54 std::string callbackName = "unknown"; 55 bool enabled; 56 }; 57 58 void OnJsCallbackSpatializationEnabled(std::unique_ptr<AudioSpatializationEnabledJsCallback> &jsCb); 59 static void SafeJsCallbackSpatializationEnabledWork(napi_env env, napi_value js_cb, void *context, void *data); 60 static void SpatializationEnabledTsfnFinalize(napi_env env, void *data, void *hint); 61 62 std::mutex mutex_; 63 napi_env env_ = nullptr; 64 std::list<std::shared_ptr<AutoRef>> spatializationEnabledChangeCbList_; 65 std::list<std::shared_ptr<AutoRef>> spatializationEnabledChangeCbForAnyDeviceList_; 66 std::list<std::shared_ptr<AutoRef>> spatializationEnabledChangeCbForCurrentDeviceList_; 67 static bool onSpatializationEnabledChangeFlag_; 68 bool regAmSpatEnable_ = false; 69 napi_threadsafe_function amSpatEnableTsfn_ = nullptr; 70 }; 71 72 class NapiAudioCurrentSpatializationEnabledChangeCallback : 73 public AudioSpatializationEnabledChangeForCurrentDeviceCallback { 74 public: 75 explicit NapiAudioCurrentSpatializationEnabledChangeCallback(napi_env env); 76 virtual ~NapiAudioCurrentSpatializationEnabledChangeCallback(); 77 void SaveCurrentSpatializationEnabledChangeCallbackReference(napi_value args, const std::string &cbName); 78 void RemoveCurrentSpatializationEnabledChangeCallbackReference(napi_env env, napi_value args, 79 const std::string &cbName); 80 void RemoveAllCurrentSpatializationEnabledChangeCallbackReference(const std::string &cbName); 81 int32_t GetCurrentSpatializationEnabledChangeCbListSize(const std::string &cbName); 82 void OnSpatializationEnabledChangeForCurrentDevice(const bool &enabled) override; 83 void CreateCurrentSpatEnableForCurrentDeviceTsfn(napi_env env); 84 bool GetCurrentSpatEnableForCurrentDeviceTsfnFlag(); 85 86 private: 87 struct AudioSpatializationEnabledForCurrentDeviceJsCallback { 88 std::shared_ptr<AutoRef> callback = nullptr; 89 std::string callbackName = "unknown"; 90 bool enabled; 91 }; 92 93 void OnJsCallbackSpatializationEnabledForCurrentDevice( 94 std::unique_ptr<AudioSpatializationEnabledForCurrentDeviceJsCallback> &jsCb); 95 static void SafeJsCallbackSpatializationEnabledForCurrentDeviceWork(napi_env env, napi_value js_cb, void *context, 96 void *data); 97 static void SpatializationEnabledForCurrentDeviceTsfnFinalize(napi_env env, void *data, void *hint); 98 99 std::mutex mutex_; 100 napi_env env_ = nullptr; 101 std::list<std::shared_ptr<AutoRef>> spatializationEnabledChangeCbForCurrentDeviceList_; 102 bool regAmSpatEnableForCurrentDevice_ = false; 103 napi_threadsafe_function amSpatEnableForCurrentDeviceTsfn_ = nullptr; 104 }; 105 106 class NapiAudioHeadTrackingEnabledChangeCallback : public AudioHeadTrackingEnabledChangeCallback { 107 public: 108 explicit NapiAudioHeadTrackingEnabledChangeCallback(napi_env env); 109 virtual ~NapiAudioHeadTrackingEnabledChangeCallback(); 110 void SaveHeadTrackingEnabledChangeCallbackReference(napi_value args, const std::string &cbName); 111 void RemoveHeadTrackingEnabledChangeCallbackReference(napi_env env, napi_value args, const std::string &cbName); 112 void RemoveAllHeadTrackingEnabledChangeCallbackReference(const std::string &cbName); 113 int32_t GetHeadTrackingEnabledChangeCbListSize(const std::string &cbName); 114 void OnHeadTrackingEnabledChange(const bool &enabled) override; 115 void OnHeadTrackingEnabledChangeForAnyDevice(const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor, 116 const bool &enabled) override; 117 void CreateHeadTrackingTsfn(napi_env env); 118 bool GetHeadTrackingTsfnFlag(); 119 120 private: 121 struct AudioHeadTrackingEnabledJsCallback { 122 std::shared_ptr<AutoRef> callback = nullptr; 123 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor; 124 std::string callbackName = "unknown"; 125 bool enabled; 126 }; 127 128 void OnJsCallbackHeadTrackingEnabled(std::unique_ptr<AudioHeadTrackingEnabledJsCallback> &jsCb); 129 static void SafeJsCallbackHeadTrackingEnabledWork(napi_env env, napi_value js_cb, void *context, void *data); 130 static void HeadTrackingEnabledTsfnFinalize(napi_env env, void *data, void *hint); 131 132 std::mutex mutex_; 133 napi_env env_ = nullptr; 134 std::list<std::shared_ptr<AutoRef>> headTrackingEnabledChangeCbList_; 135 std::list<std::shared_ptr<AutoRef>> headTrackingEnabledChangeCbForAnyDeviceList_; 136 static bool onHeadTrackingEnabledChangeFlag_; 137 bool regAmHeadTrkTsfn_ = false; 138 napi_threadsafe_function amHeadTrkTsfn_ = nullptr; 139 }; 140 } // namespace AudioStandard 141 } // namespace OHOS 142 #endif /* AUDIO_SPATIALIZATION_MANAGER_CALLBACK_NAPI_H */