diff --git a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp index 07313105fb0ab363065aed5169ec11ffc39f6979..182ac69865fdb5699c9845744ffa43501f8f1389 100644 --- a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp +++ b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp @@ -97,7 +97,6 @@ void AudioCapturerNapi::Destructor(napi_env env, void *nativeObject, void *final napi_value AudioCapturerNapi::Init(napi_env env, napi_value exports) { - napi_status status; napi_value constructor; napi_value result = nullptr; const int32_t refCount = 1; @@ -105,14 +104,19 @@ napi_value AudioCapturerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor audio_capturer_properties[] = { DECLARE_NAPI_FUNCTION("getCapturerInfo", GetCapturerInfo), + DECLARE_NAPI_FUNCTION("getCapturerInfoSync", GetCapturerInfoSync), DECLARE_NAPI_FUNCTION("getStreamInfo", GetStreamInfo), + DECLARE_NAPI_FUNCTION("getStreamInfoSync", GetStreamInfoSync), DECLARE_NAPI_FUNCTION("start", Start), DECLARE_NAPI_FUNCTION("read", Read), DECLARE_NAPI_FUNCTION("getAudioTime", GetAudioTime), + DECLARE_NAPI_FUNCTION("getAudioTimeSync", GetAudioTimeSync), DECLARE_NAPI_FUNCTION("stop", Stop), DECLARE_NAPI_FUNCTION("release", Release), DECLARE_NAPI_FUNCTION("getBufferSize", GetBufferSize), + DECLARE_NAPI_FUNCTION("getBufferSizeSync", GetBufferSizeSync), DECLARE_NAPI_FUNCTION("getAudioStreamId", GetAudioStreamId), + DECLARE_NAPI_FUNCTION("getAudioStreamIdSync", GetAudioStreamIdSync), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("getCurrentInputDevices", GetCurrentInputDevices), @@ -121,11 +125,12 @@ napi_value AudioCapturerNapi::Init(napi_env env, napi_value exports) }; napi_property_descriptor static_prop[] = { - DECLARE_NAPI_STATIC_FUNCTION("createAudioCapturer", CreateAudioCapturer) + DECLARE_NAPI_STATIC_FUNCTION("createAudioCapturer", CreateAudioCapturer), + DECLARE_NAPI_STATIC_FUNCTION("createAudioCapturerSync", CreateAudioCapturerSync) }; - status = napi_define_class(env, AUDIO_CAPTURER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, - sizeof(audio_capturer_properties) / sizeof(audio_capturer_properties[PARAM0]), + napi_status status = napi_define_class(env, AUDIO_CAPTURER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, + nullptr, sizeof(audio_capturer_properties) / sizeof(audio_capturer_properties[PARAM0]), audio_capturer_properties, &constructor); if (status != napi_ok) { return result; @@ -405,6 +410,42 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in return result; } +napi_value AudioCapturerNapi::CreateAudioCapturerSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "%{public}s IN", __func__); + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_object) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + AudioCapturerOptions capturerOptions; + if (!ParseCapturerOptions(env, argv[PARAM0], &capturerOptions)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + unique_ptr audioCapturerOptions = make_unique(); + audioCapturerOptions->streamInfo.samplingRate = capturerOptions.streamInfo.samplingRate; + audioCapturerOptions->streamInfo.encoding = capturerOptions.streamInfo.encoding; + audioCapturerOptions->streamInfo.format = capturerOptions.streamInfo.format; + audioCapturerOptions->streamInfo.channels = capturerOptions.streamInfo.channels; + audioCapturerOptions->capturerInfo.sourceType = capturerOptions.capturerInfo.sourceType; + audioCapturerOptions->capturerInfo.capturerFlags = capturerOptions.capturerInfo.capturerFlags; + audioCapturerOptions->playbackCaptureConfig.filterOptions = capturerOptions.playbackCaptureConfig.filterOptions; + + return AudioCapturerNapi::CreateAudioCapturerWrapper(env, audioCapturerOptions); +} + void AudioCapturerNapi::CommonCallbackRoutine(napi_env env, AudioCapturerAsyncContext* &asyncContext, const napi_value &valueParam) { @@ -701,6 +742,42 @@ napi_value AudioCapturerNapi::GetCapturerInfo(napi_env env, napi_callback_info i return result; } +napi_value AudioCapturerNapi::GetCapturerInfoSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "%{public}s IN", __func__); + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioCapturerNapi = reinterpret_cast(native); + if (status != napi_ok || audioCapturerNapi == nullptr) { + AUDIO_ERR_LOG("GetCapturerInfoSync unwrap failure!"); + return result; + } + + AudioCapturerInfo capturerInfo; + int32_t ret = audioCapturerNapi->audioCapturer_->GetCapturerInfo(capturerInfo); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetCapturerInfo failure!"); + return result; + } + + (void)napi_create_object(env, &result); + SetValueInt32(env, "source", static_cast(capturerInfo.sourceType), result); + SetValueInt32(env, "capturerFlags", static_cast(capturerInfo.capturerFlags), result); + + return result; +} + napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info info) { napi_status status; @@ -758,6 +835,43 @@ napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info inf return result; } +napi_value AudioCapturerNapi::GetStreamInfoSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioCapturerNapi = reinterpret_cast(native); + if (status != napi_ok || audioCapturerNapi == nullptr) { + AUDIO_ERR_LOG("GetStreamInfoSync unwrap failure!"); + return result; + } + + AudioStreamInfo streamInfo; + int32_t ret = audioCapturerNapi->audioCapturer_->GetStreamInfo(streamInfo); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetStreamInfo failure!"); + return result; + } + + (void)napi_create_object(env, &result); + SetValueInt32(env, "samplingRate", static_cast(streamInfo.samplingRate), result); + SetValueInt32(env, "channels", static_cast(streamInfo.channels), result); + SetValueInt32(env, "sampleFormat", static_cast(streamInfo.format), result); + SetValueInt32(env, "encodingType", static_cast(streamInfo.encoding), result); + + return result; +} + napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info info) { napi_status status; @@ -817,6 +931,38 @@ napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info return result; } +napi_value AudioCapturerNapi::GetAudioStreamIdSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioCapturerNapi = reinterpret_cast(native); + if (status != napi_ok || audioCapturerNapi == nullptr) { + AUDIO_ERR_LOG("GetAudioStreamIdSync unwrap failure!"); + return result; + } + + uint32_t audioStreamId; + int32_t streamIdStatus = audioCapturerNapi->audioCapturer_->GetAudioStreamId(audioStreamId); + if (streamIdStatus != SUCCESS) { + AUDIO_ERR_LOG("GetAudioStreamId failure!"); + return result; + } + napi_create_uint32(env, audioStreamId, &result); + + return result; +} + napi_value AudioCapturerNapi::GetCurrentInputDevices(napi_env env, napi_callback_info info) { napi_status status; @@ -1084,6 +1230,41 @@ napi_value AudioCapturerNapi::GetAudioTime(napi_env env, napi_callback_info info return result; } +napi_value AudioCapturerNapi::GetAudioTimeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioCapturerNapi = reinterpret_cast(native); + if (status != napi_ok || audioCapturerNapi == nullptr) { + AUDIO_ERR_LOG("GetAudioTimeSync unwrap failure!"); + return result; + } + + Timestamp timestamp; + bool ret = audioCapturerNapi->audioCapturer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC); + if (!ret) { + AUDIO_ERR_LOG("GetAudioTime failure!"); + return result; + } + const uint64_t secToNanosecond = 1000000000; + uint64_t time = timestamp.time.tv_nsec + timestamp.time.tv_sec * secToNanosecond; + + napi_create_int64(env, time, &result); + + return result; +} + napi_value AudioCapturerNapi::Stop(napi_env env, napi_callback_info info) { napi_status status; @@ -1601,6 +1782,38 @@ napi_value AudioCapturerNapi::GetBufferSize(napi_env env, napi_callback_info inf return result; } +napi_value AudioCapturerNapi::GetBufferSizeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioCapturerNapi = reinterpret_cast(native); + if (status != napi_ok || audioCapturerNapi == nullptr) { + AUDIO_ERR_LOG("GetBufferSizeSync unwrap failure!"); + return result; + } + + size_t bufferSize; + int32_t ret = audioCapturerNapi->audioCapturer_->GetBufferSize(bufferSize); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetBufferSize failure!"); + return result; + } + napi_create_uint32(env, bufferSize, &result); + + return result; +} + napi_value AudioCapturerNapi::GetState(napi_env env, napi_callback_info info) { napi_value jsThis = nullptr; diff --git a/frameworks/js/napi/audio_common/include/audio_common_napi.h b/frameworks/js/napi/audio_common/include/audio_common_napi.h index f41249f9a28b5857e8d8e8889070a9a7a5b9d20b..4b6bfdac7edd9306e7dd68f2446f3007bee398e5 100644 --- a/frameworks/js/napi/audio_common/include/audio_common_napi.h +++ b/frameworks/js/napi/audio_common/include/audio_common_napi.h @@ -76,6 +76,7 @@ public: static bool IsLegalInputArgumentVolumeAdjustType(int32_t adjustType); static bool IsLegalInputArgumentDeviceType(int32_t deviceType); static bool IsLegalInputArgumentChannelBlendMode(int32_t blendMode); + static bool IsLegalInputArgumentInterruptMode(int32_t interruptMode); private: static constexpr int32_t MAX_VOLUME_LEVEL = 15; static constexpr int32_t MIN_VOLUME_LEVEL = 0; diff --git a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp index 9e07bab2074558fedfdf63381bf0e28cdffeb90c..ded6b04baf62beefe484a5b88a3e4ec99018ca62 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -294,5 +294,20 @@ bool AudioCommonNapi::IsLegalInputArgumentChannelBlendMode(int32_t blendMode) } return result; } + +bool AudioCommonNapi::IsLegalInputArgumentInterruptMode(int32_t interruptMode) +{ + bool result = false; + switch (interruptMode) { + case InterruptMode::SHARE_MODE: + case InterruptMode::INDEPENDENT_MODE: + result = true; + break; + default: + result = false; + break; + } + return result; +} } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp index e507fc188b5e9f8d17efb2c0b13b6cabe71df446..6d98637a1679eb87b77666d26fd5f327244f8fc1 100644 --- a/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp @@ -552,6 +552,7 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("isMicrophoneMute", IsMicrophoneMute), DECLARE_NAPI_FUNCTION("setAudioScene", SetAudioScene), DECLARE_NAPI_FUNCTION("getAudioScene", GetAudioScene), + DECLARE_NAPI_FUNCTION("getAudioSceneSync", GetAudioSceneSync), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("requestIndependentInterrupt", RequestIndependentInterrupt), @@ -1271,6 +1272,34 @@ napi_value AudioManagerNapi::GetAudioScene(napi_env env, napi_callback_info info return result; } +napi_value AudioManagerNapi::GetAudioSceneSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetAudioSceneSync unwrap failure!"); + return result; + } + + AudioScene audioScene = audioManagerNapi->audioMngr_->GetAudioScene(); + napi_create_int32(env, audioScene, &result); + + AUDIO_INFO_LOG("GetAudioSceneSync is successful"); + return result; +} + napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info) { napi_status status; diff --git a/frameworks/js/napi/audio_manager/src/audio_routing_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_routing_manager_napi.cpp index 52bdce58bed739f2f0128c872c9c0f1a80f5c383..5715d74ef4932f7bb035bed8e9904e277cdaedec 100644 --- a/frameworks/js/napi/audio_manager/src/audio_routing_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_routing_manager_napi.cpp @@ -89,6 +89,7 @@ napi_value AudioRoutingManagerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor audio_routing_manager_properties[] = { DECLARE_NAPI_FUNCTION("getDevices", GetDevices), + DECLARE_NAPI_FUNCTION("getDevicesSync", GetDevicesSync), DECLARE_NAPI_FUNCTION("on", AudioRoutingManagerNapi::On), DECLARE_NAPI_FUNCTION("off", AudioRoutingManagerNapi::Off), DECLARE_NAPI_FUNCTION("selectOutputDevice", SelectOutputDevice), @@ -97,10 +98,14 @@ napi_value AudioRoutingManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("selectInputDeviceByFilter", SelectInputDeviceByFilter), DECLARE_NAPI_FUNCTION("setCommunicationDevice", SetCommunicationDevice), DECLARE_NAPI_FUNCTION("isCommunicationDeviceActive", IsCommunicationDeviceActive), + DECLARE_NAPI_FUNCTION("isCommunicationDeviceActiveSync", IsCommunicationDeviceActiveSync), DECLARE_NAPI_FUNCTION("getActiveOutputDeviceDescriptors", GetActiveOutputDeviceDescriptors), DECLARE_NAPI_FUNCTION("getPreferredOutputDeviceForRendererInfo", GetPreferredOutputDeviceForRendererInfo), DECLARE_NAPI_FUNCTION("getPreferOutputDeviceForRendererInfo", GetPreferOutputDeviceForRendererInfo), + DECLARE_NAPI_FUNCTION("getPreferredOutputDeviceForRendererInfoSync", + GetPreferredOutputDeviceForRendererInfoSync), DECLARE_NAPI_FUNCTION("getPreferredInputDeviceForCapturerInfo", GetPreferredInputDeviceForCapturerInfo), + DECLARE_NAPI_FUNCTION("getPreferredInputDeviceForCapturerInfoSync", GetPreferredInputDeviceForCapturerInfoSync), }; status = napi_define_class(env, AUDIO_ROUTING_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -246,12 +251,12 @@ static void ParseAudioRendererInfo(napi_env env, napi_value root, AudioRendererI napi_value tempValue = nullptr; int32_t intValue = {0}; - if (napi_get_named_property(env, root, "contentType", &tempValue) == napi_ok) { + if (napi_get_named_property(env, root, "content", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); rendererInfo->contentType = static_cast(intValue); } - if (napi_get_named_property(env, root, "streamUsage", &tempValue) == napi_ok) { + if (napi_get_named_property(env, root, "usage", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); rendererInfo->streamUsage = static_cast(intValue); } @@ -392,7 +397,7 @@ static void SetValueString(const napi_env& env, const std::string& fieldStr, con napi_set_named_property(env, result, fieldStr.c_str(), value); } -static void SetDeviceDescriptors(const napi_env& env, napi_value &valueParam, const AudioDeviceDescriptor &deviceInfo) +static void SetDeviceDescriptor(const napi_env& env, napi_value &valueParam, const AudioDeviceDescriptor &deviceInfo) { SetValueInt32(env, "deviceRole", static_cast(deviceInfo.deviceRole_), valueParam); SetValueInt32(env, "deviceType", static_cast(deviceInfo.deviceType_), valueParam); @@ -436,6 +441,19 @@ static void SetDeviceDescriptors(const napi_env& env, napi_value &valueParam, co napi_set_named_property(env, valueParam, "encodingTypes", encodingTypes); } +static void SetDeviceDescriptors(const napi_env &env, napi_value &result, napi_value &valueParam, + const vector> deviceDescriptors) +{ + napi_create_array_with_length(env, deviceDescriptors.size(), &result); + for (size_t i = 0; i < deviceDescriptors.size(); i++) { + if (deviceDescriptors[i] != nullptr) { + (void)napi_create_object(env, &valueParam); + SetDeviceDescriptor(env, valueParam, deviceDescriptors[i]); + napi_set_element(env, result, i, valueParam); + } + } +} + static void SetDevicesInfo(vector> deviceDescriptors, napi_env env, napi_value* result, int32_t arrayLength, napi_value valueParam) { @@ -443,18 +461,11 @@ static void SetDevicesInfo(vector> deviceDescriptors HiLog::Info(LABEL, "number of devices = %{public}zu", size); if (arrayLength > PARAM1) { - napi_create_array_with_length(env, size, &result[PARAM1]); + SetDeviceDescriptors(env, result[PARAM1], valueParam, deviceDescriptors); } else { HiLog::Error(LABEL, "ERROR: Array access out of bounds, result size is %{public}d", arrayLength); return; } - for (size_t i = 0; i < size; i++) { - if (deviceDescriptors[i] != nullptr) { - (void)napi_create_object(env, &valueParam); - SetDeviceDescriptors(env, valueParam, deviceDescriptors[i]); - napi_set_element(env, result[PARAM1], i, valueParam); - } - } } static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, void* data) @@ -519,6 +530,49 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info return result; } +napi_value AudioRoutingManagerNapi::GetDevicesSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRoutingManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioRoutingManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetDevicesSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t deviceFlag; + napi_get_value_int32(env, argv[PARAM0], &deviceFlag); + if (!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(deviceFlag)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + vector> deviceDescriptors = audioRoutingManagerNapi->audioMngr_->GetDevices( + static_cast(deviceFlag)); + + napi_value valueParam = nullptr; + SetDeviceDescriptors(env, result, valueParam, deviceDescriptors); + + return result; +} + void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* argv, std::unique_ptr& asyncContext, const int32_t refCount, napi_value& result) { @@ -793,6 +847,46 @@ napi_value AudioRoutingManagerNapi::GetPreferredOutputDeviceForRendererInfo(napi return result; } +napi_value AudioRoutingManagerNapi::GetPreferredOutputDeviceForRendererInfoSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRoutingManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioRoutingManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetPreferredOutputDeviceForRendererInfoSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_object) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + AudioRendererInfo rendererInfo; + ParseAudioRendererInfo(env, argv[PARAM0], &rendererInfo); + + vector> outDeviceDescriptors; + audioRoutingManagerNapi->audioRoutingMngr_->GetPreferredOutputDeviceForRendererInfo( + rendererInfo, outDeviceDescriptors); + + napi_value valueParam = nullptr; + SetDeviceDescriptors(env, result, valueParam, outDeviceDescriptors); + + return result; +} + static void ParseAudioCapturerInfo(napi_env env, napi_value root, AudioCapturerInfo *capturerInfo) { napi_value tempValue = nullptr; @@ -899,6 +993,46 @@ napi_value AudioRoutingManagerNapi::GetPreferredInputDeviceForCapturerInfo(napi_ return result; } +napi_value AudioRoutingManagerNapi::GetPreferredInputDeviceForCapturerInfoSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRoutingManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioRoutingManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetPreferredInputDeviceForCapturerInfoSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_object) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + AudioCapturerInfo capturerInfo; + ParseAudioCapturerInfo(env, argv[PARAM0], &capturerInfo); + + vector> outDeviceDescriptors; + audioRoutingManagerNapi->audioRoutingMngr_->GetPreferredInputDeviceForCapturerInfo( + capturerInfo, outDeviceDescriptors); + + napi_value valueParam = nullptr; + SetDeviceDescriptors(env, result, valueParam, outDeviceDescriptors); + + return result; +} + napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, napi_callback_info info) { napi_status status; @@ -1596,5 +1730,45 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na return result; } +napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActiveSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRoutingManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioRoutingManagerNapi == nullptr) { + AUDIO_ERR_LOG("IsCommunicationDeviceActiveSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t deviceType; + napi_get_value_int32(env, argv[PARAM0], &deviceType); + if (!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(deviceType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + bool isActive = audioRoutingManagerNapi->audioMngr_->IsDeviceActive(static_cast(deviceType)); + napi_get_boolean(env, isActive, &result); + + return result; +} + } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp index fc710c8af1ebee946f487c7ff66299868dbf2a19..5b09b9de8e724ef5231634c54aab957556e93b39 100644 --- a/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp @@ -290,10 +290,14 @@ napi_value AudioStreamMgrNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("getCurrentAudioRendererInfoArray", GetCurrentAudioRendererInfos), + DECLARE_NAPI_FUNCTION("getCurrentAudioRendererInfoArraySync", GetCurrentAudioRendererInfosSync), DECLARE_NAPI_FUNCTION("getCurrentAudioCapturerInfoArray", GetCurrentAudioCapturerInfos), + DECLARE_NAPI_FUNCTION("getCurrentAudioCapturerInfoArraySync", GetCurrentAudioCapturerInfosSync), DECLARE_NAPI_FUNCTION("isAudioRendererLowLatencySupported", IsAudioRendererLowLatencySupported), DECLARE_NAPI_FUNCTION("isActive", IsStreamActive), + DECLARE_NAPI_FUNCTION("isActiveSync", IsStreamActiveSync), DECLARE_NAPI_FUNCTION("getAudioEffectInfoArray", GetEffectInfoArray), + DECLARE_NAPI_FUNCTION("getAudioEffectInfoArraySync", GetEffectInfoArraySync), }; status = napi_define_class(env, AUDIO_STREAM_MGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -593,6 +597,64 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c return result; } +napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfosSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioStreamMgrNapi = reinterpret_cast(native); + if (status != napi_ok || audioStreamMgrNapi == nullptr) { + AUDIO_ERR_LOG("GetCurrentAudioRendererInfosSync unwrap failure!"); + return result; + } + + vector> audioRendererChangeInfos; + int32_t ret = audioStreamMgrNapi->audioStreamMngr_->GetCurrentRendererChangeInfos(audioRendererChangeInfos); + if (ret != AUDIO_OK) { + AUDIO_ERR_LOG("GetCurrentRendererChangeInfos failure!"); + return result; + } + + napi_value jsChangeInfoObj = nullptr; + napi_value jsRenInfoObj = nullptr; + + int32_t position = 0; + napi_create_array_with_length(env, audioRendererChangeInfos.size(), &result); + for (const unique_ptr &changeInfo: audioRendererChangeInfos) { + if (!changeInfo) { + AUDIO_ERR_LOG("AudioStreamMgrNapi:AudioRendererChangeInfo Null, something wrong!!"); + continue; + } + + napi_create_object(env, &jsChangeInfoObj); + SetValueInt32(env, "streamId", changeInfo->sessionId, jsChangeInfoObj); + SetValueInt32(env, "rendererState", static_cast(changeInfo->rendererState), jsChangeInfoObj); + SetValueInt32(env, "clientUid", changeInfo->clientUID, jsChangeInfoObj); + + napi_create_object(env, &jsRenInfoObj); + SetValueInt32(env, "content", static_cast(changeInfo->rendererInfo.contentType), jsRenInfoObj); + SetValueInt32(env, "usage", static_cast(changeInfo->rendererInfo.streamUsage), jsRenInfoObj); + SetValueInt32(env, "rendererFlags", changeInfo->rendererInfo.rendererFlags, jsRenInfoObj); + napi_set_named_property(env, jsChangeInfoObj, "rendererInfo", jsRenInfoObj); + SetDeviceDescriptors(env, jsChangeInfoObj, changeInfo->outputDeviceInfo); + + napi_set_element(env, result, position, jsChangeInfoObj); + position++; + } + + return result; +} + napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_callback_info info) { napi_status status; @@ -659,6 +721,63 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_c return result; } +napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfosSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioStreamMgrNapi = reinterpret_cast(native); + if (status != napi_ok || audioStreamMgrNapi == nullptr) { + AUDIO_ERR_LOG("GetCurrentAudioCapturerInfosSync unwrap failure!"); + return result; + } + + vector> audioCapturerChangeInfos; + int32_t ret = audioStreamMgrNapi->audioStreamMngr_->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos); + if (ret != AUDIO_OK) { + AUDIO_ERR_LOG("GetCurrentCapturerChangeInfos failure!"); + return result; + } + + napi_value jsChangeInfoObj = nullptr; + napi_value jsCapInfoObj = nullptr; + + int32_t position = 0; + napi_create_array_with_length(env, audioCapturerChangeInfos.size(), &result); + for (const unique_ptr &changeInfo: audioCapturerChangeInfos) { + if (!changeInfo) { + AUDIO_ERR_LOG("AudioCapturerChangeInfo Null, something wrong!!"); + continue; + } + + napi_create_object(env, &jsChangeInfoObj); + SetValueInt32(env, "streamId", changeInfo->sessionId, jsChangeInfoObj); + SetValueInt32(env, "capturerState", static_cast(changeInfo->capturerState), jsChangeInfoObj); + SetValueInt32(env, "clientUid", changeInfo->clientUID, jsChangeInfoObj); + + napi_create_object(env, &jsCapInfoObj); + SetValueInt32(env, "source", static_cast(changeInfo->capturerInfo.sourceType), jsCapInfoObj); + SetValueInt32(env, "capturerFlags", changeInfo->capturerInfo.capturerFlags, jsCapInfoObj); + napi_set_named_property(env, jsChangeInfoObj, "capturerInfo", jsCapInfoObj); + SetDeviceDescriptors(env, jsChangeInfoObj, changeInfo->inputDeviceInfo); + + napi_set_element(env, result, position, jsChangeInfoObj); + position++; + } + + return result; +} + napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, napi_callback_info info) { napi_status status; @@ -893,6 +1012,46 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i return result; } +napi_value AudioStreamMgrNapi::IsStreamActiveSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioStreamMgrNapi = reinterpret_cast(native); + if (status != napi_ok || audioStreamMgrNapi == nullptr) { + AUDIO_ERR_LOG("IsStreamActiveSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t volType; + napi_get_value_int32(env, argv[PARAM0], &volType); + if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + bool isActive = audioStreamMgrNapi->audioStreamMngr_->IsStreamActive(GetNativeAudioVolumeType(volType)); + napi_get_boolean(env, isActive, &result); + + return result; +} + void AudioStreamMgrNapi::GetEffectInfoArrayCallbackComplete(napi_env env, napi_status status, void *data) { uint32_t i; @@ -1011,5 +1170,58 @@ napi_value AudioStreamMgrNapi::GetEffectInfoArray(napi_env env, napi_callback_in return result; } + +napi_value AudioStreamMgrNapi::GetEffectInfoArraySync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioStreamMgrNapi = reinterpret_cast(native); + if (status != napi_ok || audioStreamMgrNapi == nullptr) { + AUDIO_ERR_LOG("GetEffectInfoArraySync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t streamUsage; + napi_get_value_int32(env, argv[PARAM0], &streamUsage); + if (!AudioCommonNapi::IsLegalInputArgumentStreamUsage(streamUsage)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + AudioSceneEffectInfo audioSceneEffectInfo; + int32_t ret = audioStreamMgrNapi->audioStreamMngr_->GetEffectInfoArray(audioSceneEffectInfo, + static_cast(streamUsage)); + if (ret != AUDIO_OK) { + AUDIO_ERR_LOG("GetEffectInfoArray failure!"); + return result; + } + + napi_value jsEffectInofObj = nullptr; + napi_create_array_with_length(env, audioSceneEffectInfo.mode.size(), &result); + napi_create_object(env, &jsEffectInofObj); + for (int32_t i = 0; i < audioSceneEffectInfo.mode.size(); i++) { + napi_create_uint32(env, audioSceneEffectInfo.mode[i], &jsEffectInofObj); + napi_set_element(env, result, i, jsEffectInofObj); + } + + return result; +} } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp index fc730c29fc6e513905039a299497087c94bab645..8834867c261a2beba4aeff871f6b533ee75dafaa 100755 --- a/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp @@ -411,6 +411,46 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in return result; } +napi_value AudioVolumeGroupManagerNapi::GetVolumeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetVolumeSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t volType; + napi_get_value_int32(env, argv[PARAM0], &volType); + if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetVolume(GetNativeAudioVolumeType(volType)); + napi_create_int32(env, volLevel, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_info info) { napi_status status; @@ -558,6 +598,46 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback return result; } +napi_value AudioVolumeGroupManagerNapi::GetMaxVolumeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetMaxVolumeSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t volType; + napi_get_value_int32(env, argv[PARAM0], &volType); + if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetMaxVolume(GetNativeAudioVolumeType(volType)); + napi_create_int32(env, volLevel, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) { napi_status status; @@ -630,6 +710,46 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback return result; } +napi_value AudioVolumeGroupManagerNapi::GetMinVolumeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetMinVolumeSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t volType; + napi_get_value_int32(env, argv[PARAM0], &volType); + if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetMinVolume(GetNativeAudioVolumeType(volType)); + napi_create_int32(env, volLevel, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info info) { napi_status status; @@ -770,6 +890,52 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback return result; } +napi_value AudioVolumeGroupManagerNapi::IsStreamMuteSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("IsStreamMuteSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t volType; + napi_get_value_int32(env, argv[PARAM0], &volType); + if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + bool isMute; + int32_t ret = audioVolumeGroupManagerNapi->audioGroupMngr_->IsStreamMute( + GetNativeAudioVolumeType(volType), isMute); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("IsStreamMute failure!"); + return result; + } + napi_get_boolean(env, isMute, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callback_info info) { HiLog::Info(LABEL, " %{public}s IN", __func__); @@ -896,6 +1062,34 @@ napi_value AudioVolumeGroupManagerNapi::GetRingerMode(napi_env env, napi_callbac return result; } +napi_value AudioVolumeGroupManagerNapi::GetRingerModeSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetRingerModeSync unwrap failure!"); + return result; + } + + AudioRingerMode ringerMode = audioVolumeGroupManagerNapi->audioGroupMngr_->GetRingerMode(); + napi_create_int32(env, ringerMode, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info info) { @@ -1015,6 +1209,33 @@ napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMute(napi_env env, napi_call return result; } +napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMuteSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("IsMicrophoneMuteSync unwrap failure!"); + return result; + } + + bool isMute = audioVolumeGroupManagerNapi->audioGroupMngr_->IsMicrophoneMute(); + napi_get_boolean(env, isMute, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info) { napi_value undefinedResult = nullptr; @@ -1307,7 +1528,7 @@ void GetArgvForSystemVolumeInDb(napi_env env, size_t argc, napi_value* argv, { const int32_t refCount = 1; if (argv == nullptr) { - asyncContext->status = NAPI_ERR_INVALID_PARAM; + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return; } if (argc > PARAM3) { @@ -1316,6 +1537,9 @@ void GetArgvForSystemVolumeInDb(napi_env env, size_t argc, napi_value* argv, if (valueType == napi_function) { napi_create_reference(env, argv[PARAM3], refCount, &asyncContext->callbackRef); } + } else { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return; } for (size_t i = PARAM0; i < argc; i++) { @@ -1339,7 +1563,8 @@ void GetArgvForSystemVolumeInDb(napi_env env, size_t argc, napi_value* argv, } break; } else { - asyncContext->status = NAPI_ERR_INVALID_PARAM; + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return; } } } @@ -1394,6 +1619,61 @@ napi_value AudioVolumeGroupManagerNapi::GetSystemVolumeInDb(napi_env env, napi_c return result; } +napi_value AudioVolumeGroupManagerNapi::GetSystemVolumeInDbSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_THREE); + + if (argc < ARGS_THREE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeGroupManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetSystemVolumeInDbSync unwrap failure!"); + return result; + } + + int32_t volType; + int32_t volLevel; + int32_t deviceType; + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + bool isLegalInput = false; + if (i == PARAM0) { + napi_get_value_int32(env, argv[i], &volType); + isLegalInput = AudioCommonNapi::IsLegalInputArgumentVolType(volType); + } else if (i == PARAM1) { + napi_get_value_int32(env, argv[i], &volLevel); + isLegalInput = AudioCommonNapi::IsLegalInputArgumentVolLevel(volLevel); + } else if (i == PARAM2) { + napi_get_value_int32(env, argv[i], &deviceType); + isLegalInput = AudioCommonNapi::IsLegalInputArgumentDeviceType(deviceType); + } + if (!isLegalInput) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + } + + double volumeInDb = audioVolumeGroupManagerNapi->audioGroupMngr_->GetSystemVolumeInDb( + GetNativeAudioVolumeType(volType), volLevel, static_cast(deviceType)); + napi_create_double(env, volumeInDb, &result); + + return result; +} + napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports) { AUDIO_INFO_LOG("Init"); @@ -1406,19 +1686,26 @@ napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor audio_svc_group_mngr_properties[] = { DECLARE_NAPI_FUNCTION("setVolume", AudioVolumeGroupManagerNapi::SetVolume), DECLARE_NAPI_FUNCTION("getVolume", AudioVolumeGroupManagerNapi::GetVolume), + DECLARE_NAPI_FUNCTION("getVolumeSync", AudioVolumeGroupManagerNapi::GetVolumeSync), DECLARE_NAPI_FUNCTION("getMaxVolume", AudioVolumeGroupManagerNapi::GetMaxVolume), + DECLARE_NAPI_FUNCTION("getMaxVolumeSync", AudioVolumeGroupManagerNapi::GetMaxVolumeSync), DECLARE_NAPI_FUNCTION("getMinVolume", AudioVolumeGroupManagerNapi::GetMinVolume), + DECLARE_NAPI_FUNCTION("getMinVolumeSync", AudioVolumeGroupManagerNapi::GetMinVolumeSync), DECLARE_NAPI_FUNCTION("mute", AudioVolumeGroupManagerNapi::SetMute), DECLARE_NAPI_FUNCTION("isMute", AudioVolumeGroupManagerNapi::IsStreamMute), + DECLARE_NAPI_FUNCTION("isMuteSync", AudioVolumeGroupManagerNapi::IsStreamMuteSync), DECLARE_NAPI_FUNCTION("setRingerMode", SetRingerMode), DECLARE_NAPI_FUNCTION("getRingerMode", GetRingerMode), + DECLARE_NAPI_FUNCTION("getRingerModeSync", GetRingerModeSync), DECLARE_NAPI_FUNCTION("setMicrophoneMute", SetMicrophoneMute), DECLARE_NAPI_FUNCTION("isMicrophoneMute", IsMicrophoneMute), + DECLARE_NAPI_FUNCTION("isMicrophoneMuteSync", IsMicrophoneMuteSync), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("isVolumeUnadjustable", IsVolumeUnadjustable), DECLARE_NAPI_FUNCTION("adjustVolumeByStep", AdjustVolumeByStep), DECLARE_NAPI_FUNCTION("adjustSystemVolumeByStep", AdjustSystemVolumeByStep), DECLARE_NAPI_FUNCTION("getSystemVolumeInDb", GetSystemVolumeInDb), + DECLARE_NAPI_FUNCTION("getSystemVolumeInDbSync", GetSystemVolumeInDbSync), }; status = napi_define_class(env, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), diff --git a/frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp index 37de3827264e3426f8e3d90a6e69ce8339fe9de6..3cbbfa8b3051f6d61fabf21774e7a9e4b7b2a28c 100644 --- a/frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp @@ -133,7 +133,9 @@ napi_value AudioVolumeManagerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor audio_volume_manager_properties[] = { DECLARE_NAPI_FUNCTION("getVolumeGroupInfos", GetVolumeGroupInfos), + DECLARE_NAPI_FUNCTION("getVolumeGroupInfosSync", GetVolumeGroupInfosSync), DECLARE_NAPI_FUNCTION("getVolumeGroupManager", GetVolumeGroupManager), + DECLARE_NAPI_FUNCTION("getVolumeGroupManagerSync", GetVolumeGroupManagerSync), DECLARE_NAPI_FUNCTION("on", On), }; @@ -312,6 +314,65 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callba return result; } +napi_value AudioVolumeManagerNapi::GetVolumeGroupInfosSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioVolumeManagerNapi = reinterpret_cast(native); + if (status != napi_ok || audioVolumeManagerNapi == nullptr) { + AUDIO_ERR_LOG("GetVolumeGroupInfosSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_string) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + std::string networkId = AudioCommonNapi::GetStringArgument(env, argv[PARAM0]); + if (networkId.empty()) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + vector> volumeGroupInfos; + int32_t ret = audioVolumeManagerNapi->audioSystemMngr_->GetVolumeGroups(networkId, volumeGroupInfos); + if (ret != AUDIO_OK) { + AUDIO_ERR_LOG("GetVolumeGroups failure!"); + return result; + } + + napi_value valueParam = nullptr; + napi_create_array_with_length(env, volumeGroupInfos.size(), &result); + for (size_t i = 0; i < volumeGroupInfos.size(); i++) { + if (volumeGroupInfos[i] != nullptr) { + (void)napi_create_object(env, &valueParam); + SetValueString(env, "networkId", static_cast(volumeGroupInfos[i]->networkId_), valueParam); + SetValueInt32(env, "groupId", static_cast(volumeGroupInfos[i]->volumeGroupId_), valueParam); + SetValueInt32(env, "mappingId", static_cast(volumeGroupInfos[i]->mappingId_), valueParam); + SetValueString(env, "groupName", static_cast(volumeGroupInfos[i]->groupName_), valueParam); + SetValueInt32(env, "ConnectType", static_cast(volumeGroupInfos[i]->connectType_), valueParam); + napi_set_element(env, result, i, valueParam); + } + } + + return result; +} + static void GetGroupMgrAsyncCallbackComplete(napi_env env, napi_status status, void* data) { napi_value valueParam = nullptr; @@ -390,6 +451,30 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupManager(napi_env env, napi_call return result; } +napi_value AudioVolumeManagerNapi::GetVolumeGroupManagerSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return nullptr; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return nullptr; + } + + int32_t groupId; + napi_get_value_int32(env, argv[PARAM0], &groupId); + + return AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(env, groupId); +} + napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) { napi_value undefinedResult = nullptr; diff --git a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp index 9d64b4c3599e399d196b6a384f7e935023ca3d1a..4b0ab3a58e2c2f85b949231cee0eb9957b7f728a 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp @@ -408,6 +408,7 @@ napi_value AudioRendererNapi::CreateAudioPrivacyTypeObject(napi_env env) static void SetDeviceDescriptors(const napi_env& env, napi_value &valueParam, const DeviceInfo &deviceInfo) { + (void)napi_create_object(env, &valueParam); SetValueInt32(env, "deviceRole", static_cast(deviceInfo.deviceRole), valueParam); SetValueInt32(env, "deviceType", static_cast(deviceInfo.deviceType), valueParam); SetValueInt32(env, "id", static_cast(deviceInfo.deviceId), valueParam); @@ -461,27 +462,38 @@ napi_value AudioRendererNapi::Init(napi_env env, napi_value exports) napi_property_descriptor audio_renderer_properties[] = { DECLARE_NAPI_FUNCTION("setRenderRate", SetRenderRate), DECLARE_NAPI_FUNCTION("getRenderRate", GetRenderRate), + DECLARE_NAPI_FUNCTION("getRenderRateSync", GetRenderRateSync), DECLARE_NAPI_FUNCTION("setRendererSamplingRate", SetRendererSamplingRate), DECLARE_NAPI_FUNCTION("getRendererSamplingRate", GetRendererSamplingRate), DECLARE_NAPI_FUNCTION("start", Start), DECLARE_NAPI_FUNCTION("write", Write), DECLARE_NAPI_FUNCTION("getAudioTime", GetAudioTime), + DECLARE_NAPI_FUNCTION("getAudioTimeSync", GetAudioTimeSync), DECLARE_NAPI_FUNCTION("drain", Drain), DECLARE_NAPI_FUNCTION("pause", Pause), DECLARE_NAPI_FUNCTION("stop", Stop), DECLARE_NAPI_FUNCTION("release", Release), DECLARE_NAPI_FUNCTION("getBufferSize", GetBufferSize), + DECLARE_NAPI_FUNCTION("getBufferSizeSync", GetBufferSizeSync), DECLARE_NAPI_FUNCTION("getAudioStreamId", GetAudioStreamId), + DECLARE_NAPI_FUNCTION("getAudioStreamIdSync", GetAudioStreamIdSync), DECLARE_NAPI_FUNCTION("setVolume", SetVolume), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("getRendererInfo", GetRendererInfo), + DECLARE_NAPI_FUNCTION("getRendererInfoSync", GetRendererInfoSync), DECLARE_NAPI_FUNCTION("getStreamInfo", GetStreamInfo), + DECLARE_NAPI_FUNCTION("getStreamInfoSync", GetStreamInfoSync), DECLARE_NAPI_FUNCTION("setInterruptMode", SetInterruptMode), + DECLARE_NAPI_FUNCTION("setInterruptModeSync", SetInterruptModeSync), DECLARE_NAPI_FUNCTION("getMinStreamVolume", GetMinStreamVolume), + DECLARE_NAPI_FUNCTION("getMinStreamVolumeSync", GetMinStreamVolumeSync), DECLARE_NAPI_FUNCTION("getMaxStreamVolume", GetMaxStreamVolume), + DECLARE_NAPI_FUNCTION("getMaxStreamVolumeSync", GetMaxStreamVolumeSync), DECLARE_NAPI_FUNCTION("getCurrentOutputDevices", GetCurrentOutputDevices), + DECLARE_NAPI_FUNCTION("getCurrentOutputDevicesSync", GetCurrentOutputDevicesSync), DECLARE_NAPI_FUNCTION("getUnderflowCount", GetUnderflowCount), + DECLARE_NAPI_FUNCTION("getUnderflowCountSync", GetUnderflowCountSync), DECLARE_NAPI_FUNCTION("getAudioEffectMode", GetAudioEffectMode), DECLARE_NAPI_FUNCTION("setAudioEffectMode", SetAudioEffectMode), DECLARE_NAPI_FUNCTION("setChannelBlendMode", SetChannelBlendMode), @@ -490,6 +502,7 @@ napi_value AudioRendererNapi::Init(napi_env env, napi_value exports) napi_property_descriptor static_prop[] = { DECLARE_NAPI_STATIC_FUNCTION("createAudioRenderer", CreateAudioRenderer), + DECLARE_NAPI_STATIC_FUNCTION("createAudioRendererSync", CreateAudioRendererSync), DECLARE_NAPI_PROPERTY("AudioRendererRate", CreateAudioRendererRateObject(env)), DECLARE_NAPI_PROPERTY("InterruptType", CreateInterruptEventTypeObject(env)), DECLARE_NAPI_PROPERTY("InterruptForceType", CreateInterruptForceTypeObject(env)), @@ -668,6 +681,44 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in return result; } +napi_value AudioRendererNapi::CreateAudioRendererSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "%{public}s IN", __func__); + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_object) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + AudioRendererOptions rendererOptions; + if (!ParseRendererOptions(env, argv[PARAM0], &rendererOptions)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + unique_ptr audioRendererOptions = make_unique(); + audioRendererOptions->streamInfo.samplingRate = rendererOptions.streamInfo.samplingRate; + audioRendererOptions->streamInfo.encoding = rendererOptions.streamInfo.encoding; + audioRendererOptions->streamInfo.format = rendererOptions.streamInfo.format; + audioRendererOptions->streamInfo.channels = rendererOptions.streamInfo.channels; + audioRendererOptions->rendererInfo.contentType = rendererOptions.rendererInfo.contentType; + audioRendererOptions->rendererInfo.streamUsage = rendererOptions.rendererInfo.streamUsage; + audioRendererOptions->rendererInfo.rendererFlags = rendererOptions.rendererInfo.rendererFlags; + audioRendererOptions->privacyType = rendererOptions.privacyType; + + return AudioRendererNapi::CreateAudioRendererWrapper(env, audioRendererOptions); +} + void AudioRendererNapi::CommonCallbackRoutine(napi_env env, AudioRendererAsyncContext* &asyncContext, const napi_value &valueParam) { @@ -1082,7 +1133,6 @@ void AudioRendererNapi::GetDeviceInfoAsyncCallbackComplete(napi_env env, napi_st if (asyncContext != nullptr) { if (!asyncContext->status) { - (void)napi_create_object(env, &valueParam); SetDeviceDescriptors(env, valueParam, asyncContext->deviceInfo); asyncContext->status = AudioRendererNapi::isConstructSuccess_; AudioRendererNapi::isConstructSuccess_ = SUCCESS; @@ -1362,6 +1412,33 @@ napi_value AudioRendererNapi::GetRenderRate(napi_env env, napi_callback_info inf return result; } +napi_value AudioRendererNapi::GetRenderRateSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetRenderRateSync unwrap failure!"); + return result; + } + + AudioRendererRate rendererRate = audioRendererNapi->audioRenderer_->GetRenderRate(); + napi_create_int32(env, rendererRate, &result); + + return result; +} + napi_value AudioRendererNapi::GetRendererSamplingRate(napi_env env, napi_callback_info info) { napi_status status; @@ -1630,6 +1707,41 @@ napi_value AudioRendererNapi::GetAudioTime(napi_env env, napi_callback_info info return result; } +napi_value AudioRendererNapi::GetAudioTimeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetAudioTimeSync unwrap failure!"); + return result; + } + + Timestamp timestamp; + bool ret = audioRendererNapi->audioRenderer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC); + if (!ret) { + AUDIO_ERR_LOG("GetAudioTime failure!"); + return result; + } + const uint64_t secToNanosecond = 1000000000; + uint64_t time = timestamp.time.tv_nsec + timestamp.time.tv_sec * secToNanosecond; + + napi_create_int64(env, time, &result); + + return result; +} + napi_value AudioRendererNapi::Drain(napi_env env, napi_callback_info info) { napi_status status; @@ -1926,6 +2038,38 @@ napi_value AudioRendererNapi::GetBufferSize(napi_env env, napi_callback_info inf return result; } +napi_value AudioRendererNapi::GetBufferSizeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetBufferSizeSync unwrap failure!"); + return result; + } + + size_t bufferSize; + int32_t ret = audioRendererNapi->audioRenderer_->GetBufferSize(bufferSize); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetBufferSize failure!"); + return result; + } + napi_create_uint32(env, bufferSize, &result); + + return result; +} + napi_value AudioRendererNapi::GetAudioStreamId(napi_env env, napi_callback_info info) { napi_status status; @@ -1957,6 +2101,38 @@ napi_value AudioRendererNapi::GetAudioStreamId(napi_env env, napi_callback_info return result; } +napi_value AudioRendererNapi::GetAudioStreamIdSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetAudioStreamIdSync unwrap failure!"); + return result; + } + + uint32_t audioStreamId; + int32_t streamIdStatus = audioRendererNapi->audioRenderer_->GetAudioStreamId(audioStreamId); + if (streamIdStatus != SUCCESS) { + AUDIO_ERR_LOG("GetAudioStreamId failure!"); + return result; + } + napi_create_uint32(env, audioStreamId, &result); + + return result; +} + void AudioRendererNapi::JudgeFuncGetAudioStreamId(napi_env &env, napi_value &result, unique_ptr &asyncContext) { @@ -2129,6 +2305,43 @@ napi_value AudioRendererNapi::GetRendererInfo(napi_env env, napi_callback_info i return result; } +napi_value AudioRendererNapi::GetRendererInfoSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "Entered GetRendererInfoSync"); + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetRendererInfoSync unwrap failure!"); + return result; + } + + AudioRendererInfo rendererInfo; + int32_t ret = audioRendererNapi->audioRenderer_->GetRendererInfo(rendererInfo); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetRendererInfo failure!"); + return result; + } + + (void)napi_create_object(env, &result); + SetValueInt32(env, "content", static_cast(rendererInfo.contentType), result); + SetValueInt32(env, "usage", static_cast(rendererInfo.streamUsage), result); + SetValueInt32(env, "rendererFlags", rendererInfo.rendererFlags, result); + + return result; +} + napi_value AudioRendererNapi::GetStreamInfo(napi_env env, napi_callback_info info) { napi_status status; @@ -2190,6 +2403,43 @@ napi_value AudioRendererNapi::GetStreamInfo(napi_env env, napi_callback_info inf return result; } +napi_value AudioRendererNapi::GetStreamInfoSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetStreamInfoSync unwrap failure!"); + return result; + } + + AudioStreamInfo streamInfo; + int32_t ret = audioRendererNapi->audioRenderer_->GetStreamInfo(streamInfo); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetStreamInfo failure!"); + return result; + } + + (void)napi_create_object(env, &result); + SetValueInt32(env, "samplingRate", static_cast(streamInfo.samplingRate), result); + SetValueInt32(env, "channels", static_cast(streamInfo.channels), result); + SetValueInt32(env, "sampleFormat", static_cast(streamInfo.format), result); + SetValueInt32(env, "encodingType", static_cast(streamInfo.encoding), result); + + return result; +} + napi_value AudioRendererNapi::GetAudioEffectMode(napi_env env, napi_callback_info info) { napi_status status; @@ -2264,21 +2514,10 @@ void AudioRendererNapi::AsyncSetAudioEffectMode(napi_env env, void *data) } } -napi_value AudioRendererNapi::SetAudioEffectMode(napi_env env, napi_callback_info info) +void AudioRendererNapi::GetArgvForSetAudioEffectMode(napi_env env, size_t argc, napi_value* argv, + unique_ptr &asyncContext) { - napi_status status; const int32_t refCount = 1; - napi_value result = nullptr; - - GET_PARAMS(env, info, ARGS_TWO); - unique_ptr asyncContext = make_unique(); - THROW_ERROR_ASSERT(env, argc >= ARGS_ONE, NAPI_ERR_INVALID_PARAM); - - status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); - if (status != napi_ok || asyncContext->objectInfo == nullptr) { - return result; - } - for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -2295,9 +2534,27 @@ napi_value AudioRendererNapi::SetAudioEffectMode(napi_env env, napi_callback_inf } break; } else { - asyncContext->status = NAPI_ERR_INVALID_PARAM; + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return; } } +} + +napi_value AudioRendererNapi::SetAudioEffectMode(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + unique_ptr asyncContext = make_unique(); + THROW_ERROR_ASSERT(env, argc >= ARGS_ONE, NAPI_ERR_INPUT_INVALID); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status != napi_ok || asyncContext->objectInfo == nullptr) { + return result; + } + + GetArgvForSetAudioEffectMode(env, argc, argv, asyncContext); if (asyncContext->callbackRef == nullptr) { napi_create_promise(env, &asyncContext->deferred, &result); @@ -2752,6 +3009,45 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info return result; } +napi_value AudioRendererNapi::SetInterruptModeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value result = nullptr; + void *native = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("SetInterruptModeSync unwrap failure!"); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_number) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + int32_t interruptMode; + napi_get_value_int32(env, argv[PARAM0], &interruptMode); + if (!AudioCommonNapi::IsLegalInputArgumentInterruptMode(interruptMode)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + audioRendererNapi->audioRenderer_->SetInterruptMode(GetNativeInterruptMode(interruptMode)); + + return result; +} + napi_value AudioRendererNapi::GetMinStreamVolume(napi_env env, napi_callback_info info) { napi_status status; @@ -2805,6 +3101,33 @@ napi_value AudioRendererNapi::GetMinStreamVolume(napi_env env, napi_callback_inf return result; } +napi_value AudioRendererNapi::GetMinStreamVolumeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetMinStreamVolumeSync unwrap failure!"); + return result; + } + + double volLevel = audioRendererNapi->audioRenderer_->GetMinStreamVolume(); + napi_create_double(env, volLevel, &result); + + return result; +} + napi_value AudioRendererNapi::GetMaxStreamVolume(napi_env env, napi_callback_info info) { napi_status status; @@ -2858,6 +3181,33 @@ napi_value AudioRendererNapi::GetMaxStreamVolume(napi_env env, napi_callback_inf return result; } +napi_value AudioRendererNapi::GetMaxStreamVolumeSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetMaxStreamVolumeSync unwrap failure!"); + return result; + } + + double volLevel = audioRendererNapi->audioRenderer_->GetMaxStreamVolume(); + napi_create_double(env, volLevel, &result); + + return result; +} + void AudioRendererNapi::AsyncGetCurrentOutputDevices(napi_env env, void *data) { auto context = static_cast(data); @@ -2918,6 +3268,41 @@ napi_value AudioRendererNapi::GetCurrentOutputDevices(napi_env env, napi_callbac return result; } +napi_value AudioRendererNapi::GetCurrentOutputDevicesSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetCurrentOutputDevicesSync unwrap failure!"); + return result; + } + + DeviceInfo deviceInfo; + int32_t ret = audioRendererNapi->audioRenderer_->GetCurrentOutputDevices(deviceInfo); + if (ret != SUCCESS) { + AUDIO_ERR_LOG("GetCurrentOutputDevices failure!"); + return result; + } + napi_create_array_with_length(env, 1, &result); + napi_value valueParam; + SetDeviceDescriptors(env, valueParam, deviceInfo); + napi_set_element(env, result, 0, valueParam); + + return result; +} + napi_value AudioRendererNapi::GetUnderflowCount(napi_env env, napi_callback_info info) { napi_status status; @@ -2968,6 +3353,34 @@ napi_value AudioRendererNapi::GetUnderflowCount(napi_env env, napi_callback_info } } } + + return result; +} + +napi_value AudioRendererNapi::GetUnderflowCountSync(napi_env env, napi_callback_info info) +{ + napi_status status; + napi_value thisVar = nullptr; + napi_value result = nullptr; + size_t argCount = 0; + void *native = nullptr; + + status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + AUDIO_ERR_LOG("Invalid parameters!"); + return result; + } + + status = napi_unwrap(env, thisVar, &native); + auto *audioRendererNapi = reinterpret_cast(native); + if (status != napi_ok || audioRendererNapi == nullptr) { + AUDIO_ERR_LOG("GetUnderflowCountSync unwrap failure!"); + return result; + } + + uint32_t underflowCount = audioRendererNapi->audioRenderer_->GetUnderflowCount(); + napi_create_uint32(env, underflowCount, &result); + return result; } diff --git a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp index 4e65619c4abce7588039cc5c81000c058b3f909f..bdf3918c2bbdbd6657990199c2a2034dffb6964c 100644 --- a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp +++ b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp @@ -296,6 +296,39 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf return result; } +napi_value TonePlayerNapi::CreateTonePlayerSync(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "%{public}s IN", __func__); + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + if (argc < ARGS_ONE) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType != napi_object) { + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); + return result; + } + + AudioRendererInfo rendererInfo; + if (!ParseRendererInfo(env, argv[PARAM0], &rendererInfo)) { + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); + return result; + } + + unique_ptr audioRendererInfo = make_unique(); + audioRendererInfo->contentType = rendererInfo.contentType; + audioRendererInfo->streamUsage = rendererInfo.streamUsage; + audioRendererInfo->rendererFlags = rendererInfo.rendererFlags; + + return TonePlayerNapi::CreateTonePlayerWrapper(env, audioRendererInfo); +} + static shared_ptr GetAbilityContext(napi_env env) { HiLog::Info(LABEL, "Getting context with FA model"); @@ -658,6 +691,7 @@ napi_value TonePlayerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor static_prop[] = { DECLARE_NAPI_STATIC_FUNCTION("createTonePlayer", CreateTonePlayer), + DECLARE_NAPI_STATIC_FUNCTION("createTonePlayerSync", CreateTonePlayerSync), DECLARE_NAPI_PROPERTY("ToneType", CreateToneTypeObject(env)), }; diff --git a/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h b/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h index 30c9190ef3a0a904c9b85d901b9451565fb692e5..0e322be1446b9d4836c9bdde9c7d4699ad2e8698 100644 --- a/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h +++ b/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h @@ -80,15 +80,21 @@ private: static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); static napi_value Construct(napi_env env, napi_callback_info info); static napi_value CreateAudioCapturer(napi_env env, napi_callback_info info); + static napi_value CreateAudioCapturerSync(napi_env env, napi_callback_info info); static napi_value GetCapturerInfo(napi_env env, napi_callback_info info); + static napi_value GetCapturerInfoSync(napi_env env, napi_callback_info info); static napi_value GetStreamInfo(napi_env env, napi_callback_info info); + static napi_value GetStreamInfoSync(napi_env env, napi_callback_info info); static napi_value Start(napi_env env, napi_callback_info info); static napi_value Read(napi_env env, napi_callback_info info); static napi_value GetAudioTime(napi_env env, napi_callback_info info); + static napi_value GetAudioTimeSync(napi_env env, napi_callback_info info); static napi_value Stop(napi_env env, napi_callback_info info); static napi_value Release(napi_env env, napi_callback_info info); static napi_value GetBufferSize(napi_env env, napi_callback_info info); + static napi_value GetBufferSizeSync(napi_env env, napi_callback_info info); static napi_value GetAudioStreamId(napi_env env, napi_callback_info info); + static napi_value GetAudioStreamIdSync(napi_env env, napi_callback_info info); static napi_value On(napi_env env, napi_callback_info info); static napi_value Off(napi_env env, napi_callback_info info); static napi_value GetState(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/audio_manager/include/audio_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_manager_napi.h index fc4fee240fc8308327ffeddec7edf8dd02a3b5af..f12a394e8b0f096603a28372d5af9ab3655f752d 100644 --- a/interfaces/kits/js/audio_manager/include/audio_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_manager_napi.h @@ -82,6 +82,7 @@ private: static napi_value GetRingerMode(napi_env env, napi_callback_info info); static napi_value SetAudioScene(napi_env env, napi_callback_info info); static napi_value GetAudioScene(napi_env env, napi_callback_info info); + static napi_value GetAudioSceneSync(napi_env env, napi_callback_info info); static napi_value SetDeviceActive(napi_env env, napi_callback_info info); static napi_value IsDeviceActive(napi_env env, napi_callback_info info); static napi_value SetAudioParameter(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h index 36f6d5cd37d9c7d729ba357914487c390dc15a8c..4adbb1bed665eaa18ae3366010c7eb66e7dd1a02 100644 --- a/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h @@ -36,6 +36,7 @@ public: static napi_value CreateRoutingManagerWrapper(napi_env env); private: static napi_value GetDevices(napi_env env, napi_callback_info info); + static napi_value GetDevicesSync(napi_env env, napi_callback_info info); static void CheckParams(size_t argc, napi_env env, napi_value* argv, std::unique_ptr& asyncContext, const int32_t refCount, napi_value& result); @@ -46,10 +47,13 @@ private: static napi_value SelectInputDeviceByFilter(napi_env env, napi_callback_info info); static napi_value SetCommunicationDevice(napi_env env, napi_callback_info info); static napi_value IsCommunicationDeviceActive(napi_env env, napi_callback_info info); + static napi_value IsCommunicationDeviceActiveSync(napi_env env, napi_callback_info info); static napi_value GetActiveOutputDeviceDescriptors(napi_env env, napi_callback_info info); static napi_value GetPreferOutputDeviceForRendererInfo(napi_env env, napi_callback_info info); static napi_value GetPreferredOutputDeviceForRendererInfo(napi_env env, napi_callback_info info); + static napi_value GetPreferredOutputDeviceForRendererInfoSync(napi_env env, napi_callback_info info); static napi_value GetPreferredInputDeviceForCapturerInfo(napi_env env, napi_callback_info info); + static napi_value GetPreferredInputDeviceForCapturerInfoSync(napi_env env, napi_callback_info info); static void CheckPreferredInputDeviceForCaptureInfo(napi_env env, std::unique_ptr &asyncContext, size_t argc, napi_value *argv); static void CheckPreferredOutputDeviceForRendererInfo(napi_env env, diff --git a/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h b/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h index 4314c8409b94b63edd1acb030f041f2a833dcd3e..b4dd2dcd16253664861ff62a56a15a872db004ea 100644 --- a/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h @@ -57,11 +57,14 @@ private: }; static napi_value GetCurrentAudioRendererInfos(napi_env env, napi_callback_info info); + static napi_value GetCurrentAudioRendererInfosSync(napi_env env, napi_callback_info info); static napi_value GetCurrentAudioCapturerInfos(napi_env env, napi_callback_info info); + static napi_value GetCurrentAudioCapturerInfosSync(napi_env env, napi_callback_info info); static napi_value On(napi_env env, napi_callback_info info); static napi_value Off(napi_env env, napi_callback_info info); static napi_value IsAudioRendererLowLatencySupported(napi_env env, napi_callback_info info); static napi_value IsStreamActive(napi_env env, napi_callback_info info); + static napi_value IsStreamActiveSync(napi_env env, napi_callback_info info); static void RegisterCallback(napi_env env, napi_value jsThis, napi_value* args, const std::string& cbName); static void RegisterCapturerStateChangeCallback(napi_env env, napi_value* args, @@ -74,6 +77,7 @@ private: static bool ParseAudioStreamInfo(napi_env env, napi_value root, AudioStreamInfo &audioStreamInfo); static void IsLowLatencySupportedCallback(napi_env env, napi_status status, void *data); static napi_value GetEffectInfoArray(napi_env env, napi_callback_info info); + static napi_value GetEffectInfoArraySync(napi_env env, napi_callback_info info); static void GetCurrentCapturerChangeInfosCallbackComplete(napi_env env, napi_status status, void *data); static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void GetEffectInfoArrayCallbackComplete(napi_env env, napi_status status, void *data); diff --git a/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h index 2c997450060ca0aff234697978d52c3824f9aec8..6a8c4ead86f3d9575e47e54a9864325bdb376623 100755 --- a/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h @@ -46,20 +46,27 @@ private: static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); static napi_value Construct(napi_env env, napi_callback_info info); static napi_value GetVolume(napi_env env, napi_callback_info info); + static napi_value GetVolumeSync(napi_env env, napi_callback_info info); static napi_value SetVolume(napi_env env, napi_callback_info info); static napi_value GetMaxVolume(napi_env env, napi_callback_info info); + static napi_value GetMaxVolumeSync(napi_env env, napi_callback_info info); static napi_value GetMinVolume(napi_env env, napi_callback_info info); + static napi_value GetMinVolumeSync(napi_env env, napi_callback_info info); static napi_value SetMute(napi_env env, napi_callback_info info); static napi_value IsStreamMute(napi_env env, napi_callback_info info); + static napi_value IsStreamMuteSync(napi_env env, napi_callback_info info); static napi_value SetRingerMode(napi_env env, napi_callback_info info); static napi_value GetRingerMode(napi_env env, napi_callback_info info); + static napi_value GetRingerModeSync(napi_env env, napi_callback_info info); static napi_value SetMicrophoneMute(napi_env env, napi_callback_info info); static napi_value IsMicrophoneMute(napi_env env, napi_callback_info info); + static napi_value IsMicrophoneMuteSync(napi_env env, napi_callback_info info); static napi_value On(napi_env env, napi_callback_info info); static napi_value IsVolumeUnadjustable(napi_env env, napi_callback_info info); static napi_value AdjustVolumeByStep(napi_env env, napi_callback_info info); static napi_value AdjustSystemVolumeByStep(napi_env env, napi_callback_info info); static napi_value GetSystemVolumeInDb(napi_env env, napi_callback_info info); + static napi_value GetSystemVolumeInDbSync(napi_env env, napi_callback_info info); std::shared_ptr audioGroupMngr_ = nullptr; int32_t cachedClientId_ = -1; diff --git a/interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h index f63258643d2561a5713435974e735e2449cce55b..680e15a35c5d10d2d7d2d709c8e436feed61e295 100644 --- a/interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h @@ -36,7 +36,9 @@ public: static napi_value CreateVolumeManagerWrapper(napi_env env); private: static napi_value GetVolumeGroupInfos(napi_env env, napi_callback_info info); + static napi_value GetVolumeGroupInfosSync(napi_env env, napi_callback_info info); static napi_value GetVolumeGroupManager(napi_env env, napi_callback_info info); + static napi_value GetVolumeGroupManagerSync(napi_env env, napi_callback_info info); static napi_value SetRingerMode(napi_env env, napi_callback_info info); static napi_value GetRingerMode(napi_env env, napi_callback_info info); static napi_value SetMicrophoneMute(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h b/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h index ee781a14065933242fce6f643c6f4bdd570c731c..c10feb0d934572ecedfdc4dee280bacbb2608b38 100644 --- a/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h +++ b/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h @@ -96,31 +96,43 @@ private: static void CreateRendererFailed(); static napi_value Construct(napi_env env, napi_callback_info info); static napi_value CreateAudioRenderer(napi_env env, napi_callback_info info); + static napi_value CreateAudioRendererSync(napi_env env, napi_callback_info info); static napi_value SetRenderRate(napi_env env, napi_callback_info info); static napi_value GetRenderRate(napi_env env, napi_callback_info info); + static napi_value GetRenderRateSync(napi_env env, napi_callback_info info); static napi_value SetRendererSamplingRate(napi_env env, napi_callback_info info); static napi_value GetRendererSamplingRate(napi_env env, napi_callback_info info); static napi_value Start(napi_env env, napi_callback_info info); static napi_value Write(napi_env env, napi_callback_info info); static napi_value GetAudioTime(napi_env env, napi_callback_info info); + static napi_value GetAudioTimeSync(napi_env env, napi_callback_info info); static napi_value Drain(napi_env env, napi_callback_info info); static napi_value Pause(napi_env env, napi_callback_info info); static napi_value Stop(napi_env env, napi_callback_info info); static napi_value Release(napi_env env, napi_callback_info info); static napi_value GetBufferSize(napi_env env, napi_callback_info info); + static napi_value GetBufferSizeSync(napi_env env, napi_callback_info info); static napi_value GetAudioStreamId(napi_env env, napi_callback_info info); + static napi_value GetAudioStreamIdSync(napi_env env, napi_callback_info info); static napi_value SetVolume(napi_env env, napi_callback_info info); static napi_value GetState(napi_env env, napi_callback_info info); static napi_value GetRendererInfo(napi_env env, napi_callback_info info); + static napi_value GetRendererInfoSync(napi_env env, napi_callback_info info); static napi_value GetStreamInfo(napi_env env, napi_callback_info info); + static napi_value GetStreamInfoSync(napi_env env, napi_callback_info info); static napi_value On(napi_env env, napi_callback_info info); static napi_value Off(napi_env env, napi_callback_info info); static napi_value CreateAudioRendererWrapper(napi_env env, std::unique_ptr &renderOptions); static napi_value SetInterruptMode(napi_env env, napi_callback_info info); + static napi_value SetInterruptModeSync(napi_env env, napi_callback_info info); static napi_value GetMinStreamVolume(napi_env env, napi_callback_info info); + static napi_value GetMinStreamVolumeSync(napi_env env, napi_callback_info info); static napi_value GetMaxStreamVolume(napi_env env, napi_callback_info info); + static napi_value GetMaxStreamVolumeSync(napi_env env, napi_callback_info info); static napi_value GetCurrentOutputDevices(napi_env env, napi_callback_info info); + static napi_value GetCurrentOutputDevicesSync(napi_env env, napi_callback_info info); static napi_value GetUnderflowCount(napi_env env, napi_callback_info info); + static napi_value GetUnderflowCountSync(napi_env env, napi_callback_info info); static napi_value GetAudioEffectMode(napi_env env, napi_callback_info info); static napi_value SetAudioEffectMode(napi_env env, napi_callback_info info); static napi_value SetChannelBlendMode(napi_env env, napi_callback_info info); @@ -128,6 +140,8 @@ private: std::unique_ptr &asyncContext); static void JudgeFuncGetAudioStreamId(napi_env &env, napi_value &result, std::unique_ptr &asyncContext); + static void GetArgvForSetAudioEffectMode(napi_env env, size_t argc, napi_value* argv, + std::unique_ptr &asyncContext); static bool ParseRendererOptions(napi_env env, napi_value root, AudioRendererOptions *opts); static bool ParseRendererInfo(napi_env env, napi_value root, AudioRendererInfo *rendererInfo); diff --git a/interfaces/kits/js/toneplayer/include/toneplayer_napi.h b/interfaces/kits/js/toneplayer/include/toneplayer_napi.h index 8d386ed05c3e4434dd6dc3506c1b049ed2939792..cfcf475f80ca3365fed7d8c2c188b3c754a7ecb9 100644 --- a/interfaces/kits/js/toneplayer/include/toneplayer_napi.h +++ b/interfaces/kits/js/toneplayer/include/toneplayer_napi.h @@ -79,6 +79,7 @@ private: static napi_value Construct(napi_env env, napi_callback_info info); static bool ParseRendererInfo(napi_env env, napi_value root, AudioRendererInfo *rendererInfo); static napi_value CreateTonePlayer(napi_env env, napi_callback_info info); + static napi_value CreateTonePlayerSync(napi_env env, napi_callback_info info); static bool toneTypeCheck(napi_env env, int32_t type); static napi_value Load(napi_env env, napi_callback_info info); static napi_value Start(napi_env env, napi_callback_info info);