diff --git a/frameworks/taihe/audiocapturer/taihe_audio_capturer.cpp b/frameworks/taihe/audiocapturer/taihe_audio_capturer.cpp index f530068dc8c474e955f5b3eaa7485920f7a13860..45abd470f3ea970ba6541faf98ceba1cec1467c5 100644 --- a/frameworks/taihe/audiocapturer/taihe_audio_capturer.cpp +++ b/frameworks/taihe/audiocapturer/taihe_audio_capturer.cpp @@ -348,6 +348,16 @@ void AudioCapturerImpl::StartSync() CHECK_AND_RETURN_LOG(ret, "StartSync failure!"); } +void AudioCapturerImpl::StartWithCallback() +{ + return this->StartSync(); +} + +void AudioCapturerImpl::StartReturnsPromise() +{ + return this->StartSync(); +} + void AudioCapturerImpl::StopSync() { if (audioCapturer_ == nullptr) { @@ -358,6 +368,16 @@ void AudioCapturerImpl::StopSync() CHECK_AND_RETURN_LOG(ret, "StopSync failure!"); } +void AudioCapturerImpl::StopWithCallback() +{ + return this->StopSync(); +} + +void AudioCapturerImpl::StopReturnsPromise() +{ + return this->StopSync(); +} + void AudioCapturerImpl::ReleaseSync() { if (audioCapturer_ == nullptr) { @@ -368,6 +388,16 @@ void AudioCapturerImpl::ReleaseSync() CHECK_AND_RETURN_LOG(ret, "ReleaseSync failure!"); } +void AudioCapturerImpl::ReleaseWithCallback() +{ + return this->ReleaseSync(); +} + +void AudioCapturerImpl::ReleaseReturnsPromise() +{ + return this->ReleaseSync(); +} + int64_t AudioCapturerImpl::GetBufferSizeSync() { size_t bufferSize = 0; @@ -382,6 +412,16 @@ int64_t AudioCapturerImpl::GetBufferSizeSync() return static_cast(bufferSize); } +int64_t AudioCapturerImpl::GetBufferSizeWithCallback() +{ + return this->GetBufferSizeSync(); +} + +int64_t AudioCapturerImpl::GetBufferSizeReturnsPromise() +{ + return this->GetBufferSizeSync(); +} + AudioCapturerInfo AudioCapturerImpl::GetCapturerInfoSync() { AudioCapturerInfo emptyAudioCapturerInfo { @@ -699,49 +739,56 @@ void AudioCapturerImpl::RegisterPositionCallback(int64_t frame, std::shared_ptr< } } -void AudioCapturerImpl::OnAudioInterrupt(callback_view callback) +void AudioCapturerImpl::OnAudioInterrupt(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterCapturerCallback(cacheCallback, AUDIO_INTERRUPT_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnStateChange(callback_view callback) +void AudioCapturerImpl::OnStateChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterCapturerCallback(cacheCallback, STATE_CHANGE_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnInputDeviceChange(callback_view)> callback) +void AudioCapturerImpl::OnInputDeviceChange(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterAudioCapturerDeviceChangeCallback(cacheCallback, INPUTDEVICE_CHANGE_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnAudioCapturerChange(callback_view callback) +void AudioCapturerImpl::OnAudioCapturerChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterAudioCapturerInfoChangeCallback(cacheCallback, AUDIO_CAPTURER_CHANGE_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnReadData(callback_view)> callback) +void AudioCapturerImpl::OnReadData(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterCapturerReadDataCallback(cacheCallback, READ_DATA_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnPeriodReach(int64_t frame, callback_view callback) +void AudioCapturerImpl::OnPeriodReach(::taihe::string_view type, + int64_t frame, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterPeriodPositionCallback(frame, cacheCallback, PERIOD_REACH_CALLBACK_NAME, this); } -void AudioCapturerImpl::OnMarkReach(int64_t frame, callback_view callback) +void AudioCapturerImpl::OnMarkReach(::taihe::string_view type, + int64_t frame, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterPositionCallback(frame, cacheCallback, MARK_REACH_CALLBACK_NAME, this); } -void AudioCapturerImpl::OffStateChange(optional_view> callback) +void AudioCapturerImpl::OffStateChange(::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -750,7 +797,8 @@ void AudioCapturerImpl::OffStateChange(optional_view> UnregisterCapturerCallback(cacheCallback, STATE_CHANGE_CALLBACK_NAME, this); } -void AudioCapturerImpl::OffAudioInterrupt(optional_view> callback) +void AudioCapturerImpl::OffAudioInterrupt(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -759,7 +807,8 @@ void AudioCapturerImpl::OffAudioInterrupt(optional_view)>> callback) +void AudioCapturerImpl::OffInputDeviceChange(::taihe::string_view type, + optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -768,7 +817,8 @@ void AudioCapturerImpl::OffInputDeviceChange(optional_view> callback) +void AudioCapturerImpl::OffAudioCapturerChange(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -777,7 +827,8 @@ void AudioCapturerImpl::OffAudioCapturerChange(optional_view)>> callback) +void AudioCapturerImpl::OffReadData(::taihe::string_view type, + optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -786,7 +837,7 @@ void AudioCapturerImpl::OffReadData(optional_view> callback) +void AudioCapturerImpl::OffPeriodReach(::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -795,7 +846,7 @@ void AudioCapturerImpl::OffPeriodReach(optional_view> ca UnregisterCapturerPeriodPositionCallback(cacheCallback, PERIOD_REACH_CALLBACK_NAME, this); } -void AudioCapturerImpl::OffMarkReach(optional_view> callback) +void AudioCapturerImpl::OffMarkReach(::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -817,4 +868,6 @@ AudioCapturer CreateAudioCapturerSync(AudioCapturerOptions const &options) } } // namespace ANI::Audio -TH_EXPORT_CPP_API_CreateAudioCapturerSync(ANI::Audio::CreateAudioCapturerSync); \ No newline at end of file +TH_EXPORT_CPP_API_CreateAudioCapturerSync(ANI::Audio::CreateAudioCapturerSync); +TH_EXPORT_CPP_API_CreateAudioCapturerWithCallback(ANI::Audio::CreateAudioCapturerSync); +TH_EXPORT_CPP_API_CreateAudioCapturerReturnsPromise(ANI::Audio::CreateAudioCapturerSync); \ No newline at end of file diff --git a/frameworks/taihe/audiocapturer/taihe_audio_capturer.h b/frameworks/taihe/audiocapturer/taihe_audio_capturer.h index 679a8a66f27c932ec6b925089ad84e85600c5af5..7d70338fc8803786e06e563f51b59c09fd72040f 100644 --- a/frameworks/taihe/audiocapturer/taihe_audio_capturer.h +++ b/frameworks/taihe/audiocapturer/taihe_audio_capturer.h @@ -52,9 +52,17 @@ public: AudioState GetState(); void StartSync(); + void StartWithCallback(); + void StartReturnsPromise(); void StopSync(); + void StopWithCallback(); + void StopReturnsPromise(); void ReleaseSync(); + void ReleaseWithCallback(); + void ReleaseReturnsPromise(); int64_t GetBufferSizeSync(); + int64_t GetBufferSizeWithCallback(); + int64_t GetBufferSizeReturnsPromise(); AudioCapturerInfo GetCapturerInfoSync(); AudioStreamInfo GetStreamInfoSync(); int64_t GetAudioStreamIdSync(); @@ -64,20 +72,28 @@ public: taihe::array GetCurrentInputDevices(); AudioCapturerChangeInfo GetCurrentAudioCapturerChangeInfo(); - void OnAudioInterrupt(callback_view callback); - void OnStateChange(callback_view callback); - void OnInputDeviceChange(callback_view)> callback); - void OnAudioCapturerChange(callback_view callback); - void OnReadData(callback_view)> callback); - void OnPeriodReach(int64_t frame, callback_view callback); - void OnMarkReach(int64_t frame, callback_view callback); - void OffStateChange(optional_view> callback); - void OffAudioInterrupt(optional_view> callback); - void OffInputDeviceChange(optional_view)>> callback); - void OffAudioCapturerChange(optional_view> callback); - void OffReadData(optional_view)>> callback); - void OffPeriodReach(optional_view> callback); - void OffMarkReach(optional_view> callback); + void OnAudioInterrupt(::taihe::string_view type, + callback_view callback); + void OnStateChange(::taihe::string_view type, + callback_view callback); + void OnInputDeviceChange(::taihe::string_view type, + callback_view)> callback); + void OnAudioCapturerChange(::taihe::string_view type, + callback_view callback); + void OnReadData(::taihe::string_view type, callback_view)> callback); + void OnPeriodReach(::taihe::string_view type, int64_t frame, callback_view callback); + void OnMarkReach(::taihe::string_view type, int64_t frame, callback_view callback); + void OffStateChange(::taihe::string_view type, optional_view> callback); + void OffAudioInterrupt(::taihe::string_view type, + optional_view> callback); + void OffInputDeviceChange(::taihe::string_view type, + optional_view)>> callback); + void OffAudioCapturerChange(::taihe::string_view type, + optional_view> callback); + void OffReadData(::taihe::string_view type, + optional_view)>> callback); + void OffPeriodReach(::taihe::string_view type, optional_view> callback); + void OffMarkReach(::taihe::string_view type, optional_view> callback); private: static void RegisterCapturerCallback(std::shared_ptr &callback, diff --git a/frameworks/taihe/audiomanager/taihe_audio_routing_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_routing_manager.cpp index 1168186bb68982e01e702d0756e8112f43d3d519..098fba0fb2b4d6f7ca23c4ccf6da59c8f1b99d4c 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_routing_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_routing_manager.cpp @@ -185,6 +185,18 @@ array AudioRoutingManagerImpl::GetPreferredOutputDeviceFo return TaiheParamUtils::SetDeviceDescriptors(outDeviceDescriptors); } +array AudioRoutingManagerImpl::GetPreferOutputDeviceForRendererInfoWithCallback( + AudioRendererInfo const &rendererInfo) +{ + return this->GetPreferredOutputDeviceForRendererInfoSync(rendererInfo); +} + +array AudioRoutingManagerImpl::GetPreferOutputDeviceForRendererInfoReturnsPromise( + AudioRendererInfo const &rendererInfo) +{ + return this->GetPreferredOutputDeviceForRendererInfoSync(rendererInfo); +} + array AudioRoutingManagerImpl::GetPreferredInputDeviceForCapturerInfoSync( AudioCapturerInfo const &capturerInfo) { @@ -211,6 +223,18 @@ array AudioRoutingManagerImpl::GetPreferredInputDeviceFor return TaiheParamUtils::SetDeviceDescriptors(inDeviceDescriptors); } +array AudioRoutingManagerImpl::GetPreferredInputDeviceForCapturerInfoWithCallback( + AudioCapturerInfo const &capturerInfo) +{ + return this->GetPreferredInputDeviceForCapturerInfoSync(capturerInfo); +} + +array AudioRoutingManagerImpl::GetPreferredInputDeviceForCapturerInfoReturnsPromise( + AudioCapturerInfo const &capturerInfo) +{ + return this->GetPreferredInputDeviceForCapturerInfoSync(capturerInfo); +} + void AudioRoutingManagerImpl::SelectOutputDeviceSync(array_view outputAudioDevices) { std::vector> deviceDescriptors; @@ -234,6 +258,16 @@ void AudioRoutingManagerImpl::SelectOutputDeviceSync(array_view outputAudioDevices) +{ + return this->SelectOutputDeviceSync(outputAudioDevices); +} + +void AudioRoutingManagerImpl::SelectOutputDeviceReturnsPromise(array_view outputAudioDevices) +{ + return this->SelectOutputDeviceSync(outputAudioDevices); +} + void AudioRoutingManagerImpl::SelectOutputDeviceByFilterSync(AudioRendererFilter const &filter, array_view outputAudioDevices) { @@ -261,6 +295,18 @@ void AudioRoutingManagerImpl::SelectOutputDeviceByFilterSync(AudioRendererFilter } } +void AudioRoutingManagerImpl::SelectOutputDeviceByFilterWithCallback(AudioRendererFilter const &filter, + array_view outputAudioDevices) +{ + return this->SelectOutputDeviceByFilterSync(filter, outputAudioDevices); +} + +void AudioRoutingManagerImpl::SelectOutputDeviceByFilterReturnsPromise(AudioRendererFilter const &filter, + array_view outputAudioDevices) +{ + return this->SelectOutputDeviceByFilterSync(filter, outputAudioDevices); +} + array AudioRoutingManagerImpl::GetPreferredInputDeviceByFilter(AudioCapturerFilter const &filter) { std::vector emptyResult; @@ -366,6 +412,16 @@ void AudioRoutingManagerImpl::SelectInputDeviceSync(array_view inputAudioDevices) +{ + return this->SelectInputDeviceSync(inputAudioDevices); +} + +void AudioRoutingManagerImpl::SelectInputDeviceReturnsPromise(array_view inputAudioDevices) +{ + return this->SelectInputDeviceSync(inputAudioDevices); +} + array AudioRoutingManagerImpl::GetDevicesSync(DeviceFlag deviceFlag) { std::vector emptyResult; @@ -390,6 +446,16 @@ array AudioRoutingManagerImpl::GetDevicesSync(DeviceFlag return TaiheParamUtils::SetDeviceDescriptors(deviceDescriptors); } +array AudioRoutingManagerImpl::GetDevicesWithCallback(DeviceFlag deviceFlag) +{ + return this->GetDevicesSync(deviceFlag); +} + +array AudioRoutingManagerImpl::GetDevicesReturnsPromise(DeviceFlag deviceFlag) +{ + return this->GetDevicesSync(deviceFlag); +} + void AudioRoutingManagerImpl::SetCommunicationDeviceSync(CommunicationDeviceType deviceType, bool active) { if (!TaiheAudioEnum::IsLegalInputArgumentCommunicationDeviceType(deviceType)) { @@ -433,7 +499,9 @@ bool AudioRoutingManagerImpl::IsCommunicationDeviceActiveSync(CommunicationDevic return isActive; } -void AudioRoutingManagerImpl::OnPreferredInputDeviceChangeForCapturerInfo(AudioCapturerInfo const &capturerInfo, +void AudioRoutingManagerImpl::OnPreferredInputDeviceChangeForCapturerInfo( + ::taihe::string_view type, + AudioCapturerInfo const &capturerInfo, callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); @@ -481,7 +549,7 @@ void AudioRoutingManagerImpl::AddPreferredInputDeviceChangeCallback(AudioRouting } void AudioRoutingManagerImpl::OffPreferredInputDeviceChangeForCapturerInfo( - optional_view)>> callback) + ::taihe::string_view type, optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -491,7 +559,7 @@ void AudioRoutingManagerImpl::OffPreferredInputDeviceChangeForCapturerInfo( } void AudioRoutingManagerImpl::OffPreferOutputDeviceChangeForRendererInfo( - optional_view)>> callback) + ::taihe::string_view type, optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -605,7 +673,8 @@ void AudioRoutingManagerImpl::RemoveAllPrefOutputDeviceChangeCallback(AudioRouti audioRoutingManagerImpl->preferredOutputDeviceCallbacks_.clear(); } -void AudioRoutingManagerImpl::OnMicBlockStatusChanged(callback_view callback) +void AudioRoutingManagerImpl::OnMicBlockStatusChanged(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterMicrophoneBlockedCallback(cacheCallback, MICROPHONE_BLOCKED_CALLBACK_NAME, this); @@ -635,7 +704,7 @@ void AudioRoutingManagerImpl::RegisterMicrophoneBlockedCallback(std::shared_ptr< } void AudioRoutingManagerImpl::OffMicBlockStatusChanged( - optional_view> callback) + ::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -673,7 +742,8 @@ void AudioRoutingManagerImpl::UnregisterMicrophoneBlockedCallback(std::shared_pt } } -void AudioRoutingManagerImpl::OffDeviceChange(optional_view> callback) +void AudioRoutingManagerImpl::OffDeviceChange(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -713,6 +783,7 @@ void AudioRoutingManagerImpl::UnregisterDeviceChangeCallback(std::shared_ptr> callback) { std::shared_ptr cacheCallback; @@ -752,14 +823,17 @@ void AudioRoutingManagerImpl::UnregisterAvailableDeviceChangeCallback(std::share } } -void AudioRoutingManagerImpl::OnDeviceChange(DeviceFlag deviceFlag, +void AudioRoutingManagerImpl::OnDeviceChange(::taihe::string_view type, + DeviceFlag deviceFlag, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterDeviceChangeCallback(deviceFlag, cacheCallback, DEVICE_CHANGE_CALLBACK_NAME, this); } -void AudioRoutingManagerImpl::OnAvailableDeviceChange(DeviceUsage deviceUsage, +void AudioRoutingManagerImpl::OnAvailableDeviceChange( + ::taihe::string_view type, + DeviceUsage deviceUsage, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); @@ -833,7 +907,8 @@ void AudioRoutingManagerImpl::RegisterAvaiableDeviceChangeCallback(DeviceUsage d cb->SaveRoutingAvailbleDeviceChangeCbRef(usage, callback); } -void AudioRoutingManagerImpl::OnPreferOutputDeviceChangeForRendererInfo(AudioRendererInfo const &rendererInfo, +void AudioRoutingManagerImpl::OnPreferOutputDeviceChangeForRendererInfo(::taihe::string_view type, + AudioRendererInfo const &rendererInfo, callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); diff --git a/frameworks/taihe/audiomanager/taihe_audio_routing_manager.h b/frameworks/taihe/audiomanager/taihe_audio_routing_manager.h index b9c31a59ca590a2ddeaf42d07bfdb83e9cc2847e..764dff78445e9ea1517df1388f7b06940de4a2ed 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_routing_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_routing_manager.h @@ -41,37 +41,66 @@ public: bool IsMicBlockDetectionSupportedSync(); #endif array GetDevicesSync(DeviceFlag deviceFlag); + array GetDevicesWithCallback(DeviceFlag deviceFlag); + array GetDevicesReturnsPromise(DeviceFlag deviceFlag); array GetAvailableDevices(DeviceUsage usage); array GetExcludedDevices(DeviceUsage usage); - array GetPreferredOutputDeviceForRendererInfoSync(AudioRendererInfo const &rendererInfo); - array GetPreferredInputDeviceForCapturerInfoSync(AudioCapturerInfo const &capturerInfo); + array GetPreferredOutputDeviceForRendererInfoSync( + AudioRendererInfo const &rendererInfo); + array GetPreferOutputDeviceForRendererInfoWithCallback( + AudioRendererInfo const &rendererInfo); + array GetPreferOutputDeviceForRendererInfoReturnsPromise( + AudioRendererInfo const &rendererInfo); + array GetPreferredInputDeviceForCapturerInfoSync( + AudioCapturerInfo const &capturerInfo); + array GetPreferredInputDeviceForCapturerInfoWithCallback( + AudioCapturerInfo const &capturerInfo); + array GetPreferredInputDeviceForCapturerInfoReturnsPromise( + AudioCapturerInfo const &capturerInfo); void SelectOutputDeviceSync(array_view outputAudioDevices); + void SelectOutputDeviceWithCallback(array_view outputAudioDevices); + void SelectOutputDeviceReturnsPromise(array_view outputAudioDevices); void SelectOutputDeviceByFilterSync(AudioRendererFilter const &filter, array_view outputAudioDevices); + void SelectOutputDeviceByFilterWithCallback(AudioRendererFilter const &filter, + array_view outputAudioDevices); + void SelectOutputDeviceByFilterReturnsPromise(AudioRendererFilter const &filter, + array_view outputAudioDevices); array GetPreferredInputDeviceByFilter(AudioCapturerFilter const &filter); array GetPreferredOutputDeviceByFilter(AudioRendererFilter const &filter); void SelectInputDeviceByFilterSync(AudioCapturerFilter const &filter, array_view inputAudioDevices); void SelectInputDeviceSync(array_view inputAudioDevices); + void SelectInputDeviceWithCallback(array_view inputAudioDevices); + void SelectInputDeviceReturnsPromise(array_view inputAudioDevices); void SetCommunicationDeviceSync(CommunicationDeviceType deviceType, bool active); bool IsCommunicationDeviceActiveSync(CommunicationDeviceType deviceType); void ExcludeOutputDevicesSync(DeviceUsage usage, array_view devices); void UnexcludeOutputDevicesWithUsageAndDevices(DeviceUsage usage, array_view devices); void UnexcludeOutputDevicesWithUsage(DeviceUsage usage); - void OnPreferredInputDeviceChangeForCapturerInfo(AudioCapturerInfo const &capturerInfo, + void OnPreferredInputDeviceChangeForCapturerInfo(::taihe::string_view type, + AudioCapturerInfo const &capturerInfo, callback_view)> callback); - void OnMicBlockStatusChanged(callback_view callback); - void OnDeviceChange(DeviceFlag deviceFlag, callback_view callback); - void OnAvailableDeviceChange(DeviceUsage deviceUsage, callback_view callback); - void OnPreferOutputDeviceChangeForRendererInfo(AudioRendererInfo const &rendererInfo, + void OnMicBlockStatusChanged(::taihe::string_view type, + callback_view callback); + void OnDeviceChange(::taihe::string_view type, + DeviceFlag deviceFlag, callback_view callback); + void OnAvailableDeviceChange(::taihe::string_view type, + DeviceUsage deviceUsage, callback_view callback); + void OnPreferOutputDeviceChangeForRendererInfo( + ::taihe::string_view type, + AudioRendererInfo const &rendererInfo, callback_view)> callback); - void OffMicBlockStatusChanged(optional_view> callback); - void OffAvailableDeviceChange(optional_view> callback); - void OffPreferredInputDeviceChangeForCapturerInfo(optional_view)>> - callback); - void OffPreferOutputDeviceChangeForRendererInfo(optional_view)>> - callback); - void OffDeviceChange(optional_view> callback); + void OffMicBlockStatusChanged(::taihe::string_view type, + optional_view> callback); + void OffAvailableDeviceChange(::taihe::string_view type, + optional_view> callback); + void OffPreferredInputDeviceChangeForCapturerInfo(::taihe::string_view type, + optional_view)>> callback); + void OffPreferOutputDeviceChangeForRendererInfo(::taihe::string_view type, + optional_view)>> callback); + void OffDeviceChange(::taihe::string_view type, + optional_view> callback); private: static void RegisterDeviceChangeCallback(DeviceFlag deviceFlag, std::shared_ptr &callback, diff --git a/frameworks/taihe/audiomanager/taihe_audio_session_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_session_manager.cpp index 027682852201ab89605bbdb5f2720151c3ea2243..d4dab4e53241a5d20ae8dc4a0dcc210fb86043fc 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_session_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_session_manager.cpp @@ -88,6 +88,7 @@ bool AudioSessionManagerImpl::IsAudioSessionActivated() } void AudioSessionManagerImpl::OnAudioSessionDeactivated( + ::taihe::string_view type, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); @@ -95,6 +96,7 @@ void AudioSessionManagerImpl::OnAudioSessionDeactivated( } void AudioSessionManagerImpl::OffAudioSessionDeactivated( + ::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; diff --git a/frameworks/taihe/audiomanager/taihe_audio_session_manager.h b/frameworks/taihe/audiomanager/taihe_audio_session_manager.h index 8b90110bd55bf65bdeac3eb53782ee921d0292dd..2c26867b613f3173f206db5f4e50c473fefddd0e 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_session_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_session_manager.h @@ -38,8 +38,10 @@ public: void ActivateAudioSessionSync(AudioSessionStrategy const &strategy); void DeactivateAudioSessionSync(); bool IsAudioSessionActivated(); - void OnAudioSessionDeactivated(callback_view callback); - void OffAudioSessionDeactivated(optional_view> callback); + void OnAudioSessionDeactivated(::taihe::string_view type, + callback_view callback); + void OffAudioSessionDeactivated(::taihe::string_view type, + optional_view> callback); private: static void RegisterAudioSessionCallback(std::shared_ptr &callback, diff --git a/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.cpp index df755cc424eaac34f80f99fd80044cd4b56cee03..82dff7aee6251e4f92aa7fbf6f06d40044a491fd 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.cpp @@ -326,13 +326,16 @@ AudioSpatializationSceneType AudioSpatializationManagerImpl::GetSpatializationSc return TaiheAudioEnum::ToTaiheAudioSpatializationSceneType(sceneType); } -void AudioSpatializationManagerImpl::OnSpatializationEnabledChangeForCurrentDevice(callback_view callback) +void AudioSpatializationManagerImpl::OnSpatializationEnabledChangeForCurrentDevice( + ::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterSpatializationEnabledChangeForCurrentDeviceCallback(cacheCallback, this); } void AudioSpatializationManagerImpl::OnSpatializationEnabledChangeForAnyDevice( + ::taihe::string_view type, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); @@ -342,6 +345,7 @@ void AudioSpatializationManagerImpl::OnSpatializationEnabledChangeForAnyDevice( } void AudioSpatializationManagerImpl::OnHeadTrackingEnabledChangeForAnyDevice( + ::taihe::string_view type, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); @@ -351,6 +355,7 @@ void AudioSpatializationManagerImpl::OnHeadTrackingEnabledChangeForAnyDevice( } void AudioSpatializationManagerImpl::OffSpatializationEnabledChangeForCurrentDevice( + ::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; @@ -361,6 +366,7 @@ void AudioSpatializationManagerImpl::OffSpatializationEnabledChangeForCurrentDev } void AudioSpatializationManagerImpl::OffSpatializationEnabledChangeForAnyDevice( + ::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; @@ -373,6 +379,7 @@ void AudioSpatializationManagerImpl::OffSpatializationEnabledChangeForAnyDevice( } void AudioSpatializationManagerImpl::OffHeadTrackingEnabledChangeForAnyDevice( + ::taihe::string_view type, optional_view> callback) { std::shared_ptr cacheCallback; diff --git a/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.h b/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.h index 1603c98c3fba1d5826cea96243e58ad6ccc10fd5..715e1b1fdbc46cb3426dfe8850f7f07140df66ac 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_spatialization_manager.h @@ -45,15 +45,21 @@ public: void SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType); AudioSpatializationSceneType GetSpatializationSceneType(); - void OnSpatializationEnabledChangeForCurrentDevice(callback_view callback); + void OnSpatializationEnabledChangeForCurrentDevice(::taihe::string_view type, + callback_view callback); void OnSpatializationEnabledChangeForAnyDevice( + ::taihe::string_view type, callback_view callback); void OnHeadTrackingEnabledChangeForAnyDevice( + ::taihe::string_view type, callback_view callback); - void OffSpatializationEnabledChangeForCurrentDevice(optional_view> callback); + void OffSpatializationEnabledChangeForCurrentDevice(::taihe::string_view type, + optional_view> callback); void OffSpatializationEnabledChangeForAnyDevice( + ::taihe::string_view type, optional_view> callback); void OffHeadTrackingEnabledChangeForAnyDevice( + ::taihe::string_view type, optional_view> callback); private: diff --git a/frameworks/taihe/audiomanager/taihe_audio_stream_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_stream_manager.cpp index 591a8d3a138fe98582424e6e3915751c503c8858..790a8f672ee420272dc39076e44b47f6f4fcad53 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_stream_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_stream_manager.cpp @@ -61,6 +61,16 @@ array AudioStreamManagerImpl::GetCurrentAudioRendererIn return TaiheParamUtils::SetRendererChangeInfos(audioRendererChangeInfos); } +array AudioStreamManagerImpl::GetCurrentAudioRendererInfoArrayWithCallback() +{ + return this->GetCurrentAudioRendererInfoArraySync(); +} + +array AudioStreamManagerImpl::GetCurrentAudioRendererInfoArrayReturnsPromise() +{ + return this->GetCurrentAudioRendererInfoArraySync(); +} + array AudioStreamManagerImpl::GetCurrentAudioCapturerInfoArraySync() { std::vector emptyResult; @@ -76,6 +86,16 @@ array AudioStreamManagerImpl::GetCurrentAudioCapturerIn return TaiheParamUtils::SetCapturerChangeInfos(audioCapturerChangeInfos); } +array AudioStreamManagerImpl::GetCurrentAudioCapturerInfoArrayWithCallback() +{ + return this->GetCurrentAudioCapturerInfoArraySync(); +} + +array AudioStreamManagerImpl::GetCurrentAudioCapturerInfoArrayReturnsPromise() +{ + return this->GetCurrentAudioCapturerInfoArraySync(); +} + array AudioStreamManagerImpl::GetAudioEffectInfoArraySync(StreamUsage usage) { std::vector emptyResult; @@ -116,19 +136,32 @@ bool AudioStreamManagerImpl::IsActiveSync(AudioVolumeType volumeType) return audioStreamMngr_->IsStreamActive(TaiheAudioEnum::GetNativeAudioVolumeType(volType)); } -void AudioStreamManagerImpl::OnAudioRendererChange(callback_view)> callback) +bool AudioStreamManagerImpl::IsActiveWithCallback(AudioVolumeType volumeType) +{ + return this->IsActiveSync(volumeType); +} + +bool AudioStreamManagerImpl::IsActiveReturnsPromise(AudioVolumeType volumeType) +{ + return this->IsActiveSync(volumeType); +} + +void AudioStreamManagerImpl::OnAudioRendererChange(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererStateChangeCallback(cacheCallback, RENDERERCHANGE_CALLBACK_NAME, this); } -void AudioStreamManagerImpl::OnAudioCapturerChange(callback_view)> callback) +void AudioStreamManagerImpl::OnAudioCapturerChange(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterCapturerStateChangeCallback(cacheCallback, CAPTURERCHANGE_CALLBACK_NAME, this); } void AudioStreamManagerImpl::OffAudioRendererChange( + ::taihe::string_view type, optional_view)>> callback) { std::shared_ptr cacheCallback; @@ -138,8 +171,8 @@ void AudioStreamManagerImpl::OffAudioRendererChange( UnregisterRendererChangeCallback(cacheCallback, this); } -void AudioStreamManagerImpl::OffAudioCapturerChange(optional_view)>> - callback) +void AudioStreamManagerImpl::OffAudioCapturerChange(::taihe::string_view type, + optional_view)>> callback) { CHECK_AND_RETURN_RET_LOG(audioStreamMngr_ != nullptr, TaiheAudioError::ThrowErrorAndReturn( TAIHE_ERROR_INVALID_PARAM), "audioStreamMngr_ is nullptr"); diff --git a/frameworks/taihe/audiomanager/taihe_audio_stream_manager.h b/frameworks/taihe/audiomanager/taihe_audio_stream_manager.h index d162b8cbdf9bbab9cbec92bbbefd2d2b27e6c401..55965353a8224f06e39e18f7328ce91833d54738 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_stream_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_stream_manager.h @@ -36,13 +36,23 @@ public: static AudioStreamManager CreateStreamManagerWrapper(); array GetCurrentAudioRendererInfoArraySync(); + array GetCurrentAudioRendererInfoArrayWithCallback(); + array GetCurrentAudioRendererInfoArrayReturnsPromise(); array GetCurrentAudioCapturerInfoArraySync(); + array GetCurrentAudioCapturerInfoArrayWithCallback(); + array GetCurrentAudioCapturerInfoArrayReturnsPromise(); array GetAudioEffectInfoArraySync(StreamUsage usage); bool IsActiveSync(AudioVolumeType volumeType); - void OnAudioRendererChange(callback_view)> callback); - void OnAudioCapturerChange(callback_view)> callback); - void OffAudioRendererChange(optional_view)>> callback); - void OffAudioCapturerChange(optional_view)>> callback); + bool IsActiveWithCallback(AudioVolumeType volumeType); + bool IsActiveReturnsPromise(AudioVolumeType volumeType); + void OnAudioRendererChange(::taihe::string_view type, + callback_view)> callback); + void OnAudioCapturerChange(::taihe::string_view type, + callback_view)> callback); + void OffAudioRendererChange(::taihe::string_view type, + optional_view)>> callback); + void OffAudioCapturerChange(::taihe::string_view type, + optional_view)>> callback); private: static void RegisterRendererStateChangeCallback(std::shared_ptr &callback, const std::string &cbName, diff --git a/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.cpp index 5319ff54db5faaf5db05bcc043cda2ad32a32b88..f1ef1183fc4762840a72f1c692b704367bdd2929 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.cpp @@ -83,6 +83,16 @@ void AudioVolumeGroupManagerImpl::SetVolumeSync(AudioVolumeType volumeType, int3 return; } +void AudioVolumeGroupManagerImpl::SetVolumeWithCallback(AudioVolumeType volumeType, int32_t volume) +{ + return this->SetVolumeSync(volumeType, volume); +} + +void AudioVolumeGroupManagerImpl::SetVolumeReturnsPromise(AudioVolumeType volumeType, int32_t volume) +{ + return this->SetVolumeSync(volumeType, volume); +} + void AudioVolumeGroupManagerImpl::SetVolumeWithFlagSync(AudioVolumeType volumeType, int32_t volume, int32_t flags) { int32_t volType = volumeType.get_value(); @@ -133,6 +143,16 @@ int32_t AudioVolumeGroupManagerImpl::GetVolumeSync(AudioVolumeType volumeType) return volLevel; } +int32_t AudioVolumeGroupManagerImpl::GetVolumeWithVolumeTypeCallback(AudioVolumeType volumeType) +{ + return this->GetVolumeSync(volumeType); +} + +int32_t AudioVolumeGroupManagerImpl::GetVolumeWithVolumeTypeReturnsPromise(AudioVolumeType volumeType) +{ + return this->GetVolumeSync(volumeType); +} + int32_t AudioVolumeGroupManagerImpl::GetMinVolumeSync(AudioVolumeType volumeType) { int32_t volType = volumeType.get_value(); @@ -150,6 +170,16 @@ int32_t AudioVolumeGroupManagerImpl::GetMinVolumeSync(AudioVolumeType volumeType return volLevel; } +int32_t AudioVolumeGroupManagerImpl::GetMinVolumeWithCallback(AudioVolumeType volumeType) +{ + return this->GetMinVolumeSync(volumeType); +} + +int32_t AudioVolumeGroupManagerImpl::GetMinVolumeReturnsPromise(AudioVolumeType volumeType) +{ + return this->GetMinVolumeSync(volumeType); +} + int32_t AudioVolumeGroupManagerImpl::GetMaxVolumeSync(AudioVolumeType volumeType) { int32_t volType = volumeType.get_value(); @@ -167,6 +197,16 @@ int32_t AudioVolumeGroupManagerImpl::GetMaxVolumeSync(AudioVolumeType volumeType return volLevel; } +int32_t AudioVolumeGroupManagerImpl::GetMaxVolumeWithCallback(AudioVolumeType volumeType) +{ + return this->GetMaxVolumeSync(volumeType); +} + +int32_t AudioVolumeGroupManagerImpl::GetMaxVolumeReturnsPromise(AudioVolumeType volumeType) +{ + return this->GetMaxVolumeSync(volumeType); +} + void AudioVolumeGroupManagerImpl::MuteSync(AudioVolumeType volumeType, bool mute) { int32_t volType = volumeType.get_value(); @@ -184,6 +224,16 @@ void AudioVolumeGroupManagerImpl::MuteSync(AudioVolumeType volumeType, bool mute return; } +void AudioVolumeGroupManagerImpl::MuteWithCallback(AudioVolumeType volumeType, bool mute) +{ + return this->MuteSync(volumeType, mute); +} + +void AudioVolumeGroupManagerImpl::MuteReturnsPromise(AudioVolumeType volumeType, bool mute) +{ + return this->MuteSync(volumeType, mute); +} + bool AudioVolumeGroupManagerImpl::IsMuteSync(AudioVolumeType volumeType) { bool isMute = false; @@ -203,6 +253,16 @@ bool AudioVolumeGroupManagerImpl::IsMuteSync(AudioVolumeType volumeType) return isMute; } +bool AudioVolumeGroupManagerImpl::IsMuteWithCallback(AudioVolumeType volumeType) +{ + return this->IsMuteSync(volumeType); +} + +bool AudioVolumeGroupManagerImpl::IsMuteReturnsPromise(AudioVolumeType volumeType) +{ + return this->IsMuteSync(volumeType); +} + void AudioVolumeGroupManagerImpl::SetRingerModeSync(AudioRingMode mode) { int32_t ringMode = mode.get_value(); @@ -220,6 +280,16 @@ void AudioVolumeGroupManagerImpl::SetRingerModeSync(AudioRingMode mode) return; } +void AudioVolumeGroupManagerImpl::SetRingerModeWithCallback(AudioRingMode mode) +{ + return this->SetRingerModeSync(mode); +} + +void AudioVolumeGroupManagerImpl::SetRingerModeReturnsPromise(AudioRingMode mode) +{ + return this->SetRingerModeSync(mode); +} + AudioRingMode AudioVolumeGroupManagerImpl::GetRingerModeSync() { OHOS::AudioStandard::AudioRingerMode ringerMode = OHOS::AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL; @@ -231,6 +301,16 @@ AudioRingMode AudioVolumeGroupManagerImpl::GetRingerModeSync() return TaiheAudioEnum::ToTaiheAudioRingMode(ringerMode); } +AudioRingMode AudioVolumeGroupManagerImpl::GetRingerModeWithCallback() +{ + return this->GetRingerModeSync(); +} + +AudioRingMode AudioVolumeGroupManagerImpl::GetRingerModeReturnsPromise() +{ + return this->GetRingerModeSync(); +} + void AudioVolumeGroupManagerImpl::SetMicMuteSync(bool mute) { if (!OHOS::AudioStandard::PermissionUtil::VerifySelfPermission()) { @@ -299,6 +379,16 @@ bool AudioVolumeGroupManagerImpl::IsMicrophoneMuteSync() return audioGroupMngr_->IsMicrophoneMute(); } +bool AudioVolumeGroupManagerImpl::IsMicrophoneMuteWithCallback() +{ + return this->IsMicrophoneMuteSync(); +} + +bool AudioVolumeGroupManagerImpl::IsMicrophoneMuteReturnsPromise() +{ + return this->IsMicrophoneMuteSync(); +} + void AudioVolumeGroupManagerImpl::AdjustVolumeByStepSync(VolumeAdjustType adjustType) { int32_t adjustTypeInt32 = adjustType.get_value(); @@ -325,7 +415,18 @@ void AudioVolumeGroupManagerImpl::AdjustVolumeByStepSync(VolumeAdjustType adjust return; } -void AudioVolumeGroupManagerImpl::OnRingerModeChange(callback_view callback) +void AudioVolumeGroupManagerImpl::AdjustVolumeByStepWithCallback(VolumeAdjustType adjustType) +{ + return this->AdjustVolumeByStepSync(adjustType); +} + +void AudioVolumeGroupManagerImpl::AdjustVolumeByStepReturnsPromise(VolumeAdjustType adjustType) +{ + return this->AdjustVolumeByStepSync(adjustType); +} + +void AudioVolumeGroupManagerImpl::OnRingerModeChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRingModeCallback(cacheCallback, RINGERMODE_CALLBACK_NAME, this); @@ -351,7 +452,8 @@ void AudioVolumeGroupManagerImpl::RegisterRingModeCallback(std::shared_ptrSaveCallbackReference(cbName, callback); } -void AudioVolumeGroupManagerImpl::OffRingerModeChange(optional_view> callback) +void AudioVolumeGroupManagerImpl::OffRingerModeChange(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -385,7 +487,8 @@ void AudioVolumeGroupManagerImpl::UnregisterRingerModeCallback(std::shared_ptr callback) +void AudioVolumeGroupManagerImpl::OnMicStateChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterMicStateChangeCallback(cacheCallback, MIC_STATE_CHANGE_CALLBACK_NAME, this); @@ -419,7 +522,8 @@ void AudioVolumeGroupManagerImpl::RegisterMicStateChangeCallback(std::shared_ptr AUDIO_DEBUG_LOG("On SetMicStateChangeCallback is successful"); } -void AudioVolumeGroupManagerImpl::OffMicStateChange(optional_view> callback) +void AudioVolumeGroupManagerImpl::OffMicStateChange(::taihe::string_view type, + optional_view> callback) { CHECK_AND_RETURN_RET_LOG(audioGroupMngr_ != nullptr, TaiheAudioError::ThrowErrorAndReturn( TAIHE_ERR_NO_MEMORY), "audioGroupMngr_ is nullptr"); diff --git a/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.h b/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.h index 7eeba7d6755282c1e39ed75edf003af336ac55dc..70b02206f0bb8f5120ad253d8373e7635df75d3c 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_volume_group_manager.h @@ -31,29 +31,53 @@ public: static AudioVolumeGroupManager CreateAudioVolumeGroupManagerWrapper(int32_t groupId); void SetVolumeSync(AudioVolumeType volumeType, int32_t volume); + void SetVolumeWithCallback(AudioVolumeType volumeType, int32_t volume); + void SetVolumeReturnsPromise(AudioVolumeType volumeType, int32_t volume); void SetVolumeWithFlagSync(AudioVolumeType volumeType, int32_t volume, int32_t flags); AudioVolumeType GetActiveVolumeTypeSync(int32_t uid); int32_t GetVolumeSync(AudioVolumeType volumeType); + int32_t GetVolumeWithVolumeTypeCallback(AudioVolumeType volumeType); + int32_t GetVolumeWithVolumeTypeReturnsPromise(AudioVolumeType volumeType); int32_t GetMinVolumeSync(AudioVolumeType volumeType); + int32_t GetMinVolumeWithCallback(AudioVolumeType volumeType); + int32_t GetMinVolumeReturnsPromise(AudioVolumeType volumeType); int32_t GetMaxVolumeSync(AudioVolumeType volumeType); + int32_t GetMaxVolumeWithCallback(AudioVolumeType volumeType); + int32_t GetMaxVolumeReturnsPromise(AudioVolumeType volumeType); void MuteSync(AudioVolumeType volumeType, bool mute); + void MuteWithCallback(AudioVolumeType volumeType, bool mute); + void MuteReturnsPromise(AudioVolumeType volumeType, bool mute); bool IsMuteSync(AudioVolumeType volumeType); + bool IsMuteWithCallback(AudioVolumeType volumeType); + bool IsMuteReturnsPromise(AudioVolumeType volumeType); void SetRingerModeSync(AudioRingMode mode); + void SetRingerModeWithCallback(AudioRingMode mode); + void SetRingerModeReturnsPromise(AudioRingMode mode); AudioRingMode GetRingerModeSync(); + AudioRingMode GetRingerModeWithCallback(); + AudioRingMode GetRingerModeReturnsPromise(); void SetMicMuteSync(bool mute); void SetMicMutePersistentSync(bool mute, PolicyType type); bool IsPersistentMicMute(); bool IsMicrophoneMuteSync(); + bool IsMicrophoneMuteWithCallback(); + bool IsMicrophoneMuteReturnsPromise(); void AdjustVolumeByStepSync(VolumeAdjustType adjustType); + void AdjustVolumeByStepWithCallback(VolumeAdjustType adjustType); + void AdjustVolumeByStepReturnsPromise(VolumeAdjustType adjustType); bool IsVolumeUnadjustable(); void AdjustSystemVolumeByStepSync(AudioVolumeType volumeType, VolumeAdjustType adjustType); double GetSystemVolumeInDbSync(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType device); double GetMaxAmplitudeForInputDeviceSync(AudioDeviceDescriptor inputDevice); double GetMaxAmplitudeForOutputDeviceSync(AudioDeviceDescriptor inputDevice); - void OnRingerModeChange(callback_view callback); - void OnMicStateChange(callback_view callback); - void OffRingerModeChange(optional_view> callback); - void OffMicStateChange(optional_view> callback); + void OnRingerModeChange(::taihe::string_view type, + callback_view callback); + void OnMicStateChange(::taihe::string_view type, + callback_view callback); + void OffRingerModeChange(::taihe::string_view type, + optional_view> callback); + void OffMicStateChange(::taihe::string_view type, + optional_view> callback); private: static void RegisterRingModeCallback(std::shared_ptr &callback, diff --git a/frameworks/taihe/audiomanager/taihe_audio_volume_manager.cpp b/frameworks/taihe/audiomanager/taihe_audio_volume_manager.cpp index 2c1f8e95e7bf06cad1f25afd29754e594551996a..7edbc1c050c780ceea7eafbe95d92ed2fed466bd 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_volume_manager.cpp +++ b/frameworks/taihe/audiomanager/taihe_audio_volume_manager.cpp @@ -195,6 +195,16 @@ AudioVolumeGroupManager AudioVolumeManagerImpl::GetVolumeGroupManagerSync(int32_ return AudioVolumeGroupManagerImpl::CreateAudioVolumeGroupManagerWrapper(groupId); } +AudioVolumeGroupManager AudioVolumeManagerImpl::GetVolumeGroupManagerWithCallback(int32_t groupId) +{ + return this->GetVolumeGroupManagerSync(groupId); +} + +AudioVolumeGroupManager AudioVolumeManagerImpl::GetVolumeGroupManagerReturnsPromise(int32_t groupId) +{ + return this->GetVolumeGroupManagerSync(groupId); +} + void AudioVolumeManagerImpl::RegisterCallback(std::shared_ptr &callback, const std::string &cbName, AudioVolumeManagerImpl *audioVolMngrImpl) { @@ -364,13 +374,15 @@ void AudioVolumeManagerImpl::UnregisterSelfAppVolumeChangeCallback(std::shared_p } } -void AudioVolumeManagerImpl::OnVolumeChange(callback_view callback) +void AudioVolumeManagerImpl::OnVolumeChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterCallback(cacheCallback, VOLUME_KEY_EVENT_CALLBACK_NAME, this); } -void AudioVolumeManagerImpl::OffVolumeChange(optional_view> callback) +void AudioVolumeManagerImpl::OffVolumeChange(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -379,13 +391,16 @@ void AudioVolumeManagerImpl::OffVolumeChange(optional_view callback) +void AudioVolumeManagerImpl::OnAppVolumeChange(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterSelfAppVolumeChangeCallback(cacheCallback, APP_VOLUME_CHANGE_CALLBACK_NAME, this); } -void AudioVolumeManagerImpl::OffAppVolumeChange(optional_view> callback) +void AudioVolumeManagerImpl::OffAppVolumeChange( + ::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -394,13 +409,16 @@ void AudioVolumeManagerImpl::OffAppVolumeChange(optional_view callback) +void AudioVolumeManagerImpl::OnAppVolumeChangeForUid(::taihe::string_view type, + int32_t uid, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterAppVolumeChangeForUidCallback(uid, cacheCallback, APP_VOLUME_CHANGE_CALLBACK_NAME_FOR_UID, this); } -void AudioVolumeManagerImpl::OffAppVolumeChangeForUid(optional_view> callback) +void AudioVolumeManagerImpl::OffAppVolumeChangeForUid( + ::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { diff --git a/frameworks/taihe/audiomanager/taihe_audio_volume_manager.h b/frameworks/taihe/audiomanager/taihe_audio_volume_manager.h index 7b8a30cf20afd3a04b3ff10fa21cc8ebacfb367b..6f2881aa58585419d5f285f4bb4ceed419eddfcd 100644 --- a/frameworks/taihe/audiomanager/taihe_audio_volume_manager.h +++ b/frameworks/taihe/audiomanager/taihe_audio_volume_manager.h @@ -40,12 +40,20 @@ public: int32_t GetAppVolumePercentageSync(); void SetAppVolumePercentageSync(int32_t volume); AudioVolumeGroupManager GetVolumeGroupManagerSync(int32_t groupId); - void OnVolumeChange(callback_view callback); - void OnAppVolumeChangeForUid(int32_t uid, callback_view callback); - void OnAppVolumeChange(callback_view callback); - void OffVolumeChange(optional_view> callback); - void OffAppVolumeChange(optional_view> callback); - void OffAppVolumeChangeForUid(optional_view> callback); + AudioVolumeGroupManager GetVolumeGroupManagerWithCallback(int32_t groupId); + AudioVolumeGroupManager GetVolumeGroupManagerReturnsPromise(int32_t groupId); + void OnVolumeChange(::taihe::string_view type, + callback_view callback); + void OnAppVolumeChangeForUid(::taihe::string_view type, + int32_t uid, callback_view callback); + void OnAppVolumeChange(::taihe::string_view type, + callback_view callback); + void OffVolumeChange(::taihe::string_view type, + optional_view> callback); + void OffAppVolumeChange(::taihe::string_view type, + optional_view> callback); + void OffAppVolumeChangeForUid(::taihe::string_view type, + optional_view> callback); private: static void RegisterCallback(std::shared_ptr &callback, diff --git a/frameworks/taihe/audiorenderer/taihe_audio_renderer.cpp b/frameworks/taihe/audiorenderer/taihe_audio_renderer.cpp index 97a070c0ff16f586d1b6ced2df1c15ea4e4f361b..25c0c77e6e79006c6d69ab82d395520c3a0ff07d 100644 --- a/frameworks/taihe/audiorenderer/taihe_audio_renderer.cpp +++ b/frameworks/taihe/audiorenderer/taihe_audio_renderer.cpp @@ -159,6 +159,16 @@ void AudioRendererImpl::StartSync() } } +void AudioRendererImpl::StartWithCallback() +{ + return this->StartSync(); +} + +void AudioRendererImpl::StartReturnsPromise() +{ + return this->StartSync(); +} + int64_t AudioRendererImpl::GetAudioTimeSync() { if (audioRenderer_ == nullptr) { @@ -251,6 +261,16 @@ void AudioRendererImpl::StopSync() } } +void AudioRendererImpl::StopWithCallback() +{ + return this->StopSync(); +} + +void AudioRendererImpl::StopReturnsPromise() +{ + return this->StopSync(); +} + void AudioRendererImpl::ReleaseSync() { if (audioRenderer_ == nullptr) { @@ -264,6 +284,16 @@ void AudioRendererImpl::ReleaseSync() } } +void AudioRendererImpl::ReleaseWithCallback() +{ + return this->ReleaseSync(); +} + +void AudioRendererImpl::ReleaseReturnsPromise() +{ + return this->ReleaseSync(); +} + int64_t AudioRendererImpl::GetBufferSizeSync() { size_t bufferSize = 0; @@ -278,6 +308,16 @@ int64_t AudioRendererImpl::GetBufferSizeSync() return static_cast(bufferSize); } +int64_t AudioRendererImpl::GetBufferSizeWithCallback() +{ + return this->GetBufferSizeSync(); +} + +int64_t AudioRendererImpl::GetBufferSizeReturnsPromise() +{ + return this->GetBufferSizeSync(); +} + int64_t AudioRendererImpl::GetAudioStreamIdSync() { uint32_t audioStreamId = 0; @@ -316,6 +356,16 @@ void AudioRendererImpl::SetVolumeSync(double volume) } } +void AudioRendererImpl::SetVolumeWithCallback(double volume) +{ + return this->SetVolumeSync(volume); +} + +void AudioRendererImpl::SetVolumeReturnsPromise(double volume) +{ + return this->SetVolumeSync(volume); +} + double AudioRendererImpl::GetVolume() { if (audioRenderer_ == nullptr) { @@ -903,49 +953,54 @@ void AudioRendererImpl::UnregisterRendererWriteDataCallback(std::shared_ptr callback) +void AudioRendererImpl::OnStateChange(::taihe::string_view type, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererCallback(cacheCallback, STATE_CHANGE_CALLBACK_NAME, this); } -void AudioRendererImpl::OnAudioInterrupt(callback_view callback) +void AudioRendererImpl::OnAudioInterrupt(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererCallback(cacheCallback, AUDIO_INTERRUPT_CALLBACK_NAME, this); } -void AudioRendererImpl::OnOutputDeviceChange(callback_view)> callback) +void AudioRendererImpl::OnOutputDeviceChange(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererDeviceChangeCallback(cacheCallback, this); } -void AudioRendererImpl::OnOutputDeviceChangeWithInfo(callback_view callback) +void AudioRendererImpl::OnOutputDeviceChangeWithInfo(::taihe::string_view type, + callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererOutputDeviceChangeWithInfoCallback(cacheCallback, this); } -void AudioRendererImpl::OnPeriodReach(int64_t frame, callback_view callback) +void AudioRendererImpl::OnPeriodReach(::taihe::string_view type, int64_t frame, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterPeriodPositionCallback(frame, cacheCallback, PERIOD_REACH_CALLBACK_NAME, this); } -void AudioRendererImpl::OnMarkReach(int64_t frame, callback_view callback) +void AudioRendererImpl::OnMarkReach(::taihe::string_view type, int64_t frame, callback_view callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterPositionCallback(frame, cacheCallback, MARK_REACH_CALLBACK_NAME, this); } -void AudioRendererImpl::OnWriteData(callback_view)> callback) +void AudioRendererImpl::OnWriteData(::taihe::string_view type, + callback_view)> callback) { auto cacheCallback = TaiheParamUtils::TypeCallback(callback); RegisterRendererWriteDataCallback(cacheCallback, WRITE_DATA_CALLBACK_NAME, this); } -void AudioRendererImpl::OffAudioInterrupt(optional_view> callback) +void AudioRendererImpl::OffAudioInterrupt(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -954,7 +1009,8 @@ void AudioRendererImpl::OffAudioInterrupt(optional_view> callback) +void AudioRendererImpl::OffStateChange(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -963,7 +1019,8 @@ void AudioRendererImpl::OffStateChange(optional_view> UnregisterRendererCallback(cacheCallback, STATE_CHANGE_CALLBACK_NAME, this); } -void AudioRendererImpl::OffOutputDeviceChange(optional_view)>> callback) +void AudioRendererImpl::OffOutputDeviceChange(::taihe::string_view type, + optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -973,6 +1030,7 @@ void AudioRendererImpl::OffOutputDeviceChange(optional_view> callback) { std::shared_ptr cacheCallback; @@ -982,7 +1040,8 @@ void AudioRendererImpl::OffOutputDeviceChangeWithInfo( UnregisterRendererOutputDeviceChangeWithInfoCallback(cacheCallback, this); } -void AudioRendererImpl::OffPeriodReach(optional_view> callback) +void AudioRendererImpl::OffPeriodReach(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -991,7 +1050,8 @@ void AudioRendererImpl::OffPeriodReach(optional_view> ca UnregisterPeriodPositionCallback(cacheCallback, PERIOD_REACH_CALLBACK_NAME, this); } -void AudioRendererImpl::OffMarkReach(optional_view> callback) +void AudioRendererImpl::OffMarkReach(::taihe::string_view type, + optional_view> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { @@ -1000,7 +1060,8 @@ void AudioRendererImpl::OffMarkReach(optional_view> call UnregisterPositionCallback(cacheCallback, MARK_REACH_CALLBACK_NAME, this); } -void AudioRendererImpl::OffWriteData(optional_view)>> callback) +void AudioRendererImpl::OffWriteData(::taihe::string_view type, + optional_view)>> callback) { std::shared_ptr cacheCallback; if (callback.has_value()) { diff --git a/frameworks/taihe/audiorenderer/taihe_audio_renderer.h b/frameworks/taihe/audiorenderer/taihe_audio_renderer.h index 45d8d58f8821737bc79bf6cb7294b86b0fe8cce9..43856c6e1f051e42222071df5cae401d978be4fd 100644 --- a/frameworks/taihe/audiorenderer/taihe_audio_renderer.h +++ b/frameworks/taihe/audiorenderer/taihe_audio_renderer.h @@ -49,15 +49,25 @@ public: bool enqueued_ = false; void StartSync(); + void StartWithCallback(); + void StartReturnsPromise(); int64_t GetAudioTimeSync(); void DrainSync(); void FlushSync(); void PauseSync(); void StopSync(); + void StopWithCallback(); + void StopReturnsPromise(); void ReleaseSync(); + void ReleaseWithCallback(); + void ReleaseReturnsPromise(); int64_t GetBufferSizeSync(); + int64_t GetBufferSizeWithCallback(); + int64_t GetBufferSizeReturnsPromise(); int64_t GetAudioStreamIdSync(); void SetVolumeSync(double volume); + void SetVolumeWithCallback(double volume); + void SetVolumeReturnsPromise(double volume); double GetVolume(); AudioRendererInfo GetRendererInfoSync(); AudioStreamInfo GetStreamInfoSync(); @@ -78,21 +88,30 @@ public: bool GetSilentModeAndMixWithOthers(); void SetDefaultOutputDeviceSync(DeviceType deviceType); - void OnStateChange(callback_view callback); - void OnAudioInterrupt(callback_view callback); - void OnPeriodReach(int64_t frame, callback_view callback); - void OnMarkReach(int64_t frame, callback_view callback); - void OnOutputDeviceChange(callback_view)> callback); - void OnOutputDeviceChangeWithInfo(callback_view callback); - void OnWriteData(callback_view)> callback); - - void OffAudioInterrupt(optional_view> callback); - void OffStateChange(optional_view> callback); - void OffOutputDeviceChange(optional_view)>> callback); - void OffOutputDeviceChangeWithInfo(optional_view> callback); - void OffPeriodReach(optional_view> callback); - void OffMarkReach(optional_view> callback); - void OffWriteData(optional_view)>> callback); + void OnStateChange(::taihe::string_view type, callback_view callback); + void OnAudioInterrupt(::taihe::string_view type, + callback_view callback); + void OnPeriodReach(::taihe::string_view type, int64_t frame, callback_view callback); + void OnMarkReach(::taihe::string_view type, int64_t frame, callback_view callback); + void OnOutputDeviceChange(::taihe::string_view type, + callback_view)> callback); + void OnOutputDeviceChangeWithInfo(::taihe::string_view type, + callback_view callback); + void OnWriteData(::taihe::string_view type, + callback_view)> callback); + + void OffAudioInterrupt(::taihe::string_view type, + optional_view> callback); + void OffStateChange(::taihe::string_view type, optional_view> callback); + void OffOutputDeviceChange(::taihe::string_view type, + optional_view)>> callback); + void OffOutputDeviceChangeWithInfo(::taihe::string_view type, + optional_view> callback); + void OffPeriodReach(::taihe::string_view type, + optional_view> callback); + void OffMarkReach(::taihe::string_view type, optional_view> callback); + void OffWriteData(::taihe::string_view type, + optional_view)>> callback); void DestroyCallbacks(); void DestroyTaiheCallbacks(); diff --git a/frameworks/taihe/audiorenderer/taihe_toneplayer.cpp b/frameworks/taihe/audiorenderer/taihe_toneplayer.cpp index 185f4162f9fd256ce0639dc0efb42a92f0bff5b8..0b7d0dcfd3f84c18ba24724af27a3a8a0be6cdb4 100644 --- a/frameworks/taihe/audiorenderer/taihe_toneplayer.cpp +++ b/frameworks/taihe/audiorenderer/taihe_toneplayer.cpp @@ -81,6 +81,16 @@ void TonePlayerImpl::ReleaseSync() } } +void TonePlayerImpl::ReleaseWithCallback() +{ + return this->ReleaseSync(); +} + +void TonePlayerImpl::ReleaseReturnsPromise() +{ + return this->ReleaseSync(); +} + void TonePlayerImpl::StopSync() { CHECK_AND_RETURN_LOG(tonePlayer_ != nullptr, "tonePlayer_ is null."); @@ -90,6 +100,16 @@ void TonePlayerImpl::StopSync() } } +void TonePlayerImpl::StopWithCallback() +{ + return this->StopSync(); +} + +void TonePlayerImpl::StopReturnsPromise() +{ + return this->StopSync(); +} + void TonePlayerImpl::StartSync() { CHECK_AND_RETURN_LOG(tonePlayer_ != nullptr, "tonePlayer_ is null."); @@ -99,6 +119,16 @@ void TonePlayerImpl::StartSync() } } +void TonePlayerImpl::StartWithCallback() +{ + return this->StartSync(); +} + +void TonePlayerImpl::StartReturnsPromise() +{ + return this->StartSync(); +} + TonePlayer CreateTonePlayerSync(AudioRendererInfo const &options) { OHOS::AudioStandard::AudioRendererInfo rendererInfo; diff --git a/frameworks/taihe/audiorenderer/taihe_toneplayer.h b/frameworks/taihe/audiorenderer/taihe_toneplayer.h index 253c1430a834e8edcd790b43d41ea8745e92f14a..8780e3780ce9b021abacbb28485df2b9b8a4692e 100644 --- a/frameworks/taihe/audiorenderer/taihe_toneplayer.h +++ b/frameworks/taihe/audiorenderer/taihe_toneplayer.h @@ -41,8 +41,14 @@ public: void LoadSync(ToneType type); void ReleaseSync(); + void ReleaseWithCallback(); + void ReleaseReturnsPromise(); void StopSync(); + void StopWithCallback(); + void StopReturnsPromise(); void StartSync(); + void StartWithCallback(); + void StartReturnsPromise(); std::shared_ptr tonePlayer_; private: diff --git a/frameworks/taihe/idl/ohos.multimedia.audio.taihe b/frameworks/taihe/idl/ohos.multimedia.audio.taihe index fc1f93b6e0613481d60a62f3c10a0c829ef660da..2e092430ff11a8f96e013d912b27cb68f5069f99 100644 --- a/frameworks/taihe/idl/ohos.multimedia.audio.taihe +++ b/frameworks/taihe/idl/ohos.multimedia.audio.taihe @@ -343,16 +343,20 @@ struct DeviceBlockStatusInfo { } interface AudioRoutingManager { - @gen_async("getDevices") - @gen_promise("getDevices") GetDevicesSync(deviceFlag: DeviceFlag): Array; + @static_overload("getDevices") + @async GetDevicesWithCallback(deviceFlag: DeviceFlag): Array; + @static_overload("getDevices") + @promise GetDevicesReturnsPromise(deviceFlag: DeviceFlag): Array; GetAvailableDevices(deviceUsage: DeviceUsage): Array; GetExcludedDevices(deviceUsage: DeviceUsage): Array; - @gen_async("selectOutputDevice") - @gen_promise("selectOutputDevice") SelectOutputDeviceSync(outputAudioDevices: Array): void; + @static_overload("selectOutputDevice") + @async SelectOutputDeviceWithCallback(outputAudioDevices: Array): void; + @static_overload("selectOutputDevice") + @promise SelectOutputDeviceReturnsPromise(outputAudioDevices: Array): void; @gen_async("setCommunicationDevice") @gen_promise("setCommunicationDevice") @@ -362,22 +366,32 @@ interface AudioRoutingManager { @gen_promise("isCommunicationDeviceActive") IsCommunicationDeviceActiveSync(deviceType: CommunicationDeviceType): bool; - @gen_async("selectOutputDeviceByFilter") - @gen_promise("selectOutputDeviceByFilter") SelectOutputDeviceByFilterSync(filter: AudioRendererFilter, outputAudioDevices: Array): void; + @static_overload("selectOutputDeviceByFilter") + @async SelectOutputDeviceByFilterWithCallback(filter: AudioRendererFilter, outputAudioDevices: + Array): void; + @static_overload("selectOutputDeviceByFilter") + @promise SelectOutputDeviceByFilterReturnsPromise(filter: AudioRendererFilter, outputAudioDevices: + Array): void; - @gen_async("selectInputDevice") - @gen_promise("selectInputDevice") SelectInputDeviceSync(inputAudioDevices: Array): void; + @static_overload("selectInputDevice") + @async SelectInputDeviceWithCallback(inputAudioDevices: Array): void; + @static_overload("selectInputDevice") + @promise SelectInputDeviceReturnsPromise(inputAudioDevices: Array): void; - @gen_async("getPreferOutputDeviceForRendererInfo") - @gen_promise("getPreferOutputDeviceForRendererInfo") GetPreferredOutputDeviceForRendererInfoSync(rendererInfo: AudioRendererInfo): Array; + @static_overload("getPreferOutputDeviceForRendererInfo") + @async GetPreferOutputDeviceForRendererInfoWithCallback(rendererInfo: AudioRendererInfo): Array; + @static_overload("getPreferOutputDeviceForRendererInfo") + @promise GetPreferOutputDeviceForRendererInfoReturnsPromise(rendererInfo: AudioRendererInfo): Array; - @gen_async("getPreferredInputDeviceForCapturerInfo") - @gen_promise("getPreferredInputDeviceForCapturerInfo") GetPreferredInputDeviceForCapturerInfoSync(capturerInfo: AudioCapturerInfo): Array; + @static_overload("getPreferredInputDeviceForCapturerInfo") + @async GetPreferredInputDeviceForCapturerInfoWithCallback(capturerInfo: AudioCapturerInfo): Array; + @static_overload("getPreferredInputDeviceForCapturerInfo") + @promise GetPreferredInputDeviceForCapturerInfoReturnsPromise(capturerInfo: AudioCapturerInfo): Array; GetPreferredInputDeviceByFilter(filter: AudioCapturerFilter): Array; @@ -398,113 +412,61 @@ interface AudioRoutingManager { @gen_promise("unexcludeOutputDevices") UnexcludeOutputDevicesWithUsage(usage: DeviceUsage): void; - @!sts_inject_into_interface("on(type: string, capturerInfo: AudioCapturerInfo, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, capturerInfo: AudioCapturerInfo, callback: object): void { - if (type === "preferredInputDeviceChangeForCapturerInfo") { - this.onPreferredInputDeviceChangeForCapturerInfo(capturerInfo, callback as (data: (AudioDeviceDescriptor[])) => void); - } - } - """) - OnPreferredInputDeviceChangeForCapturerInfo(capturerInfo: AudioCapturerInfo, callback: (data: Array) => void): void; - - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "micBlockStatusChanged") { - this.onMicBlockStatusChanged(callback as (data: DeviceBlockStatusInfo) => void); - } - } - """) - OnMicBlockStatusChanged(callback: (data: DeviceBlockStatusInfo) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "micBlockStatusChanged") { - this.offMicBlockStatusChanged(callback as ((data: DeviceBlockStatusInfo) => void) | undefined); - } else if (type === "preferredInputDeviceChangeForCapturerInfo") { - this.offPreferredInputDeviceChangeForCapturerInfo(callback as ((data: (AudioDeviceDescriptor[])) => void) | undefined); - } else if (type === "preferOutputDeviceChangeForRendererInfo") { - this.offPreferOutputDeviceChangeForRendererInfo(callback as ((data: (AudioDeviceDescriptor[])) => void) | undefined); - } else if (type === "deviceChange") { - this.offDeviceChange(callback as ((data: DeviceChangeAction) => void) | undefined); - } else if (type === "availableDeviceChange") { - this.offAvailableDeviceChange(callback as ((data: DeviceChangeAction) => void) | undefined); - } - } - """) - OffMicBlockStatusChanged(callback: Optional<(data: DeviceBlockStatusInfo) => void>): void; - OffPreferredInputDeviceChangeForCapturerInfo(callback: Optional<(data: Array) => void>): void; - OffPreferOutputDeviceChangeForRendererInfo(callback: Optional<(data: Array) => void>): void; - OffDeviceChange(callback: Optional<(data: DeviceChangeAction) => void>): void; - OffAvailableDeviceChange(callback: Optional<(data: DeviceChangeAction) => void>): void; - - @!sts_inject_into_interface("on(type: string, deviceFlag: DeviceFlag, callback: (data: object) => void): void;") - @!sts_inject_into_interface("on(type: string, deviceUsage: DeviceUsage, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, deviceFlag: DeviceFlag, callback: object): void { - if (type === "deviceChange") { - this.onDeviceChange(deviceFlag, callback as (data: DeviceChangeAction) => void); - } - } - """) - - @!sts_inject_into_class("""on(type: string, deviceUsage: DeviceUsage, callback: object): void { - if (type === "availableDeviceChange") { - this.onAvailableDeviceChange(deviceUsage, callback as (data: DeviceChangeAction) => void); - } - } - """) - - @!sts_inject_into_interface("on(type: string, rendererInfo: AudioRendererInfo, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, rendererInfo: AudioRendererInfo, callback: object): void { - if (type === "preferOutputDeviceChangeForRendererInfo") { - this.onPreferOutputDeviceChangeForRendererInfo(rendererInfo, callback as (data: (AudioDeviceDescriptor[])) => void); - } - } - """) - OnDeviceChange(deviceFlag: DeviceFlag, callback: (data: DeviceChangeAction) => void): void; - OnAvailableDeviceChange(deviceUsage: DeviceUsage, callback: (data: DeviceChangeAction) => void): void; - OnPreferOutputDeviceChangeForRendererInfo(rendererInfo: AudioRendererInfo, callback: (data: Array) => void): void; + @static_overload("off") + OffMicBlockStatusChanged(type: String, callback: Optional<(data: DeviceBlockStatusInfo) => void>): void; + @static_overload("off") + OffPreferredInputDeviceChangeForCapturerInfo(type: String, callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffPreferOutputDeviceChangeForRendererInfo(type: String, callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffDeviceChange(type: String, callback: Optional<(data: DeviceChangeAction) => void>): void; + @static_overload("off") + OffAvailableDeviceChange(type: String, callback: Optional<(data: DeviceChangeAction) => void>): void; + + @static_overload("on") + OnMicBlockStatusChanged(type: String, callback: (data: DeviceBlockStatusInfo) => void): void; + @static_overload("on") + OnPreferredInputDeviceChangeForCapturerInfo(type: String, capturerInfo: AudioCapturerInfo, callback: (data: Array) => void): void; + @static_overload("on") + OnPreferOutputDeviceChangeForRendererInfo(type: String, rendererInfo: AudioRendererInfo, callback: (data: Array) => void): void; + @static_overload("on") + OnDeviceChange(type: String, deviceFlag: DeviceFlag, callback: (data: DeviceChangeAction) => void): void; + @static_overload("on") + OnAvailableDeviceChange(type: String, deviceUsage: DeviceUsage, callback: (data: DeviceChangeAction) => void): void; } interface AudioStreamManager { - @gen_async("getCurrentAudioRendererInfoArray") - @gen_promise("getCurrentAudioRendererInfoArray") GetCurrentAudioRendererInfoArraySync(): Array; + @static_overload("getCurrentAudioRendererInfoArray") + @async GetCurrentAudioRendererInfoArrayWithCallback(): Array; + @static_overload("getCurrentAudioRendererInfoArray") + @promise GetCurrentAudioRendererInfoArrayReturnsPromise(): Array; - @gen_async("getCurrentAudioCapturerInfoArray") - @gen_promise("getCurrentAudioCapturerInfoArray") GetCurrentAudioCapturerInfoArraySync(): Array; + @static_overload("getCurrentAudioCapturerInfoArray") + @async GetCurrentAudioCapturerInfoArrayWithCallback(): Array; + @static_overload("getCurrentAudioCapturerInfoArray") + @promise GetCurrentAudioCapturerInfoArrayReturnsPromise(): Array; @gen_async("getAudioEffectInfoArray") @gen_promise("getAudioEffectInfoArray") GetAudioEffectInfoArraySync(usage: StreamUsage): Array; - @gen_async("isActive") - @gen_promise("isActive") IsActiveSync(volumeType: AudioVolumeType): bool; + @static_overload("isActive") + @async IsActiveWithCallback(volumeType: AudioVolumeType): bool; + @static_overload("isActive") + @promise IsActiveReturnsPromise(volumeType: AudioVolumeType): bool; + + @static_overload("on") + OnAudioRendererChange(type: String, callback: (data: Array) => void): void; + @static_overload("on") + OnAudioCapturerChange(type: String, callback: (data: Array) => void): void; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "audioRendererChange") { - this.onAudioRendererChange(callback as (data: (AudioRendererChangeInfo[])) => void); - } else if (type === "audioCapturerChange") { - this.onAudioCapturerChange(callback as (data: (AudioCapturerChangeInfo[])) => void); - } - } - """) - OnAudioRendererChange(callback: (data: Array) => void): void; - OnAudioCapturerChange(callback: (data: Array) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "audioRendererChange") { - this.offAudioRendererChange(callback as ((data: AudioRendererChangeInfo[]) => void) | undefined); - } else if (type === "audioCapturerChange") { - this.offAudioCapturerChange(callback as ((data: AudioCapturerChangeInfo[]) => void) | undefined); - } - } - """) - OffAudioRendererChange(callback: Optional<(data: Array) => void>): void; - OffAudioCapturerChange(callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffAudioRendererChange(type: String, callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffAudioCapturerChange(type: String, callback: Optional<(data: Array) => void>): void; } interface AudioVolumeManager { @@ -512,9 +474,11 @@ interface AudioVolumeManager { @gen_promise("getVolumeGroupInfos") GetVolumeGroupInfosSync(networkId: String): Array; - @gen_async("getVolumeGroupManager") - @gen_promise("getVolumeGroupManager") GetVolumeGroupManagerSync(groupId: i32): AudioVolumeGroupManager; + @static_overload("getVolumeGroupManager") + @async GetVolumeGroupManagerWithCallback(groupId: i32): AudioVolumeGroupManager; + @static_overload("getVolumeGroupManager") + @promise GetVolumeGroupManagerReturnsPromise(groupId: i32): AudioVolumeGroupManager; @gen_promise("getAppVolumePercentageForUid") GetAppVolumePercentageForUidSync(uid: i32): i32; @@ -534,80 +498,74 @@ interface AudioVolumeManager { @gen_promise("setAppVolumePercentage") SetAppVolumePercentageSync(volume: i32): void; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "volumeChange") { - this.onVolumeChange(callback as (data: VolumeEvent) => void); - } else if (type === "appVolumeChange") { - this.onAppVolumeChange(callback as (data: VolumeEvent) => void); - } - } - """) - OnVolumeChange(callback: (data: VolumeEvent) => void): void; - OnAppVolumeChange(callback: (data: VolumeEvent) => void): void; - - @!sts_inject_into_interface("on(type: string, uid: int, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, uid: int, callback: object): void { - if (type === "appVolumeChangeForUid") { - this.onAppVolumeChangeForUid(uid, callback as (data: VolumeEvent) => void); - } - } - """) - OnAppVolumeChangeForUid(uid: i32, callback: (data: VolumeEvent) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "volumeChange") { - this.offVolumeChange(callback as ((data: VolumeEvent) => void) | undefined); - } else if (type === "appVolumeChange") { - this.offAppVolumeChange(callback as ((data: VolumeEvent) => void) | undefined); - } else if (type === "appVolumeChangeForUid") { - this.offAppVolumeChangeForUid(callback as ((data: VolumeEvent) => void) | undefined); - } - } - """) - OffVolumeChange(callback: Optional<(data: VolumeEvent)=> void>): void; - OffAppVolumeChange(callback: Optional<(data: VolumeEvent)=> void>): void; - OffAppVolumeChangeForUid(callback: Optional<(data: VolumeEvent)=> void>): void; + @static_overload("on") + OnVolumeChange(type: String, callback: (data: VolumeEvent) => void): void; + @static_overload("on") + OnAppVolumeChange(type: String, callback: (data: VolumeEvent) => void): void; + @static_overload("on") + OnAppVolumeChangeForUid(type: String, uid: i32, callback: (data: VolumeEvent) => void): void; + + @static_overload("off") + OffVolumeChange(type: String, callback: Optional<(data: VolumeEvent)=> void>): void; + @static_overload("off") + OffAppVolumeChange(type: String, callback: Optional<(data: VolumeEvent)=> void>): void; + @static_overload("off") + OffAppVolumeChangeForUid(type: String, callback: Optional<(data: VolumeEvent)=> void>): void; } interface AudioVolumeGroupManager { - @gen_async("setVolume") - @gen_promise("setVolume") SetVolumeSync(volumeType: AudioVolumeType, volume: i32): void; + @static_overload("setVolume") + @async SetVolumeWithCallback(volumeType: AudioVolumeType, volume: i32): void; + @static_overload("setVolume") + @promise SetVolumeReturnsPromise(volumeType: AudioVolumeType, volume: i32): void; @gen_promise("setVolumeWithFlag") SetVolumeWithFlagSync(volumeType: AudioVolumeType, volume: i32, flags: i32): void; GetActiveVolumeTypeSync(uid: i32): AudioVolumeType; - @gen_async("getVolume") - @gen_promise("getVolume") GetVolumeSync(volumeType: AudioVolumeType): i32; + @static_overload("getVolume") + @async GetVolumeWithVolumeTypeCallback(volumeType: AudioVolumeType): i32; + @static_overload("getVolume") + @promise GetVolumeWithVolumeTypeReturnsPromise(volumeType: AudioVolumeType): i32; - @gen_async("getMinVolume") - @gen_promise("getMinVolume") GetMinVolumeSync(volumeType: AudioVolumeType): i32; + @static_overload("getMinVolume") + @async GetMinVolumeWithCallback(volumeType: AudioVolumeType): i32; + @static_overload("getMinVolume") + @promise GetMinVolumeReturnsPromise(volumeType: AudioVolumeType): i32; - @gen_async("getMaxVolume") - @gen_promise("getMaxVolume") GetMaxVolumeSync(volumeType: AudioVolumeType): i32; + @static_overload("getMaxVolume") + @async GetMaxVolumeWithCallback(volumeType: AudioVolumeType): i32; + @static_overload("getMaxVolume") + @promise GetMaxVolumeReturnsPromise(volumeType: AudioVolumeType): i32; - @gen_async("mute") - @gen_promise("mute") MuteSync(volumeType: AudioVolumeType, mute: bool): void; + @static_overload("mute") + @async MuteWithCallback(volumeType: AudioVolumeType, mute: bool): void; + @static_overload("mute") + @promise MuteReturnsPromise(volumeType: AudioVolumeType, mute: bool): void; - @gen_async("isMute") - @gen_promise("isMute") IsMuteSync(volumeType: AudioVolumeType): bool; + @static_overload("isMute") + @async IsMuteWithCallback(volumeType: AudioVolumeType): bool; + @static_overload("isMute") + @promise IsMuteReturnsPromise(volumeType: AudioVolumeType): bool; - @gen_async("setRingerMode") - @gen_promise("setRingerMode") SetRingerModeSync(mode: AudioRingMode): void; + @static_overload("setRingerMode") + @async SetRingerModeWithCallback(mode: AudioRingMode): void; + @static_overload("setRingerMode") + @promise SetRingerModeReturnsPromise(mode: AudioRingMode): void; - @gen_async("getRingerMode") - @gen_promise("getRingerMode") GetRingerModeSync(): AudioRingMode; + @static_overload("getRingerMode") + @async GetRingerModeWithCallback(): AudioRingMode; + @static_overload("getRingerMode") + @promise GetRingerModeReturnsPromise(): AudioRingMode; @gen_promise("setMicMute") SetMicMuteSync(mute: bool): void; @@ -617,39 +575,27 @@ interface AudioVolumeGroupManager { IsPersistentMicMute(): bool; - @gen_async("isMicrophoneMute") - @gen_promise("isMicrophoneMute") IsMicrophoneMuteSync(): bool; + @static_overload("isMicrophoneMute") + @async IsMicrophoneMuteWithCallback(): bool; + @static_overload("isMicrophoneMute") + @promise IsMicrophoneMuteReturnsPromise(): bool; - @gen_async("adjustVolumeByStep") - @gen_promise("adjustVolumeByStep") AdjustVolumeByStepSync(adjustType: VolumeAdjustType): void; + @static_overload("adjustVolumeByStep") + @async AdjustVolumeByStepWithCallback(adjustType: VolumeAdjustType): void; + @static_overload("adjustVolumeByStep") + @promise AdjustVolumeByStepReturnsPromise(adjustType: VolumeAdjustType): void; + + @static_overload("on") + OnRingerModeChange(type: String, callback: (data: AudioRingMode) => void): void; + @static_overload("on") + OnMicStateChange(type: String, callback: (data: MicStateChangeEvent) => void): void; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "ringerModeChange") { - this.onRingerModeChange(callback as (data: AudioRingMode) => void); - } else if (type === "micStateChange") { - this.onMicStateChange(callback as (data: MicStateChangeEvent) => void); - } - } - """) - - OnRingerModeChange(callback: (data: AudioRingMode) => void): void; - OnMicStateChange(callback: (data: MicStateChangeEvent) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "ringerModeChange") { - this.offRingerModeChange(callback as ((data: AudioRingMode) => void) | undefined); - } else if (type === "micStateChange") { - this.offMicStateChange(callback as ((data: MicStateChangeEvent) => void) | undefined); - } - } - """) - - OffRingerModeChange(callback: Optional<(data: AudioRingMode) => void>): void; - OffMicStateChange(callback: Optional<(data: MicStateChangeEvent) => void>): void; + @static_overload("off") + OffRingerModeChange(type: String, callback: Optional<(data: AudioRingMode) => void>): void; + @static_overload("off") + OffMicStateChange(type: String, callback: Optional<(data: MicStateChangeEvent) => void>): void; IsVolumeUnadjustable(): bool; @@ -789,17 +735,23 @@ interface TonePlayer { @gen_promise("load") LoadSync(type: ToneType): void; - @gen_async("release") - @gen_promise("release") ReleaseSync(): void; + @static_overload("release") + @async ReleaseWithCallback(): void; + @static_overload("release") + @promise ReleaseReturnsPromise(): void; - @gen_async("stop") - @gen_promise("stop") StopSync(): void; + @static_overload("stop") + @async StopWithCallback(): void; + @static_overload("stop") + @promise StopReturnsPromise(): void; - @gen_async("start") - @gen_promise("start") StartSync(): void; + @static_overload("start") + @async StartWithCallback(): void; + @static_overload("start") + @promise StartReturnsPromise(): void; } enum AudioConcurrencyMode: i32 { @@ -831,23 +783,11 @@ interface AudioSessionManager { IsAudioSessionActivated(): bool; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "audioSessionDeactivated") { - this.onAudioSessionDeactivated(callback as (data: AudioSessionDeactivatedEvent) => void); - } - } - """) - OnAudioSessionDeactivated(callback: (data: AudioSessionDeactivatedEvent) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "audioSessionDeactivated") { - this.offAudioSessionDeactivated(callback as ((data: AudioSessionDeactivatedEvent) => void) | undefined); - } - } - """) - OffAudioSessionDeactivated(callback: Optional<(data: AudioSessionDeactivatedEvent) => void>): void; + @rename("on") + OnAudioSessionDeactivated(type: String, callback: (data: AudioSessionDeactivatedEvent) => void): void; + + @rename("off") + OffAudioSessionDeactivated(type: String, callback: Optional<(data: AudioSessionDeactivatedEvent) => void>): void; } enum EffectFlag: i32 { @@ -896,21 +836,29 @@ interface AudioCapturer { GetImplPtr(): i64; - @gen_async("start") - @gen_promise("start") StartSync(): void; + @static_overload("start") + @async StartWithCallback(): void; + @static_overload("start") + @promise StartReturnsPromise(): void; - @gen_async("stop") - @gen_promise("stop") StopSync(): void; + @static_overload("stop") + @async StopWithCallback(): void; + @static_overload("stop") + @promise StopReturnsPromise(): void; - @gen_async("release") - @gen_promise("release") ReleaseSync(): void; + @static_overload("release") + @async ReleaseWithCallback(): void; + @static_overload("release") + @promise ReleaseReturnsPromise(): void; - @gen_async("getBufferSize") - @gen_promise("getBufferSize") GetBufferSizeSync(): i64; + @static_overload("getBufferSize") + @async GetBufferSizeWithCallback(): i64; + @static_overload("getBufferSize") + @promise GetBufferSizeReturnsPromise(): i64; @gen_async("getCapturerInfo") @gen_promise("getCapturerInfo") @@ -938,65 +886,35 @@ interface AudioCapturer { GetCurrentAudioCapturerChangeInfo(): AudioCapturerChangeInfo; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "stateChange") { - this.onStateChange(callback as (data: AudioState) => void); - } else if (type === "audioInterrupt") { - this.onAudioInterrupt(callback as (data: InterruptEvent) => void); - } else if (type === "inputDeviceChange") { - this.onInputDeviceChange(callback as (data: (AudioDeviceDescriptor[])) => void); - } else if (type === "audioCapturerChange") { - this.onAudioCapturerChange(callback as (data: AudioCapturerChangeInfo) => void); - } else if (type === "readData") { - this.onReadData(callback as (data: ArrayBuffer) => void); - } - } - """) - OnAudioInterrupt(callback: (data: InterruptEvent) => void): void; - OnStateChange(callback: (data: AudioState) => void): void; - OnInputDeviceChange(callback: (data: Array) => void): void; - OnAudioCapturerChange(callback: (data: AudioCapturerChangeInfo) => void): void; - OnReadData(callback: (data: @arraybuffer Array) => void): void; - - @!sts_inject_into_interface("on(type: string, frame: long, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, frame: long, callback: object): void { - if (type === "periodReach") { - this.onPeriodReach(frame, callback as (data: long) => void); - } else if (type === "markReach") { - this.onMarkReach(frame, callback as (data: long) => void); - } - } - """) - OnPeriodReach(frame: i64, callback: (data: i64) => void): void; - OnMarkReach(frame: i64, callback: (data: i64) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "stateChange") { - this.offStateChange(callback as (((data: AudioState) => void) | undefined)); - } else if (type === "audioInterrupt") { - this.offAudioInterrupt(callback as (((data: InterruptEvent) => void) | undefined)); - } else if (type === "inputDeviceChange") { - this.offInputDeviceChange(callback as (((data: (AudioDeviceDescriptor[])) => void) | undefined)); - } else if (type === "audioCapturerChange") { - this.offAudioCapturerChange(callback as (((data: AudioCapturerChangeInfo) => void) | undefined)); - } else if (type === "readData") { - this.offReadData(callback as (((data: ArrayBuffer) => void) | undefined)); - } else if (type === "periodReach") { - this.offPeriodReach(callback as (((data: long) => void) | undefined)); - } else if (type === "markReach") { - this.offMarkReach(callback as (((data: long) => void) | undefined)); - } - } - """) - OffStateChange(callback: Optional<(data: AudioState) => void>): void; - OffAudioInterrupt(callback: Optional<(data: InterruptEvent) => void>): void; - OffInputDeviceChange(callback: Optional<(data: Array) => void>): void; - OffAudioCapturerChange(callback: Optional<(data: AudioCapturerChangeInfo) => void>): void; - OffReadData(callback: Optional<(data: @arraybuffer Array) => void>): void; - OffPeriodReach(callback: Optional<(data: i64) => void>): void; - OffMarkReach(callback: Optional<(data: i64) => void>): void; + @static_overload("on") + OnAudioInterrupt(type: String, callback: (data: InterruptEvent) => void): void; + @static_overload("on") + OnStateChange(type: String, callback: (data: AudioState) => void): void; + @static_overload("on") + OnInputDeviceChange(type: String, callback: (data: Array) => void): void; + @static_overload("on") + OnAudioCapturerChange(type: String, callback: (data: AudioCapturerChangeInfo) => void): void; + @static_overload("on") + OnReadData(type: String, callback: (data: @arraybuffer Array) => void): void; + @static_overload("on") + OnPeriodReach(type: String, frame: i64, callback: (data: i64) => void): void; + @static_overload("on") + OnMarkReach(type: String, frame: i64, callback: (data: i64) => void): void; + + @static_overload("off") + OffStateChange(type: String, callback: Optional<(data: AudioState) => void>): void; + @static_overload("off") + OffAudioInterrupt(type: String, callback: Optional<(data: InterruptEvent) => void>): void; + @static_overload("off") + OffInputDeviceChange(type: String, callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffAudioCapturerChange(type: String, callback: Optional<(data: AudioCapturerChangeInfo) => void>): void; + @static_overload("off") + OffReadData(type: String, callback: Optional<(data: @arraybuffer Array) => void>): void; + @static_overload("off") + OffPeriodReach(type: String, callback: Optional<(data: i64) => void>): void; + @static_overload("off") + OffMarkReach(type: String, callback: Optional<(data: i64) => void>): void; } enum AudioDataCallbackResult: i32 { @@ -1032,9 +950,11 @@ interface AudioRenderer { @gen_promise("setAudioEffectMode") SetAudioEffectModeSync(mode: AudioEffectMode): void; - @gen_async("start") - @gen_promise("start") StartSync(): void; + @static_overload("start") + @async StartWithCallback(): void; + @static_overload("start") + @promise StartReturnsPromise(): void; @gen_async("getAudioTime") @gen_promise("getAudioTime") @@ -1054,17 +974,23 @@ interface AudioRenderer { @gen_promise("pause") PauseSync(): void; - @gen_async("stop") - @gen_promise("stop") StopSync(): void; + @static_overload("stop") + @async StopWithCallback(): void; + @static_overload("stop") + @promise StopReturnsPromise(): void; - @gen_async("release") - @gen_promise("release") ReleaseSync(): void; + @static_overload("release") + @async ReleaseWithCallback(): void; + @static_overload("release") + @promise ReleaseReturnsPromise(): void; - @gen_async("getBufferSize") - @gen_promise("getBufferSize") GetBufferSizeSync(): i64; + @static_overload("getBufferSize") + @async GetBufferSizeWithCallback(): i64; + @static_overload("getBufferSize") + @promise GetBufferSizeReturnsPromise(): i64; SetSpeed(speed: f64): void; @@ -1074,10 +1000,13 @@ interface AudioRenderer { @gen_promise("setInterruptMode") SetInterruptModeSync(mode: InterruptMode): void; - @gen_async("setVolume") - @gen_promise("setVolume") SetVolumeSync(volume: f64): void; + @static_overload("setVolume") + @async SetVolumeWithCallback(volume: f64): void; + @static_overload("setVolume") + @promise SetVolumeReturnsPromise(volume: f64): void; + @static_overload("getVolume") GetVolume(): f64; SetVolumeWithRamp(volume: f64, duration: i32): void; @@ -1107,65 +1036,35 @@ interface AudioRenderer { @gen_promise("setDefaultOutputDevice") SetDefaultOutputDeviceSync(deviceType: DeviceType): void; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => object): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "stateChange") { - this.onStateChange(callback as (data: AudioState) => void); - } else if (type === "audioInterrupt") { - this.onAudioInterrupt(callback as (data: InterruptEvent) => void); - } else if (type === "outputDeviceChange") { - this.onOutputDeviceChange(callback as (data: (AudioDeviceDescriptor[])) => void); - } else if (type === "outputDeviceChangeWithInfo") { - this.onOutputDeviceChangeWithInfo(callback as (data: AudioStreamDeviceChangeInfo) => void); - } else if (type === "writeData") { - this.onWriteData(callback as (data: ArrayBuffer) => AudioDataCallbackResult); - } - } - """) - OnAudioInterrupt(callback: (data: InterruptEvent) => void): void; - OnStateChange(callback: (data: AudioState) => void): void; - OnOutputDeviceChange(callback: (data: Array) => void): void; - OnOutputDeviceChangeWithInfo(callback: (data: AudioStreamDeviceChangeInfo) => void): void; - OnWriteData(callback: (data: @arraybuffer Array) => AudioDataCallbackResult): void; - - @!sts_inject_into_interface("on(type: string, frame: long, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, frame: long, callback: object): void { - if (type === "periodReach") { - this.onPeriodReach(frame, callback as (data: long) => void); - } else if (type === "markReach") { - this.onMarkReach(frame, callback as (data: long) => void); - } - } - """) - OnPeriodReach(frame: i64, callback: (data: i64) => void): void; - OnMarkReach(frame: i64, callback: (data: i64) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "stateChange") { - this.offStateChange(callback as (((data: AudioState) => void) | undefined)); - } else if (type === "audioInterrupt") { - this.offAudioInterrupt(callback as (((data: InterruptEvent) => void) | undefined)); - } else if (type === "outputDeviceChange") { - this.offOutputDeviceChange(callback as (((data: (AudioDeviceDescriptor[])) => void) | undefined)); - } else if (type === "outputDeviceChangeWithInfo") { - this.offOutputDeviceChangeWithInfo(callback as (((data: AudioStreamDeviceChangeInfo) => void) | undefined)); - } else if (type === "periodReach") { - this.offPeriodReach(callback as (((data: long) => void) | undefined)); - } else if (type === "markReach") { - this.offMarkReach(callback as (((data: long) => void) | undefined)); - } else if (type === "writeData") { - this.offWriteData(callback as (((data: ArrayBuffer) => AudioDataCallbackResult) | undefined)); - } - } - """) - OffAudioInterrupt(callback: Optional<(data: InterruptEvent) => void>): void; - OffStateChange(callback: Optional<(data: AudioState) => void>): void; - OffOutputDeviceChange(callback: Optional<(data: Array) => void>): void; - OffOutputDeviceChangeWithInfo(callback: Optional<(data: AudioStreamDeviceChangeInfo) => void>): void; - OffPeriodReach(callback: Optional<(data: i64) => void>): void; - OffMarkReach(callback: Optional<(data: i64) => void>): void; - OffWriteData(callback: Optional<(data: @arraybuffer Array) => AudioDataCallbackResult>): void; + @static_overload("on") + OnAudioInterrupt(type: String, callback: (data: InterruptEvent) => void): void; + @static_overload("on") + OnStateChange(type: String, callback: (data: AudioState) => void): void; + @static_overload("on") + OnOutputDeviceChange(type: String, callback: (data: Array) => void): void; + @static_overload("on") + OnOutputDeviceChangeWithInfo(type: String, callback: (data: AudioStreamDeviceChangeInfo) => void): void; + @static_overload("on") + OnWriteData(type: String, callback: (data: @arraybuffer Array) => AudioDataCallbackResult): void; + @static_overload("on") + OnPeriodReach(type: String, frame: i64, callback: (data: i64) => void): void; + @static_overload("on") + OnMarkReach(type: String, frame: i64, callback: (data: i64) => void): void; + + @static_overload("off") + OffAudioInterrupt(type: String, callback: Optional<(data: InterruptEvent) => void>): void; + @static_overload("off") + OffStateChange(type: String, callback: Optional<(data: AudioState) => void>): void; + @static_overload("off") + OffOutputDeviceChange(type: String, callback: Optional<(data: Array) => void>): void; + @static_overload("off") + OffOutputDeviceChangeWithInfo(type: String, callback: Optional<(data: AudioStreamDeviceChangeInfo) => void>): void; + @static_overload("off") + OffPeriodReach(type: String, callback: Optional<(data: i64) => void>): void; + @static_overload("off") + OffMarkReach(type: String, callback: Optional<(data: i64) => void>): void; + @static_overload("off") + OffWriteData(type: String, callback: Optional<(data: @arraybuffer Array) => AudioDataCallbackResult>): void; } enum AudioEffectMode: i32 { @@ -1250,9 +1149,11 @@ enum AudioChannelLayout: i64 { function GetAudioManager(): AudioManager; -@gen_async("createAudioCapturer") -@gen_promise("createAudioCapturer") function CreateAudioCapturerSync(options: AudioCapturerOptions): AudioCapturer; +@static_overload("createAudioCapturer") +@async function CreateAudioCapturerWithCallback(options: AudioCapturerOptions): AudioCapturer; +@static_overload("createAudioCapturer") +@promise function CreateAudioCapturerReturnsPromise(options: AudioCapturerOptions): AudioCapturer; @gen_async("createAudioRenderer") @gen_promise("createAudioRenderer") @@ -1290,35 +1191,19 @@ interface AudioSpatializationManager { SetSpatializationSceneType(spatializationSceneType: AudioSpatializationSceneType): void; GetSpatializationSceneType(): AudioSpatializationSceneType; - @!sts_inject_into_interface("on(type: string, callback: (data: object) => void): void;") - @!sts_inject_into_class("""on(type: string, callback: object): void { - if (type === "spatializationEnabledChangeForCurrentDevice") { - this.onSpatializationEnabledChangeForCurrentDevice(callback as (data: boolean) => void); - } else if (type === "spatializationEnabledChangeForAnyDevice") { - this.onSpatializationEnabledChangeForAnyDevice(callback as (data: AudioSpatialEnabledStateForDevice) => void); - } else if (type === "headTrackingEnabledChangeForAnyDevice") { - this.onHeadTrackingEnabledChangeForAnyDevice(callback as (data: AudioSpatialEnabledStateForDevice) => void); - } - } - """) - OnSpatializationEnabledChangeForCurrentDevice(callback: (data: bool) => void): void; - OnSpatializationEnabledChangeForAnyDevice(callback: (data: AudioSpatialEnabledStateForDevice) => void): void; - OnHeadTrackingEnabledChangeForAnyDevice(callback: (data: AudioSpatialEnabledStateForDevice) => void): void; - - @!sts_inject_into_interface("off(type: string, callback?: (data: object) => void): void;") - @!sts_inject_into_class("""off(type: string, callback?: object): void { - if (type === "spatializationEnabledChangeForCurrentDevice") { - this.offSpatializationEnabledChangeForCurrentDevice(callback as ((data: boolean) => void) | undefined); - } else if (type === "spatializationEnabledChangeForAnyDevice") { - this.offSpatializationEnabledChangeForAnyDevice(callback as ((data: AudioSpatialEnabledStateForDevice) => void) | undefined); - } else if (type === "headTrackingEnabledChangeForAnyDevice") { - this.offHeadTrackingEnabledChangeForAnyDevice(callback as ((data: AudioSpatialEnabledStateForDevice) => void) | undefined); - } - } - """) - OffSpatializationEnabledChangeForCurrentDevice(callback: Optional<(data: bool) => void>): void; - OffSpatializationEnabledChangeForAnyDevice(callback: Optional<(data: AudioSpatialEnabledStateForDevice) => void>): void; - OffHeadTrackingEnabledChangeForAnyDevice(callback: Optional<(data: AudioSpatialEnabledStateForDevice) => void>): void; + @static_overload("on") + OnSpatializationEnabledChangeForCurrentDevice(type: String, callback: (data: bool) => void): void; + @static_overload("on") + OnSpatializationEnabledChangeForAnyDevice(type: String, callback: (data: AudioSpatialEnabledStateForDevice) => void): void; + @static_overload("on") + OnHeadTrackingEnabledChangeForAnyDevice(type: String, callback: (data: AudioSpatialEnabledStateForDevice) => void): void; + + @static_overload("off") + OffSpatializationEnabledChangeForCurrentDevice(type: String, callback: Optional<(data: bool) => void>): void; + @static_overload("off") + OffSpatializationEnabledChangeForAnyDevice(type: String, callback: Optional<(data: AudioSpatialEnabledStateForDevice) => void>): void; + @static_overload("off") + OffHeadTrackingEnabledChangeForAnyDevice(type: String, callback: Optional<(data: AudioSpatialEnabledStateForDevice) => void>): void; } enum AsrNoiseSuppressionMode: i32 {