From 1106391b8edb1aec26e84b3a14f43f2678128627 Mon Sep 17 00:00:00 2001 From: wangtao Date: Fri, 14 Oct 2022 22:15:30 +0800 Subject: [PATCH 1/5] napi errorCode for audioManager Signed-off-by: wangtao Change-Id: I683167ee844b32412f598e82d35b767da93f8524 --- frameworks/js/napi/BUILD.gn | 9 +- .../audio_common/include/audio_common_napi.h | 52 ++ .../audio_common/src/audio_common_napi.cpp | 134 +++ ...h => audio_micstatechange_callback_napi.h} | 10 +- .../src/audio_interrupt_manager_napi.cpp | 154 ++++ .../audio_manager/src/audio_manager_napi.cpp | 847 ++++++++---------- ...=> audio_micstatechange_callback_napi.cpp} | 22 +- .../src/audio_routing_manager_napi.cpp | 353 ++++++-- .../src/audio_stream_mgr_napi.cpp | 225 ++++- ...pp => audio_volume_group_manager_napi.cpp} | 682 +++++++++++--- .../src/audio_volume_manager_napi.cpp | 455 ++++++++++ .../native/audiocommon/include/audio_info.h | 50 +- .../include/audio_interrupt_manager_napi.h | 49 + .../include/audio_manager_napi.h | 44 +- .../include/audio_routing_manager_napi.h | 5 +- .../include/audio_stream_mgr_napi.h | 3 + .../include/audio_volume_group_manager_napi.h | 31 +- .../include/audio_volume_manager_napi.h | 58 ++ 18 files changed, 2411 insertions(+), 772 deletions(-) rename frameworks/js/napi/audio_manager/include/{audio_routing_manager_callback_napi.h => audio_micstatechange_callback_napi.h} (80%) create mode 100644 frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp rename frameworks/js/napi/audio_manager/src/{audio_routing_manager_callback_napi.cpp => audio_micstatechange_callback_napi.cpp} (79%) rename frameworks/js/napi/{audio_stream_manager => audio_manager}/src/audio_stream_mgr_napi.cpp (77%) rename frameworks/js/napi/audio_manager/src/{audio_group_manager_napi.cpp => audio_volume_group_manager_napi.cpp} (39%) create mode 100644 frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp create mode 100644 interfaces/kits/js/audio_manager/include/audio_interrupt_manager_napi.h rename {frameworks/js/napi => interfaces/kits/js}/audio_manager/include/audio_routing_manager_napi.h (94%) rename interfaces/kits/js/{audio_stream_manager => audio_manager}/include/audio_stream_mgr_napi.h (95%) rename frameworks/js/napi/audio_manager/include/audio_group_manager_napi.h => interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h (56%) create mode 100644 interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h diff --git a/frameworks/js/napi/BUILD.gn b/frameworks/js/napi/BUILD.gn index ca98e62f76..0fe2435c65 100644 --- a/frameworks/js/napi/BUILD.gn +++ b/frameworks/js/napi/BUILD.gn @@ -28,7 +28,6 @@ ohos_shared_library("audio") { "audio_manager/include", "audio_stream_manager/include", "//foundation/multimedia/audio_framework/interfaces/kits/js/audio_manager/include", - "//foundation/multimedia/audio_framework/interfaces/kits/js/audio_stream_manager/include", "//foundation/multimedia/audio_framework/interfaces/kits/js/audio_capturer/include", "//foundation/multimedia/audio_framework/interfaces/kits/js/audio_renderer/include", "//foundation/multimedia/audio_framework/interfaces/kits/js/ringtone_manager/include", @@ -49,13 +48,13 @@ ohos_shared_library("audio") { "audio_capturer/src/capturer_position_callback_napi.cpp", "audio_common/src/audio_common_napi.cpp", "audio_manager/src/audio_capturer_state_callback_napi.cpp", - "audio_manager/src/audio_group_manager_napi.cpp", + "audio_manager/src/audio_volume_group_manager_napi.cpp", "audio_manager/src/audio_manager_callback_napi.cpp", "audio_manager/src/audio_manager_interrupt_callback_napi.cpp", "audio_manager/src/audio_manager_napi.cpp", "audio_manager/src/audio_renderer_state_callback_napi.cpp", "audio_manager/src/audio_ringermode_callback_napi.cpp", - "audio_manager/src/audio_routing_manager_callback_napi.cpp", + "audio_manager/src/audio_micstatechange_callback_napi.cpp", "audio_manager/src/audio_routing_manager_napi.cpp", "audio_manager/src/audio_volume_key_event_napi.cpp", "audio_renderer/src/audio_renderer_callback_napi.cpp", @@ -63,8 +62,10 @@ ohos_shared_library("audio") { "audio_renderer/src/renderer_data_request_callback_napi.cpp", "audio_renderer/src/renderer_period_position_callback_napi.cpp", "audio_renderer/src/renderer_position_callback_napi.cpp", - "audio_stream_manager/src/audio_stream_mgr_napi.cpp", "toneplayer/src/toneplayer_napi.cpp", + "audio_manager/src/audio_volume_manager_napi.cpp", + "audio_manager/src/audio_interrupt_manager_napi.cpp", + "audio_manager/src/audio_stream_mgr_napi.cpp", ] deps = [ 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 71db772a67..d56732e80d 100644 --- a/frameworks/js/napi/audio_common/include/audio_common_napi.h +++ b/frameworks/js/napi/audio_common/include/audio_common_napi.h @@ -18,6 +18,23 @@ #include "napi/native_api.h" #include "napi/native_node_api.h" +#include "audio_info.h" + + +#define THROW_ERROR_ASSERT(env, assertion, code) \ + do { \ + if (!(assertion)) { \ + AudioCommonNapi::throwError( env, code); \ + return nullptr; \ + } \ + } while (0) + +#define GET_PARAMS(env, info, num) \ + size_t argc = num; \ + napi_value argv[num] = {0}; \ + napi_value thisVar = nullptr; \ + void *data; \ + napi_get_cb_info(env, info, &argc, argv, &thisVar, &data) namespace OHOS { namespace AudioStandard { @@ -29,9 +46,27 @@ namespace { class AudioCommonNapi { public: + enum AudioVolumeType { + VOLUMETYPE_DEFAULT = -1, + VOICE_CALL = 0, + RINGTONE = 2, + MEDIA = 3, + VOICE_ASSISTANT = 9, + VOLUMETYPE_MAX, + ALL = 100 + }; AudioCommonNapi() = delete; ~AudioCommonNapi() = delete; static std::string GetStringArgument(napi_env env, napi_value value); + static std::string getMessageByCode(int32_t &code); + static void throwError (napi_env env, int32_t code); + static bool IsLegalInputArgumentVolLevel(int32_t volLevel); + static bool IsLegalInputArgumentVolType(int32_t inputType); + static bool IsLegalInputArgumentDeviceFlag(int32_t inputType); + static bool IsLegalInputArgumentActiveDeviceType(int32_t deviceType); + static bool IsLegalInputArgumentCommunicationDeviceType(int32_t deviceType); + static bool IsLegalInputArgumentRingMode(int32_t ringerMode); + static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType); }; struct AutoRef { @@ -48,6 +83,23 @@ struct AutoRef { napi_env env_; napi_ref cb_; }; +const int32_t ERR_NUMBER_401 = 401; +const int32_t ERR_NUMBER101 = ERROR_INVALID_PARAM; +const int32_t ERR_NUMBER102 = ERROR_NO_MEMORY; +const int32_t ERR_NUMBER103 = ERROR_ILLEGAL_STATE; +const int32_t ERR_NUMBER104 = ERROR_UNSUPPORTED; +const int32_t ERR_NUMBER105 = ERROR_TIMEOUT; +const int32_t ERR_NUMBER201 = ERROR_STREAM_LIMIT; +const int32_t ERR_NUMBER301 = ERROR_SYSTEM; + +const std::string ERR_MESSAGE_401 = "input parameter type or number mismatch"; +const std::string ERR_MESSAGE101 = "invalid parameter"; +const std::string ERR_MESSAGE102 = "allocate memory failed"; +const std::string ERR_MESSAGE103 = "Operation not permit at current state"; +const std::string ERR_MESSAGE104 = "unsupported option"; +const std::string ERR_MESSAGE105 = "time out"; +const std::string ERR_MESSAGE201 = "stream number limited"; +const std::string ERR_MESSAGE301 = "system error"; } // namespace AudioStandard } // namespace OHOS #endif // AUDIO_COMMON_NAPI_H_ 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 7ab28fbd44..77fc790dff 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -15,6 +15,7 @@ #include "audio_common_napi.h" #include "audio_log.h" +#include "audio_manager_napi.h" namespace OHOS { namespace AudioStandard { @@ -36,5 +37,138 @@ std::string AudioCommonNapi::GetStringArgument(napi_env env, napi_value value) } return strValue; } + +std::string AudioCommonNapi::getMessageByCode(int32_t &code){ + std::string err_message; + switch (code) { + case ERR_NUMBER101: + err_message = ERR_MESSAGE101; + break; + case ERR_NUMBER102: + err_message = ERR_MESSAGE102; + break; + case ERR_NUMBER103: + err_message = ERR_MESSAGE103; + break; + case ERR_NUMBER104: + err_message = ERR_MESSAGE104; + break; + case ERR_NUMBER105: + err_message = ERR_MESSAGE105; + break; + case ERR_NUMBER201: + err_message = ERR_MESSAGE201; + break; + case ERR_NUMBER301: + err_message = ERR_MESSAGE301; + break; + case ERR_NUMBER_401: + err_message = ERR_MESSAGE_401; + break; + default: + err_message = ERR_MESSAGE301; + code = ERR_NUMBER301; + break; + } + return err_message; +} + +void AudioCommonNapi::throwError(napi_env env,int32_t code){ + std::string messageValue = AudioCommonNapi::getMessageByCode(code); + napi_throw_error(env, (std::to_string(code)).c_str(), messageValue.c_str()); +} + +bool AudioCommonNapi::IsLegalInputArgumentVolLevel(int32_t volLevel) +{ + return (volLevel < 0 || volLevel > 15) ? false : true; +} + +bool AudioCommonNapi::IsLegalInputArgumentVolType(int32_t inputType) +{ + bool result = false; + switch (inputType) { + case AudioManagerNapi::RINGTONE: + case AudioManagerNapi::MEDIA: + case AudioManagerNapi::VOICE_CALL: + case AudioManagerNapi::VOICE_ASSISTANT: + case AudioManagerNapi::ALL: + result = true; + break; + default: + result = false; + break; + } + return result; +} + +bool AudioCommonNapi::IsLegalInputArgumentDeviceFlag(int32_t deviceFlag) +{ + bool result = false; + switch (deviceFlag) { + case DeviceFlag::NONE_DEVICES_FLAG: + case DeviceFlag::OUTPUT_DEVICES_FLAG: + case DeviceFlag::INPUT_DEVICES_FLAG: + case DeviceFlag::ALL_DEVICES_FLAG: + case DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG: + case DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG: + case DeviceFlag::ALL_DISTRIBUTED_DEVICES_FLAG: + case DeviceFlag::ALL_L_D_DEVICES_FLAG: + result = true; + break; + default: + result = false; + break; + } + return result; +} + +bool AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag) +{ + bool result = false; + switch (activeDeviceFlag) { + + case ActiveDeviceType::SPEAKER: + case ActiveDeviceType::BLUETOOTH_SCO: + + result = true; + break; + default: + result = false; + break; + } + return result; +} + +bool AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType) +{ + bool result = false; + switch (communicationDeviceType) { + + case CommunicationDeviceType::COMMUNICATION_SPEAKER: + result = true; + break; + default: + result = false; + break; + } + return result; +} + +bool AudioCommonNapi::IsLegalInputArgumentRingMode(int32_t ringerMode) +{ + bool result = false; + switch (ringerMode) { + case AudioRingerMode::RINGER_MODE_SILENT: + case AudioRingerMode::RINGER_MODE_VIBRATE: + case AudioRingerMode::RINGER_MODE_NORMAL: + result = true; + break; + default: + result = false; + break; + } + return result; +} + } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/include/audio_routing_manager_callback_napi.h b/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h similarity index 80% rename from frameworks/js/napi/audio_manager/include/audio_routing_manager_callback_napi.h rename to frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h index 0b39b47b51..dd11006813 100644 --- a/frameworks/js/napi/audio_manager/include/audio_routing_manager_callback_napi.h +++ b/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h @@ -24,21 +24,21 @@ namespace OHOS { namespace AudioStandard { -class AudioRoutingManagerCallbackNapi : public AudioManagerMicStateChangeCallback { +class AudioManagerMicStateChangeCallbackNapi : public AudioManagerMicStateChangeCallback { public: - explicit AudioRoutingManagerCallbackNapi(napi_env env); - virtual ~AudioRoutingManagerCallbackNapi(); + explicit AudioManagerMicStateChangeCallbackNapi(napi_env env); + virtual ~AudioManagerMicStateChangeCallbackNapi(); void SaveCallbackReference(const std::string &callbackName, napi_value callback); void OnMicStateUpdated(const MicStateChangeEvent &micStateChangeEvent) override; private: - struct AudioRoutingManagerJsCallback { + struct AudioManagerMicStateChangeJsCallback { std::shared_ptr callback = nullptr; std::string callbackName = "unknown"; MicStateChangeEvent micStateChangeEvent; }; - void OnJsCallbackMicStateChange(std::unique_ptr &jsCb); + void OnJsCallbackMicStateChange(std::unique_ptr &jsCb); std::mutex mutex_; napi_env env_ = nullptr; diff --git a/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp new file mode 100644 index 0000000000..df72b56b79 --- /dev/null +++ b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_interrupt_manager_napi.h" + +#include "audio_common_napi.h" +#include "audio_micstatechange_callback_napi.h" +#include "audio_errors.h" +#include "audio_log.h" +#include "hilog/log.h" +#include "napi_base_context.h" + +using namespace std; +using OHOS::HiviewDFX::HiLog; +using OHOS::HiviewDFX::HiLogLabel; + +namespace OHOS { +namespace AudioStandard { +static __thread napi_ref g_interruptManagerConstructor = nullptr; + +namespace { + // const int ARGS_ONE = 1; + const int ARGS_TWO = 2; + const int PARAM0 = 0; + // const int PARAM1 = 1; + constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioInterruptManagerNapi"}; +} + +struct AudioInterruptManagerAsyncContext { + napi_env env; + napi_async_work work; + napi_deferred deferred; + napi_ref callbackRef = nullptr; + int32_t deviceFlag; + bool bArgTransFlag = true; + int32_t status = SUCCESS; + int32_t groupId; + std::string networkId; + AudioInterruptManagerNapi *objectInfo; +}; + +AudioInterruptManagerNapi::AudioInterruptManagerNapi() + : audioSystemMngr_(nullptr), env_(nullptr), wrapper_(nullptr) {} + +AudioInterruptManagerNapi::~AudioInterruptManagerNapi() +{ + if (wrapper_ != nullptr) { + napi_delete_reference(env_, wrapper_); + } +} + +void AudioInterruptManagerNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint) +{ + if (nativeObject != nullptr) { + auto obj = static_cast(nativeObject); + delete obj; + obj = nullptr; + } +} + +napi_value AudioInterruptManagerNapi::Construct(napi_env env, napi_callback_info info) +{ + AUDIO_INFO_LOG("AudioInterruptManagerNapi::Construct"); + napi_status status; + napi_value result = nullptr; + napi_get_undefined(env, &result); + + size_t argc = ARGS_TWO; + napi_value argv[ARGS_TWO] = {0}; + napi_value thisVar = nullptr; + void *data = nullptr; + napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); + unique_ptr audioInterruptManagerNapi = make_unique(); + CHECK_AND_RETURN_RET_LOG(audioInterruptManagerNapi != nullptr, result, "No memory"); + + audioInterruptManagerNapi->audioSystemMngr_ = AudioSystemManager::GetInstance(); + + audioInterruptManagerNapi->env_ = env; + + status = napi_wrap(env, thisVar, static_cast(audioInterruptManagerNapi.get()), + AudioInterruptManagerNapi::Destructor, nullptr, &(audioInterruptManagerNapi->wrapper_)); + if (status == napi_ok) { + audioInterruptManagerNapi.release(); + return thisVar; + } + + HiLog::Error(LABEL, "Failed in AudioInterruptManager::Construct()!"); + return result; +} + +napi_value AudioInterruptManagerNapi::CreateInterruptManagerWrapper(napi_env env) +{ + napi_status status; + napi_value result = nullptr; + napi_value constructor; + + status = napi_get_reference_value(env, g_interruptManagerConstructor, &constructor); + if (status == napi_ok) { + status = napi_new_instance(env, constructor, 0, nullptr, &result); + if (status == napi_ok) { + return result; + } + } + HiLog::Error(LABEL, "Failed in AudioInterruptManagerNapi::CreateInterruptManagerWrapper!"); + napi_get_undefined(env, &result); + + return result; +} + +napi_value AudioInterruptManagerNapi::Init(napi_env env, napi_value exports) +{ + AUDIO_INFO_LOG("AudioInterruptManagerNapi::Init"); + napi_status status; + napi_value constructor; + napi_value result = nullptr; + const int32_t refCount = 1; + napi_get_undefined(env, &result); + + napi_property_descriptor audio_routing_manager_properties[] = { + + }; + + status = napi_define_class(env, AUDIO_INTERRUPT_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, + sizeof(audio_routing_manager_properties) / sizeof(audio_routing_manager_properties[PARAM0]), + audio_routing_manager_properties, &constructor); + if (status != napi_ok) { + return result; + } + status = napi_create_reference(env, constructor, refCount, &g_interruptManagerConstructor); + if (status == napi_ok) { + status = napi_set_named_property(env, exports, AUDIO_INTERRUPT_MANAGER_NAPI_CLASS_NAME.c_str(), constructor); + if (status == napi_ok) { + return exports; + } + } + + HiLog::Error(LABEL, "Failure in AudioInterruptManagerNapi::Init()"); + 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 cc0925c261..b5f7db2676 100644 --- a/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp @@ -25,8 +25,10 @@ #include "audio_manager_callback_napi.h" #include "audio_manager_interrupt_callback_napi.h" #include "audio_volume_key_event_napi.h" -#include "audio_group_manager_napi.h" - +#include "audio_common_napi.h" +#include "audio_volume_manager_napi.h" +#include "audio_volume_group_manager_napi.h" +#include "audio_interrupt_manager_napi.h" #include "hilog/log.h" #include "audio_log.h" #include "toneplayer_napi.h" @@ -58,6 +60,11 @@ napi_ref AudioManagerNapi::interruptType_ = nullptr; napi_ref AudioManagerNapi::audioScene_ = nullptr; napi_ref AudioManagerNapi::interruptMode_ = nullptr; napi_ref AudioManagerNapi::focusType_ = nullptr; +napi_ref AudioManagerNapi::audioErrors_ = nullptr; +napi_ref AudioManagerNapi::communicationDeviceType_ = nullptr; +napi_ref AudioManagerNapi::audioOutputChannelMask_ = nullptr; +napi_ref AudioManagerNapi::audioInputChannelMask_ = nullptr; + #define GET_PARAMS(env, info, num) \ size_t argc = num; \ @@ -78,7 +85,7 @@ struct AudioManagerAsyncContext { int32_t scene; int32_t deviceFlag; int32_t intValue; - int32_t status; + int32_t status = 0; int32_t focusType; int32_t groupId; bool isMute; @@ -152,34 +159,15 @@ static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) return result; } -static bool IsLegalInputArgument(int32_t inputType) -{ - bool result = false; - switch (inputType) { - case AudioManagerNapi::RINGTONE: - case AudioManagerNapi::MEDIA: - case AudioManagerNapi::VOICE_CALL: - case AudioManagerNapi::VOICE_ASSISTANT: - case AudioManagerNapi::ALL: - result = true; - break; - default: - HiLog::Error(LABEL, "Unknown volume type"); - result = false; - break; - } - return result; -} - static AudioStandard::FocusType GetNativeFocusType(int32_t focusType) { - AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING; + AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_DEFAULT; switch (focusType) { - case AudioManagerNapi::FocusType::FOCUS_TYPE_RECORDING: - result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING; + case AudioManagerNapi::FocusType::FOCUS_TYPE_DEFAULT: + result = AudioStandard::FocusType::FOCUS_TYPE_DEFAULT; break; default: - HiLog::Error(LABEL, "Unknown focusType type, Set it to default FOCUS_TYPE_RECORDING!"); + HiLog::Error(LABEL, "Unknown focusType type, Set it to default FOCUS_TYPE_DEFAULT!"); break; } @@ -738,7 +726,11 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) napi_value result = nullptr; const int32_t refCount = 1; napi_value localNetworkId; - napi_create_string_utf8(env, "LocalDevice", NAPI_AUTO_LENGTH, &localNetworkId); + napi_create_string_utf8(env, LOCAL_NETWORK_ID.c_str(), NAPI_AUTO_LENGTH, &localNetworkId); + napi_value defaultVolumeGroupId; + napi_create_int32(env, DEFAULT_VOLUME_GROUP_ID, &defaultVolumeGroupId); + napi_value defaultInterruptId; + napi_create_int32(env, DEFAULT_VOLUME_INTERRUPT_ID, &defaultInterruptId); napi_property_descriptor audio_svc_mngr_properties[] = { DECLARE_NAPI_FUNCTION("setVolume", SetVolume), @@ -765,8 +757,8 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("abandonIndependentInterrupt", AbandonIndependentInterrupt), DECLARE_NAPI_FUNCTION("getStreamManager", GetStreamManager), DECLARE_NAPI_FUNCTION("getRoutingManager", GetRoutingManager), - DECLARE_NAPI_FUNCTION("getVolumeGroups", GetVolumeGroups), - DECLARE_NAPI_FUNCTION("getGroupManager", GetGroupManager), + DECLARE_NAPI_FUNCTION("getVolumeManager", GetVolumeManager), + DECLARE_NAPI_FUNCTION("getInterruptManager", GetInterruptManager), }; napi_property_descriptor static_prop[] = { @@ -785,7 +777,14 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_PROPERTY("InterruptType", CreateInterruptTypeObject(env)), DECLARE_NAPI_PROPERTY("InterruptMode", CreatePropertyBase(env, interruptModeMap, interruptMode_)), DECLARE_NAPI_PROPERTY("FocusType", CreatePropertyBase(env, focusTypeMap, focusType_)), - DECLARE_NAPI_PROPERTY("LOCAL_NETWORK_ID", localNetworkId) + DECLARE_NAPI_PROPERTY("LOCAL_NETWORK_ID", localNetworkId), + DECLARE_NAPI_PROPERTY("DEFAULT_VOLUME_GROUP_ID", defaultVolumeGroupId), + DECLARE_NAPI_PROPERTY("DEFAULT_INTERRUPT_GROUP_ID", defaultInterruptId), + DECLARE_NAPI_PROPERTY("AudioErrors", CreatePropertyBase(env, audioErrorsMap, audioErrors_)), + DECLARE_NAPI_PROPERTY("CommunicationDeviceType", CreatePropertyBase(env, communicationDeviceTypeMap, communicationDeviceType_)), + DECLARE_NAPI_PROPERTY("AudioOutputChannelMask", CreatePropertyBase(env, audioOutputChannelMaskMap, audioOutputChannelMask_)), + DECLARE_NAPI_PROPERTY("AudioInputChannelMask", CreatePropertyBase(env, audioInputChannelMaskMap, audioInputChannelMask_)), + }; status = napi_define_class(env, AUDIO_MNGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -891,16 +890,15 @@ static void CommonCallbackRoutine(napi_env env, AudioManagerAsyncContext* &async if (!asyncContext->status) { napi_get_undefined(env, &result[PARAM0]); result[PARAM1] = valueParam; - } else if (ERR_INVALID_PARAM == asyncContext->status) { - napi_value message = nullptr; - napi_create_string_utf8(env, "Error, The input parameters are incorrect, please check!", - NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); - napi_get_undefined(env, &result[PARAM1]); } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -1001,8 +999,10 @@ napi_value AudioManagerNapi::RequestIndependentInterrupt(napi_env env, napi_call if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->focusType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { NAPI_ASSERT(env, false, "type mismatch"); @@ -1060,8 +1060,10 @@ napi_value AudioManagerNapi::AbandonIndependentInterrupt(napi_env env, napi_call napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->focusType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { NAPI_ASSERT(env, false, "type mismatch"); @@ -1109,23 +1111,27 @@ napi_value AudioManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1142,7 +1148,9 @@ napi_value AudioManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = context->objectInfo->audioMngr_->SetMicrophoneMute(context->isMute); + if (context->status == SUCCESS) { + context->status = context->objectInfo->audioMngr_->SetMicrophoneMute(context->isMute); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1172,16 +1180,12 @@ napi_value AudioManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info i status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } } if (asyncContext->callbackRef == nullptr) { @@ -1197,8 +1201,10 @@ napi_value AudioManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info i env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->isMute = context->objectInfo->audioMngr_->IsMicrophoneMute(); - context->isTrue = context->isMute; + if (context->status == SUCCESS) { + context->isMute = context->objectInfo->audioMngr_->IsMicrophoneMute(); + context->isTrue = context->isMute; + } }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1223,23 +1229,30 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->ringMode); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1256,8 +1269,10 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = - context->objectInfo->audioMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode)); + if (context->status == SUCCESS) { + context->status = + context->objectInfo->audioMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode)); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1287,16 +1302,12 @@ napi_value AudioManagerNapi::GetRingerMode(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } } if (asyncContext->callbackRef == nullptr) { @@ -1312,9 +1323,11 @@ napi_value AudioManagerNapi::GetRingerMode(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->ringMode = GetJsAudioRingMode(context->objectInfo->audioMngr_->GetRingerMode()); - context->intValue = context->ringMode; - context->status = 0; + if (context->status == SUCCESS) { + context->ringMode = GetJsAudioRingMode(context->objectInfo->audioMngr_->GetRingerMode()); + context->intValue = context->ringMode; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1340,7 +1353,6 @@ napi_value AudioManagerNapi::SetAudioScene(napi_env env, napi_callback_info info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); @@ -1352,11 +1364,13 @@ napi_value AudioManagerNapi::SetAudioScene(napi_env env, napi_callback_info info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->scene); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1374,7 +1388,7 @@ napi_value AudioManagerNapi::SetAudioScene(napi_env env, napi_callback_info info [](napi_env env, void *data) { auto context = static_cast(data); if ((context->scene < AUDIO_SCENE_DEFAULT) || (context->scene > AUDIO_SCENE_PHONE_CHAT)) { - context->status = ERROR; + context->status = ERR_NUMBER101; } else { context->status = context->objectInfo->audioMngr_->SetAudioScene(static_cast(context->scene)); @@ -1408,16 +1422,13 @@ napi_value AudioManagerNapi::GetAudioScene(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); + napi_typeof(env, argv[PARAM0], &valueType); - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } } if (asyncContext->callbackRef == nullptr) { @@ -1433,8 +1444,10 @@ napi_value AudioManagerNapi::GetAudioScene(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->intValue = context->objectInfo->audioMngr_->GetAudioScene(); - context->status = 0; + if (context->status == SUCCESS) { + context->intValue = context->objectInfo->audioMngr_->GetAudioScene(); + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1459,25 +1472,32 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1494,8 +1514,10 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = context->objectInfo->audioMngr_->SetMute(GetNativeAudioVolumeType(context->volType), + if(context->status == 0){ + context->status = context->objectInfo->audioMngr_->SetMute(GetNativeAudioVolumeType(context->volType), context->isMute); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1520,23 +1542,30 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1553,10 +1582,12 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->isMute = - context->objectInfo->audioMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); - context->isTrue = context->isMute; - context->status = 0; + if(context->status == 0){ + context->isMute = + context->objectInfo->audioMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); + context->isTrue = context->isMute; + context->status = 0; + } }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1581,23 +1612,30 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1){ + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1612,12 +1650,14 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf status = napi_create_async_work( env, nullptr, resource, - [](napi_env env, void *data) { + [](napi_env edeviceTypenv, void *data) { auto context = static_cast(data); - context->isActive = - context->objectInfo->audioMngr_->IsStreamActive(GetNativeAudioVolumeType(context->volType)); - context->isTrue = context->isActive; - context->status = 0; + if (context->status == SUCCESS) { + context->isActive = + context->objectInfo->audioMngr_->IsStreamActive(GetNativeAudioVolumeType(context->volType)); + context->isTrue = context->isActive; + context->status = SUCCESS; + } }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1642,25 +1682,32 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isActive); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1677,8 +1724,10 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = context->objectInfo->audioMngr_->SetDeviceActive( - static_cast(context->deviceType), context->isActive); + if (context->status == 0) { + context->status = context->objectInfo->audioMngr_->SetDeviceActive( + static_cast(context->deviceType), context->isActive); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1703,26 +1752,34 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } + if (asyncContext->callbackRef == nullptr) { napi_create_promise(env, &asyncContext->deferred, &result); } else { @@ -1736,10 +1793,12 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->isActive = - context->objectInfo->audioMngr_->IsDeviceActive(static_cast(context->deviceType)); - context->isTrue = context->isActive; - context->status = 0; + if (context->status == SUCCESS) { + context->isActive = + context->objectInfo->audioMngr_->IsDeviceActive(static_cast(context->deviceType)); + context->isTrue = context->isActive; + context->status = 0; + } }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1764,12 +1823,14 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -1778,11 +1839,13 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info asyncContext->key = AudioCommonNapi::GetStringArgument(env, argv[i]); } else if (i == PARAM1 && valueType == napi_string) { asyncContext->valueStr = AudioCommonNapi::GetStringArgument(env, argv[i]); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1799,8 +1862,10 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->objectInfo->audioMngr_->SetAudioParameter(context->key, context->valueStr); - context->status = 0; + if (context->status == SUCCESS) { + context->objectInfo->audioMngr_->SetAudioParameter(context->key, context->valueStr); + context->status = 0; + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1825,23 +1890,27 @@ napi_value AudioManagerNapi::GetAudioParameter(napi_env env, napi_callback_info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_string) { asyncContext->key = AudioCommonNapi::GetStringArgument(env, argv[i]); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1857,8 +1926,10 @@ napi_value AudioManagerNapi::GetAudioParameter(napi_env env, napi_callback_info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->valueStr = context->objectInfo->audioMngr_->GetAudioParameter(context->key); - context->status = 0; + if (context->status == SUCCESS) { + context->valueStr = context->objectInfo->audioMngr_->GetAudioParameter(context->key); + context->status = 0; + } }, GetStringValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1883,25 +1954,34 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } + } else if (i == PARAM2) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1918,8 +1998,10 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), - context->volLevel); + if(context->status == 0){ + context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), + context->volLevel); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1944,23 +2026,30 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1977,16 +2066,12 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - - bool isLegalInput = IsLegalInputArgument(context->volType); - if (!isLegalInput) { - context->status = ERR_INVALID_PARAM; - } else { - context->volLevel = context->objectInfo->audioMngr_->GetVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; - } + if(context->status == 0){ + context->volLevel = context->objectInfo->audioMngr_->GetVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -2011,23 +2096,30 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break;; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -2044,10 +2136,12 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->volLevel = context->objectInfo->audioMngr_->GetMaxVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; + if(context->status == 0){ + context->volLevel = context->objectInfo->audioMngr_->GetMaxVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -2072,23 +2166,30 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -2105,10 +2206,12 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->volLevel = context->objectInfo->audioMngr_->GetMinVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; + if(context->status == 0){ + context->volLevel = context->objectInfo->audioMngr_->GetMinVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -2146,7 +2249,6 @@ static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, vo auto asyncContext = static_cast(data); napi_value result[ARGS_TWO] = {0}; napi_value valueParam = nullptr; - napi_value retVal; size_t size = asyncContext->deviceDescriptors.size(); HiLog::Info(LABEL, "number of devices = %{public}zu", size); @@ -2176,6 +2278,18 @@ static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, vo napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); + napi_value channelOut; + napi_create_array_with_length(env, 1, &channelOut); + napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelOut, &value); + napi_set_element(env, channelOut, 0, value); + napi_set_named_property(env, valueParam, "channelOut", channelOut); + + napi_value channelIn; + napi_create_array_with_length(env, 1, &channelIn); + napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelIn, &value); + napi_set_element(env, channelIn, 0, value); + napi_set_named_property(env, valueParam, "channelIn", channelIn); + napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, asyncContext->deviceDescriptors[i]->channelMasks_, &value); @@ -2187,18 +2301,14 @@ static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, vo } napi_get_undefined(env, &result[PARAM0]); - - if (asyncContext->deferred) { - napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]); + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_get_undefined(env, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, result[PARAM1]); } else { - napi_value callback = nullptr; - napi_get_reference_value(env, asyncContext->callbackRef, &callback); - napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal); - napi_delete_reference(env, asyncContext->callbackRef); + HiLog::Error(LABEL, "ERROR: AudioRoutingManagerAsyncContext* is Null!"); } - napi_delete_async_work(env, asyncContext->work); - - delete asyncContext; } napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) @@ -2208,23 +2318,30 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < PARAM0) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if( !AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -2241,9 +2358,11 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->deviceDescriptors = context->objectInfo->audioMngr_->GetDevices( - static_cast(context->deviceFlag)); - context->status = 0; + if (context->status == SUCCESS) { + context->deviceDescriptors = context->objectInfo->audioMngr_->GetDevices( + static_cast(context->deviceFlag)); + context->status = 0; + } }, GetDevicesAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -2340,11 +2459,13 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -2352,13 +2473,12 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) AudioManagerNapi *managerNapi = nullptr; status = napi_unwrap(env, jsThis, reinterpret_cast(&managerNapi)); - NAPI_ASSERT(env, status == napi_ok && managerNapi != nullptr, "Failed to retrieve audio manager napi instance."); - NAPI_ASSERT(env, managerNapi->audioMngr_ != nullptr, "audio system manager instance is null."); napi_valuetype handler = napi_undefined; if (argCount == minArgCount) { napi_valuetype handler = napi_undefined; if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::On type mismatch for parameter 2"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } } else { @@ -2367,10 +2487,12 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) if (!callbackName.compare(INTERRUPT_CALLBACK_NAME)) { if (paramArg1 != napi_object) { AUDIO_ERR_LOG("AudioManagerNapi::On Type mismatch for parameter 2"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } if (napi_typeof(env, args[PARAM2], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::On type mismatch for parameter 3"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } } @@ -2389,7 +2511,6 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) cb->SaveCallbackReference(callbackName, args[PARAM2]); AudioInterrupt audioInterrupt; status = JsObjToAudioInterrupt(env, args[PARAM1], audioInterrupt); - NAPI_ASSERT(env, status == napi_ok, "Failed to retrieve audioInterrupt value"); int32_t ret = managerNapi->audioMngr_->RequestAudioFocus(audioInterrupt); if (ret) { AUDIO_ERR_LOG("AudioManagerNapi: RequestAudioFocus Failed"); @@ -2432,6 +2553,9 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) std::static_pointer_cast(managerNapi->deviceChangeCallbackNapi_); cb->SaveCallbackReference(callbackName, args[PARAM1]); AUDIO_INFO_LOG("AudioManagerNapi::On SetDeviceChangeCallback is successful"); + } else { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::No such callback supported"); + AudioCommonNapi::throwError(env, ERR_NUMBER101); } return undefinedResult; } @@ -2448,11 +2572,13 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("Off fail to napi_get_cb_info/Requires min 1 parameters"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -2460,25 +2586,24 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) AudioManagerNapi *managerNapi = nullptr; status = napi_unwrap(env, jsThis, reinterpret_cast(&managerNapi)); - NAPI_ASSERT(env, status == napi_ok && managerNapi != nullptr, "Failed to retrieve audio mgr napi instance."); - NAPI_ASSERT(env, managerNapi->audioMngr_ != nullptr, "audio system mgr instance is null."); napi_valuetype handler = napi_undefined; if (!callbackName.compare(INTERRUPT_CALLBACK_NAME) && argCount > ARGS_ONE) { napi_valuetype paramArg1 = napi_undefined; if (napi_typeof(env, args[PARAM1], ¶mArg1) != napi_ok || paramArg1 != napi_object) { AUDIO_ERR_LOG("AudioManagerNapi::Off type mismatch for parameter 2"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } if (argCount == ARGS_THREE) { if (napi_typeof(env, args[PARAM2], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::Off type mismatch for parameter 3"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); return undefinedResult; } } AudioInterrupt audioInterrupt; status = JsObjToAudioInterrupt(env, args[PARAM1], audioInterrupt); - NAPI_ASSERT(env, status == napi_ok, "AudioManagerNapi::Off Failed to retrieve audioInterrupt value"); int32_t ret = managerNapi->audioMngr_->AbandonAudioFocus(audioInterrupt); if (ret) { AUDIO_ERR_LOG("AudioManagerNapi::Off AbandonAudioFocus Failed"); @@ -2504,146 +2629,68 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) managerNapi->deviceChangeCallbackNapi_ = nullptr; } AUDIO_INFO_LOG("AudioManagerNapi::Off UnsetDeviceChangeCallback Success"); + } else { + AudioCommonNapi::throwError(env, ERR_NUMBER101); } return undefinedResult; } + napi_value AudioManagerNapi::GetStreamManager(napi_env env, napi_callback_info info) { - HiLog::Info(LABEL, "%{public}s IN", __func__); napi_status status; - const int32_t refCount = 1; - napi_value result = nullptr; - - GET_PARAMS(env, info, ARGS_ONE); - - unique_ptr asyncContext = make_unique(); - CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioManagerAsyncContext object creation failed"); - - for (size_t i = PARAM0; i < argc; i++) { - napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } - } - - if (asyncContext->callbackRef == nullptr) { - napi_create_promise(env, &asyncContext->deferred, &result); - } else { - napi_get_undefined(env, &result); - } - - napi_value resource = nullptr; - napi_create_string_utf8(env, "GetStreamManager", NAPI_AUTO_LENGTH, &resource); + size_t argCount = 0; - status = napi_create_async_work( - env, nullptr, resource, - [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = SUCCESS; - }, - GetStreamMgrAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); - if (status != napi_ok) { - result = nullptr; - } else { - status = napi_queue_async_work(env, asyncContext->work); - if (status == napi_ok) { - asyncContext.release(); - } else { - result = nullptr; - } + status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr); + if (status != napi_ok || argCount != 0) { + HiLog::Error(LABEL, "Invalid arguments!"); + return nullptr; } - return result; + return AudioStreamMgrNapi::CreateStreamManagerWrapper(env); } -static void GetRoutingManagerAsyncCallbackComplete(napi_env env, napi_status status, void *data) -{ - napi_value valueParam = nullptr; - auto asyncContext = static_cast(data); - - if (asyncContext != nullptr) { - if (!asyncContext->status) { - valueParam = AudioRoutingManagerNapi::CreateRoutingManagerWrapper(env); - } - CommonCallbackRoutine(env, asyncContext, valueParam); - } else { - HiLog::Error(LABEL, "ERROR: GetRoutingManagerAsyncCallbackComplete asyncContext is Null!"); - } -} napi_value AudioManagerNapi::GetRoutingManager(napi_env env, napi_callback_info info) { - HiLog::Info(LABEL, "%{public}s IN", __func__); napi_status status; - const int32_t refCount = 1; - napi_value result = nullptr; - - GET_PARAMS(env, info, ARGS_ONE); - - unique_ptr asyncContext = make_unique(); - CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioManagerAsyncContext object creation failed"); - - for (size_t i = PARAM0; i < argc; i++) { - napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); + size_t argCount = 0; - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } + status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr); + if (status != napi_ok || argCount != 0) { + HiLog::Error(LABEL, "Invalid arguments!"); + return nullptr; } - if (asyncContext->callbackRef == nullptr) { - napi_create_promise(env, &asyncContext->deferred, &result); - } else { - napi_get_undefined(env, &result); - } + return AudioRoutingManagerNapi::CreateRoutingManagerWrapper(env); +} - napi_value resource = nullptr; - napi_create_string_utf8(env, "GetRoutingManager", NAPI_AUTO_LENGTH, &resource); +napi_value AudioManagerNapi::GetVolumeManager(napi_env env, napi_callback_info info) +{ + napi_status status; + size_t argCount = 0; - status = napi_create_async_work( - env, nullptr, resource, - [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = SUCCESS; - }, - GetRoutingManagerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); - if (status != napi_ok) { - result = nullptr; - } else { - status = napi_queue_async_work(env, asyncContext->work); - if (status == napi_ok) { - asyncContext.release(); - } else { - result = nullptr; - } + status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr); + if (status != napi_ok || argCount != 0) { + HiLog::Error(LABEL, "Invalid arguments!"); + return nullptr; } - return result; + return AudioVolumeManagerNapi::CreateVolumeManagerWrapper(env); } -void AudioManagerNapi::GetStreamMgrAsyncCallbackComplete(napi_env env, napi_status status, void *data) +napi_value AudioManagerNapi::GetInterruptManager(napi_env env, napi_callback_info info) { - napi_value valueParam = nullptr; - auto asyncContext = static_cast(data); + napi_status status; + size_t argCount = 0; - if (asyncContext != nullptr) { - if (!asyncContext->status) { - valueParam = AudioStreamMgrNapi::CreateStreamManagerWrapper(env); - } - CommonCallbackRoutine(env, asyncContext, valueParam); - } else { - HiLog::Error(LABEL, "ERROR: GetStreamMgrAsyncCallbackComplete asyncContext is Null!"); + status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr); + if (status != napi_ok || argCount != 0) { + HiLog::Error(LABEL, "Invalid arguments!"); + return nullptr; } + + return AudioInterruptManagerNapi::CreateInterruptManagerWrapper(env); } void AudioManagerNapi::AddPropName(std::string& propName, napi_status& status, napi_env env, napi_value& result) @@ -2683,178 +2730,6 @@ void AudioManagerNapi::AddPropName(std::string& propName, napi_status& status, n } } -static void GetVolumeGroupsAsyncCallbackComplete(napi_env env, napi_status status, void* data) -{ - auto asyncContext = static_cast(data); - napi_value result[ARGS_TWO] = { 0 }; - napi_value valueParam = nullptr; - napi_value retVal; - size_t size = asyncContext->volumeGroupInfos.size(); - HiLog::Info(LABEL, "number of devices = %{public}zu", size); - napi_create_array_with_length(env, size, &result[PARAM1]); - for (size_t i = 0; i < size; i++) { - if (asyncContext->volumeGroupInfos[i] != nullptr) { - (void)napi_create_object(env, &valueParam); - SetValueString(env, "networkId", static_cast( - asyncContext->volumeGroupInfos[i]->networkId_), valueParam); - SetValueInt32(env, "groupId", static_cast( - asyncContext->volumeGroupInfos[i]->volumeGroupId_), valueParam); - SetValueInt32(env, "mappingId", static_cast( - asyncContext->volumeGroupInfos[i]->mappingId_), valueParam); - SetValueString(env, "groupName", static_cast( - asyncContext->volumeGroupInfos[i]->groupName_), valueParam); - SetValueInt32(env, "ConnectType", static_cast( - asyncContext->volumeGroupInfos[i]->connectType_), valueParam); - napi_set_element(env, result[PARAM1], i, valueParam); - } - } - - napi_get_undefined(env, &result[PARAM0]); - - if (asyncContext->deferred) { - napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]); - } else { - napi_value callback = nullptr; - napi_get_reference_value(env, asyncContext->callbackRef, &callback); - napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal); - napi_delete_reference(env, asyncContext->callbackRef); - } - napi_delete_async_work(env, asyncContext->work); - - delete asyncContext; -} - -napi_value AudioManagerNapi::GetVolumeGroups(napi_env env, napi_callback_info info) -{ - napi_status status; - - const int32_t refCount = 1; - napi_value result = nullptr; - - GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - - unique_ptr asyncContext = make_unique(); - - status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); - if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { - napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - if (i == PARAM0 && valueType == napi_string) { - asyncContext->networkId = AudioCommonNapi::GetStringArgument(env, argv[i]); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } - } - - if (asyncContext->callbackRef == nullptr) { - napi_create_promise(env, &asyncContext->deferred, &result); - } else { - napi_get_undefined(env, &result); - } - - napi_value resource = nullptr; - napi_create_string_utf8(env, "getVolumeGroups", NAPI_AUTO_LENGTH, &resource); - - status = napi_create_async_work( - env, nullptr, resource, - [](napi_env env, void* data) { - auto context = static_cast(data); - - context->volumeGroupInfos = context->objectInfo->audioMngr_->GetVolumeGroups(context->networkId); - HiLog::Info(LABEL, "AudioManagerNapi::GetVolumeGroups--napi_create_async_work "); - context->status = 0; - }, - GetVolumeGroupsAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); - if (status != napi_ok) { - result = nullptr; - } else { - status = napi_queue_async_work(env, asyncContext->work); - if (status == napi_ok) { - asyncContext.release(); - } else { - result = nullptr; - } - } - } - - return result; -} - -napi_value AudioManagerNapi::GetGroupManager(napi_env env, napi_callback_info info) -{ - HiLog::Info(LABEL, "%{public}s IN", __func__); - napi_status status; - const int32_t refCount = 1; - napi_value result = nullptr; - - GET_PARAMS(env, info, ARGS_TWO); - - unique_ptr asyncContext = make_unique(); - CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioManagerAsyncContext object creation failed"); - - for (size_t i = PARAM0; i < argc; i++) { - napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - if (i == PARAM0 && valueType == napi_number) { - napi_get_value_int32(env, argv[i], &asyncContext->groupId); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); - } - } - - if (asyncContext->callbackRef == nullptr) { - napi_create_promise(env, &asyncContext->deferred, &result); - } else { - napi_get_undefined(env, &result); - } - - napi_value resource = nullptr; - napi_create_string_utf8(env, "GetGroupManager", NAPI_AUTO_LENGTH, &resource); - - status = napi_create_async_work( - env, nullptr, resource, - [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = SUCCESS; - }, - GetGroupMgrAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); - if (status != napi_ok) { - result = nullptr; - } else { - status = napi_queue_async_work(env, asyncContext->work); - if (status == napi_ok) { - asyncContext.release(); - } else { - result = nullptr; - } - } - - return result; -} - -void AudioManagerNapi::GetGroupMgrAsyncCallbackComplete(napi_env env, napi_status status, void* data) -{ - napi_value valueParam = nullptr; - auto asyncContext = static_cast(data); - - if (asyncContext != nullptr) { - if (!asyncContext->status) { - valueParam = AudioGroupManagerNapi::CreateAudioGroupManagerWrapper(env, asyncContext->groupId); - } - CommonCallbackRoutine(env, asyncContext, valueParam); - } else { - HiLog::Error(LABEL, "ERROR: GetStreamMgrAsyncCallbackComplete asyncContext is Null!"); - } -} - static napi_value Init(napi_env env, napi_value exports) { AudioManagerNapi::Init(env, exports); @@ -2864,7 +2739,9 @@ static napi_value Init(napi_env env, napi_value exports) AudioParametersNapi::Init(env, exports); AudioStreamMgrNapi::Init(env, exports); AudioRoutingManagerNapi::Init(env, exports); - AudioGroupManagerNapi::Init(env, exports); + AudioVolumeGroupManagerNapi::Init(env, exports); + AudioVolumeManagerNapi::Init(env, exports); + AudioInterruptManagerNapi::Init(env, exports); return exports; } diff --git a/frameworks/js/napi/audio_manager/src/audio_routing_manager_callback_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp similarity index 79% rename from frameworks/js/napi/audio_manager/src/audio_routing_manager_callback_napi.cpp rename to frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp index a722832b90..43e3959fa5 100644 --- a/frameworks/js/napi/audio_manager/src/audio_routing_manager_callback_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "audio_routing_manager_callback_napi.h" +#include "audio_micstatechange_callback_napi.h" #include @@ -22,31 +22,31 @@ namespace OHOS { namespace AudioStandard { -AudioRoutingManagerCallbackNapi::AudioRoutingManagerCallbackNapi(napi_env env) +AudioManagerMicStateChangeCallbackNapi::AudioManagerMicStateChangeCallbackNapi(napi_env env) : env_(env) { - AUDIO_DEBUG_LOG("AudioRoutingManagerCallbackNapi: instance create"); + AUDIO_DEBUG_LOG("AudioManagerMicStateChangeCallbackNapi: instance create"); } -AudioRoutingManagerCallbackNapi::~AudioRoutingManagerCallbackNapi() +AudioManagerMicStateChangeCallbackNapi::~AudioManagerMicStateChangeCallbackNapi() { AUDIO_DEBUG_LOG("AudioManagerCallbackNapi: instance destroy"); } -void AudioRoutingManagerCallbackNapi::SaveCallbackReference(const std::string &callbackName, napi_value args) +void AudioManagerMicStateChangeCallbackNapi::SaveCallbackReference(const std::string &callbackName, napi_value args) { std::lock_guard lock(mutex_); napi_ref callback = nullptr; const int32_t refCount = 1; napi_status status = napi_create_reference(env_, args, refCount, &callback); CHECK_AND_RETURN_LOG(status == napi_ok && callback != nullptr, - "AudioRoutingManagerCallbackNapi: creating reference for callback fail"); + "AudioManagerMicStateChangeCallbackNapi: creating reference for callback fail"); std::shared_ptr cb = std::make_shared(env_, callback); if (callbackName == MIC_STATE_CHANGE_CALLBACK_NAME) { micStateChangeCallback_ = cb; } else { - AUDIO_ERR_LOG("AudioRoutingManagerCallbackNapi: Unknown callback type: %{public}s", callbackName.c_str()); + AUDIO_ERR_LOG("AudioManagerMicStateChangeCallbackNapi: Unknown callback type: %{public}s", callbackName.c_str()); } } @@ -64,12 +64,12 @@ static void NativeMicStateChangeToJsObj(const napi_env &env, napi_value &jsObj, SetValueBoolean(env, "mute", micStateChangeEvent.mute, jsObj); } -void AudioRoutingManagerCallbackNapi::OnMicStateUpdated(const MicStateChangeEvent &micStateChangeEvent) +void AudioManagerMicStateChangeCallbackNapi::OnMicStateUpdated(const MicStateChangeEvent &micStateChangeEvent) { std::lock_guard lock(mutex_); CHECK_AND_RETURN_LOG(micStateChangeCallback_ != nullptr, "callback not registered by JS client"); - std::unique_ptr cb = std::make_unique(); + std::unique_ptr cb = std::make_unique(); CHECK_AND_RETURN_LOG(cb != nullptr, "No memory"); cb->callback = micStateChangeCallback_; @@ -78,7 +78,7 @@ void AudioRoutingManagerCallbackNapi::OnMicStateUpdated(const MicStateChangeEven return OnJsCallbackMicStateChange(cb); } -void AudioRoutingManagerCallbackNapi::OnJsCallbackMicStateChange(std::unique_ptr &jsCb) +void AudioManagerMicStateChangeCallbackNapi::OnJsCallbackMicStateChange(std::unique_ptr &jsCb) { uv_loop_s *loop = nullptr; napi_get_uv_event_loop(env_, &loop); @@ -102,7 +102,7 @@ void AudioRoutingManagerCallbackNapi::OnJsCallbackMicStateChange(std::unique_ptr int ret = uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { // Js Thread - AudioRoutingManagerJsCallback *event = reinterpret_cast(work->data); + AudioManagerMicStateChangeJsCallback *event = reinterpret_cast(work->data); std::string request = event->callbackName; napi_env env = event->callback->env_; napi_ref callback = event->callback->cb_; 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 780f136d81..02b2fdf45e 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 @@ -16,7 +16,7 @@ #include "audio_routing_manager_napi.h" #include "audio_common_napi.h" -#include "audio_routing_manager_callback_napi.h" +#include "audio_micstatechange_callback_napi.h" #include "audio_errors.h" #include "audio_log.h" #include "hilog/log.h" @@ -49,8 +49,11 @@ struct AudioRoutingManagerAsyncContext { napi_deferred deferred; napi_ref callbackRef = nullptr; int32_t deviceFlag; + int32_t status = SUCCESS; + int32_t deviceType; + bool isActive; + bool isTrue; bool bArgTransFlag = true; - int32_t status; AudioRoutingManagerNapi *objectInfo; sptr audioRendererFilter; sptr audioCapturerFilter; @@ -93,6 +96,9 @@ napi_value AudioRoutingManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("selectOutputDeviceByFilter", SelectOutputDeviceByFilter), DECLARE_NAPI_FUNCTION("selectInputDevice", SelectInputDevice), DECLARE_NAPI_FUNCTION("selectInputDeviceByFilter", SelectInputDeviceByFilter), + DECLARE_NAPI_FUNCTION("setCommunicationDevice", SetCommunicationDevice), + DECLARE_NAPI_FUNCTION("isCommunicationDeviceActive", IsCommunicationDeviceActive), + }; status = napi_define_class(env, AUDIO_ROUTING_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -175,8 +181,13 @@ static void CommonCallbackRoutine(napi_env env, AudioRoutingManagerAsyncContext result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -198,6 +209,36 @@ static void CommonCallbackRoutine(napi_env env, AudioRoutingManagerAsyncContext asyncContext = nullptr; } +static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + napi_value valueParam = nullptr; + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_get_undefined(env, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!"); + } +} + +static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + napi_value valueParam = nullptr; + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_get_boolean(env, asyncContext->isTrue, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!"); + } +} + static void ParseAudioRendererInfo(napi_env env, napi_value root, AudioRendererInfo *rendererInfo) { napi_value tempValue = nullptr; @@ -384,6 +425,18 @@ static void SetDevicesInfo(AudioRoutingManagerAsyncContext* asyncContext, napi_e napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); + napi_value channelOut; + napi_create_array_with_length(env, 1, &channelOut); + napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelOut, &value); + napi_set_element(env, channelOut, 0, value); + napi_set_named_property(env, valueParam, "channelOut", channelOut); + + napi_value channelIn; + napi_create_array_with_length(env, 1, &channelIn); + napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelIn, &value); + napi_set_element(env, channelIn, 0, value); + napi_set_named_property(env, valueParam, "channelIn", channelIn); + napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, asyncContext->deviceDescriptors[i]->channelMasks_, &value); @@ -399,22 +452,17 @@ static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, vo auto asyncContext = static_cast(data); napi_value result[ARGS_TWO] = {0}; napi_value valueParam = nullptr; - napi_value retVal; SetDevicesInfo(asyncContext, env, result, valueParam); napi_get_undefined(env, &result[PARAM0]); - - if (asyncContext->deferred) { - napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]); + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_get_undefined(env, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, result[PARAM1]); } else { - napi_value callback = nullptr; - napi_get_reference_value(env, asyncContext->callbackRef, &callback); - napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal); - napi_delete_reference(env, asyncContext->callbackRef); + HiLog::Error(LABEL, "ERROR: AudioRoutingManagerAsyncContext* is Null!"); } - napi_delete_async_work(env, asyncContext->work); - - delete asyncContext; } napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info info) @@ -428,11 +476,11 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info void* data; napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + CheckParams(argc, env, argv, asyncContext, refCount, result); napi_value resource = nullptr; @@ -441,9 +489,11 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->deviceDescriptors = context->objectInfo->audioMngr_->GetDevices( - static_cast(context->deviceFlag)); - context->status = 0; + if(context->status == 0){ + context->deviceDescriptors = context->objectInfo->audioMngr_->GetDevices( + static_cast(context->deviceFlag)); + context->status = 0; + } }, GetDevicesAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { result = nullptr; @@ -463,6 +513,9 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* argv, std::unique_ptr& asyncContext, const int32_t refCount, napi_value& result) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -470,12 +523,17 @@ void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); HiLog::Info(LABEL, " GetDevices deviceFlag = %{public}d", asyncContext->deviceFlag); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - HiLog::Error(LABEL, "ERROR: type mismatch"); - return; + asyncContext->status = ERR_NUMBER101; + HiLog::Error(LABEL, "ERROR: type mismatch"); } } @@ -496,12 +554,14 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba napi_value thisVar = nullptr; void *data = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -509,16 +569,15 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba if (i == PARAM0 && valueType == napi_object) { ParseAudioDeviceDescriptorVector(env, argv[i], asyncContext->deviceDescriptors, asyncContext->bArgTransFlag); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } - if (!asyncContext->bArgTransFlag) { - break; - } } if (asyncContext->callbackRef == nullptr) { @@ -537,7 +596,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba if (context->bArgTransFlag) { context->status = context->objectInfo->audioMngr_->SelectOutputDevice(context->deviceDescriptors); } else { - context->status = ERR_INVALID_PARAM; + context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } }, SelectOutputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -565,12 +624,14 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap napi_value thisVar = nullptr; void *data = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -580,16 +641,15 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap } else if (i == PARAM1 && valueType == napi_object) { ParseAudioDeviceDescriptorVector(env, argv[i], asyncContext->deviceDescriptors, asyncContext->bArgTransFlag); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } - if (!asyncContext->bArgTransFlag) { - break; - } } if (asyncContext->callbackRef == nullptr) { @@ -609,7 +669,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap context->status = context->objectInfo->audioMngr_->SelectOutputDevice( context->audioRendererFilter, context->deviceDescriptors); } else { - context->status = ERR_INVALID_PARAM; + context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } }, SelectOutputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -665,23 +725,27 @@ napi_value AudioRoutingManagerNapi::SelectInputDevice(napi_env env, napi_callbac napi_value thisVar = nullptr; void *data = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameters minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_object) { ParseAudioDeviceDescriptorVector(env, argv[i], asyncContext->deviceDescriptors, asyncContext->bArgTransFlag); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1 ) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } if (!asyncContext->bArgTransFlag) { @@ -741,6 +805,9 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -749,11 +816,13 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi } else if (i == PARAM1 && valueType == napi_object) { ParseAudioDeviceDescriptorVector(env, argv[i], asyncContext->deviceDescriptors, asyncContext->bArgTransFlag); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } if (!asyncContext->bArgTransFlag) { @@ -778,7 +847,8 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi context->status = context->objectInfo->audioMngr_->SelectInputDevice( context->audioCapturerFilter, context->deviceDescriptors); } else { - context->status = ERR_INVALID_PARAM; + context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } }, SelectInputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -823,31 +893,6 @@ void AudioRoutingManagerNapi::RegisterDeviceChangeCallback(napi_env env, napi_va AUDIO_INFO_LOG("AudioRoutingManager::On SetDeviceChangeCallback is successful"); } -void AudioRoutingManagerNapi::RegisterMicStateChangeCallback(napi_env env, napi_value* args, - const std::string& cbName, AudioRoutingManagerNapi* routingMgrNapi) -{ - if (!routingMgrNapi->micStateChangeCallbackNapi_) { - routingMgrNapi->micStateChangeCallbackNapi_= std::make_shared(env); - if (!routingMgrNapi->micStateChangeCallbackNapi_) { - AUDIO_ERR_LOG("AudioStreamMgrNapi: Memory Allocation Failed !!"); - return; - } - - int32_t ret = routingMgrNapi->audioRoutingMngr_->SetMicStateChangeCallback( - routingMgrNapi->micStateChangeCallbackNapi_); - if (ret) { - AUDIO_ERR_LOG("AudioRoutingMgrNapi: Registering Microphone Change Callback Failed"); - return; - } - } - - std::shared_ptr cb = - std::static_pointer_cast(routingMgrNapi->micStateChangeCallbackNapi_); - cb->SaveCallbackReference(cbName, args[PARAM1]); - - AUDIO_INFO_LOG("AudioRoutingManager::On SetMicStateChangeCallback is successful"); -} - void AudioRoutingManagerNapi::RegisterCallback(napi_env env, napi_value jsThis, napi_value* args, const std::string& cbName, int32_t flag) { @@ -855,20 +900,16 @@ void AudioRoutingManagerNapi::RegisterCallback(napi_env env, napi_value jsThis, napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&routingMgrNapi)); if ((status != napi_ok) || (routingMgrNapi == nullptr) || (routingMgrNapi->audioMngr_ == nullptr) || (routingMgrNapi->audioRoutingMngr_ == nullptr)) { - AUDIO_ERR_LOG("AudioStreamMgrNapi::Failed to retrieve stream mgr napi instance."); + AUDIO_ERR_LOG("AudioRoutingMgrNapi::Failed to retrieve stream mgr napi instance."); + return; } if (!cbName.compare(DEVICE_CHANGE_CALLBACK_NAME)) { RegisterDeviceChangeCallback(env, args, cbName, flag, routingMgrNapi); } else { - AUDIO_ERR_LOG("AudioStreamMgrNapi::No such callback supported"); - } - - if (!cbName.compare(MIC_STATE_CHANGE_CALLBACK_NAME)) { - RegisterMicStateChangeCallback(env, args, cbName, routingMgrNapi); - } else { - AUDIO_ERR_LOG("AudioStreamMgrNapi::No such micStateChangeCallback supported"); + AUDIO_ERR_LOG("AudioRoutingMgrNapi::No such supported"); + AudioCommonNapi::throwError(env, ERR_NUMBER101); } } @@ -887,11 +928,11 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr); bool isArgcCountRight = argc == requireArgc || argc == maxArgc; - NAPI_ASSERT(env, status == napi_ok && isArgcCountRight, "AudioStreamMgrNapi: On: requires 2 or 3 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok && isArgcCountRight, ERR_NUMBER_401); napi_valuetype eventType = napi_undefined; napi_typeof(env, args[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioStreamMgrNapi:On: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); AUDIO_INFO_LOG("AaudioRoutingManagerNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -900,7 +941,7 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) if (argc == requireArgc) { napi_valuetype handler = napi_undefined; napi_typeof(env, args[1], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); deviceFlag = 3; // 3 for ALL_DEVICES_FLAG } if (argc == maxArgc) { @@ -909,7 +950,7 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; napi_typeof(env, args[PARAM2], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); } RegisterCallback(env, jsThis, args, callbackName, deviceFlag); @@ -958,5 +999,149 @@ napi_value AudioRoutingManagerNapi::Off(napi_env env, napi_callback_info info) } return undefinedResult; } + +napi_value AudioRoutingManagerNapi::SetCommunicationDevice(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_THREE); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO) { + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + + if (i == PARAM0 && valueType == napi_number) { + napi_get_value_int32(env, argv[i], &asyncContext->deviceType); + if(!AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(asyncContext->deviceType)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1 && valueType == napi_boolean) { + napi_get_value_bool(env, argv[i], &asyncContext->isActive); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "SetCommunicationDeviceActive", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == 0) { + context->status = context->objectInfo->audioMngr_->SetDeviceActive( + static_cast(context->deviceType), context->isActive); + } + + }, + SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + + if (i == PARAM0 && valueType == napi_number) { + napi_get_value_int32(env, argv[i], &asyncContext->deviceType); + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "IsCommunicationDeviceActive", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->isActive = + context->objectInfo->audioMngr_->IsDeviceActive(static_cast(context->deviceType)); + context->isTrue = context->isActive; + context->status = 0; + } + + }, + IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + + } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_stream_manager/src/audio_stream_mgr_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp similarity index 77% rename from frameworks/js/napi/audio_stream_manager/src/audio_stream_mgr_napi.cpp rename to frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp index 81518ab859..812466cfb7 100644 --- a/frameworks/js/napi/audio_stream_manager/src/audio_stream_mgr_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_stream_mgr_napi.cpp @@ -58,9 +58,11 @@ struct AudioStreamMgrAsyncContext { napi_async_work work; napi_deferred deferred; napi_ref callbackRef = nullptr; - int32_t status; + int32_t status = SUCCESS; + int32_t volType; bool isTrue; bool isLowLatencySupported; + bool isActive; AudioStreamInfo audioStreamInfo; AudioStreamMgrNapi *objectInfo; vector> audioRendererChangeInfos; @@ -86,6 +88,35 @@ void AudioStreamMgrNapi::Destructor(napi_env env, void *nativeObject, void *fina } } + +static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) +{ + AudioVolumeType result = STREAM_MUSIC; + + switch (volumeType) { + case AudioManagerNapi::RINGTONE: + result = STREAM_RING; + break; + case AudioManagerNapi::MEDIA: + result = STREAM_MUSIC; + break; + case AudioManagerNapi::VOICE_CALL: + result = STREAM_VOICE_CALL; + break; + case AudioManagerNapi::VOICE_ASSISTANT: + result = STREAM_VOICE_ASSISTANT; + break; + case AudioManagerNapi::ALL: + result = STREAM_ALL; + break; + default: + result = STREAM_MUSIC; + HiLog::Error(LABEL, "Unknown volume type, Set it to default MEDIA!"); + break; + } + + return result; +} static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value &result) { napi_value value = nullptr; @@ -128,6 +159,18 @@ static void SetDeviceDescriptors(const napi_env& env, napi_value &jsChangeInfoOb napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); + napi_value channelOut; + napi_create_array_with_length(env, 1, &channelOut); + napi_create_int32(env, deviceInfo.audioStreamInfo.channelOut, &value); + napi_set_element(env, channelOut, 0, value); + napi_set_named_property(env, valueParam, "channelOut", channelOut); + + napi_value channelIn; + napi_create_array_with_length(env, 1, &channelIn); + napi_create_int32(env, deviceInfo.audioStreamInfo.channelIn, &value); + napi_set_element(env, channelIn, 0, value); + napi_set_named_property(env, valueParam, "channelIn", channelIn); + napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, deviceInfo.channelMasks, &value); @@ -152,7 +195,7 @@ static void GetCurrentRendererChangeInfosCallbackComplete(napi_env env, napi_sta napi_create_array_with_length(env, size, &result[PARAM1]); for (const unique_ptr &changeInfo: asyncContext->audioRendererChangeInfos) { if (!changeInfo) { - AUDIO_ERR_LOG("AudioManagerNapi:AudioRendererChangeInfo Null, something wrong!!"); + AUDIO_ERR_LOG("AudioStreamMgrNapi:AudioRendererChangeInfo Null, something wrong!!"); continue; } @@ -201,7 +244,7 @@ static void GetCurrentCapturerChangeInfosCallbackComplete(napi_env env, napi_sta napi_create_array_with_length(env, size, &result[PARAM1]); for (const unique_ptr &changeInfo: asyncContext->audioCapturerChangeInfos) { if (!changeInfo) { - AUDIO_ERR_LOG("AudioManagerNapi:AudioCapturerChangeInfo Null, something wrong!!"); + AUDIO_ERR_LOG("AudioStreamMgrNapi:AudioCapturerChangeInfo Null, something wrong!!"); continue; } @@ -249,7 +292,9 @@ napi_value AudioStreamMgrNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("getCurrentAudioRendererInfoArray", GetCurrentAudioRendererInfos), DECLARE_NAPI_FUNCTION("getCurrentAudioCapturerInfoArray", GetCurrentAudioCapturerInfos), - DECLARE_NAPI_FUNCTION("isAudioRendererLowLatencySupported", IsAudioRendererLowLatencySupported) + DECLARE_NAPI_FUNCTION("isAudioRendererLowLatencySupported", IsAudioRendererLowLatencySupported), + DECLARE_NAPI_FUNCTION("isActive", IsStreamActive), + }; status = napi_define_class(env, AUDIO_STREAM_MGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -340,7 +385,7 @@ void AudioStreamMgrNapi::RegisterRendererStateChangeCallback(napi_env env, napi_ std::static_pointer_cast(streamMgrNapi->rendererStateChangeCallbackNapi_); cb->SaveCallbackReference(args[PARAM1]); - AUDIO_INFO_LOG("AudioManagerNapi::OnRendererStateChangeCallback is successful"); + AUDIO_INFO_LOG("AudioStreamMgrNapi::OnRendererStateChangeCallback is successful"); } void AudioStreamMgrNapi::RegisterCapturerStateChangeCallback(napi_env env, napi_value* args, @@ -366,7 +411,7 @@ void AudioStreamMgrNapi::RegisterCapturerStateChangeCallback(napi_env env, napi_ std::static_pointer_cast(streamMgrNapi->capturerStateChangeCallbackNapi_); cb->SaveCallbackReference(args[PARAM1]); - AUDIO_INFO_LOG("AudioManagerNapi::OnCapturerStateChangeCallback is successful"); + AUDIO_INFO_LOG("AudioStreamMgrNapi::OnCapturerStateChangeCallback is successful"); } void AudioStreamMgrNapi::RegisterCallback(napi_env env, napi_value jsThis, @@ -385,6 +430,7 @@ void AudioStreamMgrNapi::RegisterCallback(napi_env env, napi_value jsThis, RegisterCapturerStateChangeCallback(env, args, cbName, streamMgrNapi); } else { AUDIO_ERR_LOG("AudioStreamMgrNapi::No such callback supported"); + AudioCommonNapi::throwError(env, ERR_NUMBER101); } } @@ -399,11 +445,11 @@ napi_value AudioStreamMgrNapi::On(napi_env env, napi_callback_info info) napi_value args[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr); - NAPI_ASSERT(env, status == napi_ok && argc == requireArgc, "AudioStreamMgrNapi: On: requires 2 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok && argc == requireArgc, ERR_NUMBER_401); napi_valuetype eventType = napi_undefined; napi_typeof(env, args[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioStreamMgrNapi:On: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); AUDIO_DEBUG_LOG("AudioStreamMgrNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -411,7 +457,7 @@ napi_value AudioStreamMgrNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; napi_typeof(env, args[1], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); RegisterCallback(env, jsThis, args, callbackName); @@ -491,7 +537,7 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c unique_ptr asyncContext = make_unique(); if (!asyncContext) { - AUDIO_ERR_LOG("AudioManagerNapi:Audio manager async context failed"); + AUDIO_ERR_LOG("AudioStreamMgrNapi:Audio manager async context failed"); return result; } @@ -502,11 +548,13 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if (i == PARAM0) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -523,8 +571,12 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = context->objectInfo->audioStreamMngr_-> - GetCurrentRendererChangeInfos(context->audioRendererChangeInfos); + if (context->status == SUCCESS) { + context->status = context->objectInfo->audioStreamMngr_-> + GetCurrentRendererChangeInfos(context->audioRendererChangeInfos); + context->status = context->status == SUCCESS ? SUCCESS : ERR_NUMBER301; + } + }, GetCurrentRendererChangeInfosCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -563,11 +615,13 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_c napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if (i == PARAM0) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -584,8 +638,11 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_c env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->objectInfo->audioStreamMngr_->GetCurrentCapturerChangeInfos(context->audioCapturerChangeInfos); - context->status = 0; + if (context->status == SUCCESS) { + context->objectInfo->audioStreamMngr_->GetCurrentCapturerChangeInfos(context->audioCapturerChangeInfos); + context->status = SUCCESS; + } + }, GetCurrentCapturerChangeInfosCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -622,13 +679,15 @@ napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, if (i == PARAM0 && valueType == napi_object) { if (!ParseAudioStreamInfo(env, argv[i], asyncContext->audioStreamInfo)) { HiLog::Error(LABEL, "Parsing of audiostream failed"); - return result; + asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } if (asyncContext->callbackRef == nullptr) { @@ -643,10 +702,13 @@ napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->isLowLatencySupported = - context->objectInfo->audioStreamMngr_->IsAudioRendererLowLatencySupported(context->audioStreamInfo); - context->isTrue = context->isLowLatencySupported; - context->status = SUCCESS; + if (context->status == SUCCESS) { + context->isLowLatencySupported = + context->objectInfo->audioStreamMngr_->IsAudioRendererLowLatencySupported(context->audioStreamInfo); + context->isTrue = context->isLowLatencySupported; + context->status = SUCCESS; + } + }, IsLowLatencySupportedCallback, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -678,6 +740,16 @@ bool AudioStreamMgrNapi::ParseAudioStreamInfo(napi_env env, napi_value root, Aud audioStreamInfo.channels = static_cast(intValue); } + if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + audioStreamInfo.channelOut = static_cast(intValue); + } + + if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + audioStreamInfo.channelIn = static_cast(intValue); + } + if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); audioStreamInfo.format = static_cast(intValue); @@ -702,8 +774,13 @@ static void CommonCallbackRoutine(napi_env env, AudioStreamMgrAsyncContext* &asy result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -736,8 +813,94 @@ void AudioStreamMgrNapi::IsLowLatencySupportedCallback(napi_env env, napi_status } CommonCallbackRoutine(env, asyncContext, valueParam); } else { - HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!"); + HiLog::Error(LABEL, "ERROR: AudioStreamMgrAsyncContext* is Null!"); } } + + +static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + napi_value valueParam = nullptr; + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_get_boolean(env, asyncContext->isTrue, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR: AudioStreamMgrAsyncContext* is Null!"); + } +} + +napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + + if (i == PARAM0 && valueType == napi_number) { + napi_get_value_int32(env, argv[i], &asyncContext->volType); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1){ + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "IsStreamActive", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->isActive = + context->objectInfo->audioMngr_->IsStreamActive(GetNativeAudioVolumeType(context->volType)); + context->isTrue = context->isActive; + context->status = SUCCESS; + } + }, + IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/src/audio_group_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp similarity index 39% rename from frameworks/js/napi/audio_manager/src/audio_group_manager_napi.cpp rename to frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp index 7121ba4a85..f5e25c3918 100755 --- a/frameworks/js/napi/audio_manager/src/audio_group_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_volume_group_manager_napi.cpp @@ -12,10 +12,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "audio_group_manager_napi.h" +#include "audio_volume_group_manager_napi.h" #include "audio_common_napi.h" #include "audio_errors.h" - #include "hilog/log.h" #include "audio_log.h" @@ -34,7 +33,7 @@ static __thread napi_ref g_groupmanagerConstructor = nullptr; void *data; \ napi_get_cb_info(env, info, &argc, argv, &thisVar, &data) -struct AudioGroupManagerAsyncContext { +struct AudioVolumeGroupManagerAsyncContext { napi_env env; napi_async_work work; napi_deferred deferred; @@ -46,17 +45,16 @@ struct AudioGroupManagerAsyncContext { int32_t scene; int32_t deviceFlag; int32_t intValue; - int32_t status; + int32_t status = SUCCESS; int32_t groupId; bool isMute; bool isActive; bool isTrue; - string key; - string valueStr; + std::string key; + std::string valueStr; int32_t networkId; - AudioGroupManagerNapi *objectInfo; + AudioVolumeGroupManagerNapi *objectInfo; }; - namespace { const int ARGS_ONE = 1; const int ARGS_TWO = 2; @@ -64,7 +62,8 @@ namespace { const int PARAM0 = 0; const int PARAM1 = 1; const int PARAM2 = 2; - constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioGroupManagerNapi"}; + constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioVolumeGroupManagerNapi"}; + const std::string RINGERMODE_CALLBACK_NAME = "ringerModeChange"; } static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) @@ -72,16 +71,16 @@ static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) AudioVolumeType result = STREAM_MUSIC; switch (volumeType) { - case AudioManagerNapi::RINGTONE: + case AudioCommonNapi::RINGTONE: result = STREAM_RING; break; - case AudioManagerNapi::MEDIA: + case AudioCommonNapi::MEDIA: result = STREAM_MUSIC; break; - case AudioManagerNapi::VOICE_CALL: + case AudioCommonNapi::VOICE_CALL: result = STREAM_VOICE_CALL; break; - case AudioManagerNapi::VOICE_ASSISTANT: + case AudioCommonNapi::VOICE_ASSISTANT: result = STREAM_VOICE_ASSISTANT; break; @@ -93,7 +92,52 @@ static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) return result; } -static void CommonCallbackRoutine(napi_env env, AudioGroupManagerAsyncContext* &asyncContext, +static AudioRingerMode GetNativeAudioRingerMode(int32_t ringMode) +{ + AudioRingerMode result = RINGER_MODE_NORMAL; + + switch (ringMode) { + case AudioVolumeGroupManagerNapi::RINGER_MODE_SILENT: + result = RINGER_MODE_SILENT; + break; + case AudioVolumeGroupManagerNapi::RINGER_MODE_VIBRATE: + result = RINGER_MODE_VIBRATE; + break; + case AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL: + result = RINGER_MODE_NORMAL; + break; + default: + result = RINGER_MODE_NORMAL; + HiLog::Error(LABEL, "Unknown ringer mode requested by JS, Set it to default RINGER_MODE_NORMAL!"); + break; + } + + return result; +} + +static AudioVolumeGroupManagerNapi::AudioRingMode GetJsAudioRingMode(int32_t ringerMode) +{ + AudioVolumeGroupManagerNapi::AudioRingMode result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL; + + switch (ringerMode) { + case RINGER_MODE_SILENT: + result = AudioVolumeGroupManagerNapi::RINGER_MODE_SILENT; + break; + case RINGER_MODE_VIBRATE: + result = AudioVolumeGroupManagerNapi::RINGER_MODE_VIBRATE; + break; + case RINGER_MODE_NORMAL: + result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL; + break; + default: + result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL; + HiLog::Error(LABEL, "Unknown ringer mode returned from native, Set it to default RINGER_MODE_NORMAL!"); + break; + } + + return result; +} +static void CommonCallbackRoutine(napi_env env, AudioVolumeGroupManagerAsyncContext* &asyncContext, const napi_value &valueParam) { napi_value result[ARGS_TWO] = {0}; @@ -104,8 +148,13 @@ static void CommonCallbackRoutine(napi_env env, AudioGroupManagerAsyncContext* & result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -129,7 +178,7 @@ static void CommonCallbackRoutine(napi_env env, AudioGroupManagerAsyncContext* & static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data) { - auto asyncContext = static_cast(data); + auto asyncContext = static_cast(data); napi_value valueParam = nullptr; if (asyncContext != nullptr) { @@ -138,14 +187,13 @@ static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, v } CommonCallbackRoutine(env, asyncContext, valueParam); } else { - HiLog::Error(LABEL, "ERROR: AudioGroupManagerAsyncContext* is Null!"); + HiLog::Error(LABEL, "ERROR: AudioVolumeGroupManagerAsyncContext* is Null!"); } } - static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, void *data) { - auto asyncContext = static_cast(data); + auto asyncContext = static_cast(data); napi_value valueParam = nullptr; if (asyncContext != nullptr) { @@ -160,7 +208,7 @@ static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, v static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data) { - auto asyncContext = static_cast(data); + auto asyncContext = static_cast(data); napi_value valueParam = nullptr; if (asyncContext != nullptr) { @@ -174,30 +222,31 @@ static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void * } // Constructor callback -napi_value AudioGroupManagerNapi::Construct(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::Construct(napi_env env, napi_callback_info info) { napi_status status; napi_value jsThis; napi_value undefinedResult = nullptr; napi_get_undefined(env, &undefinedResult); size_t argCount = 1; - int32_t valueParam = 0; + int32_t groupId = 0; napi_value args[1] = { nullptr}; status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); - napi_get_value_int32(env, args[0], &valueParam); - HiLog::Info(LABEL, "Construct() %{public}d", valueParam); + napi_get_value_int32(env, args[0], &groupId); + HiLog::Info(LABEL, "Construct() %{public}d", groupId); if (status == napi_ok) { - unique_ptr groupmanagerNapi = make_unique(); + unique_ptr groupmanagerNapi = make_unique(); if (groupmanagerNapi != nullptr) { - groupmanagerNapi->audioGroupMngr_ = AudioSystemManager::GetInstance()->GetGroupManager(valueParam); + groupmanagerNapi->audioGroupMngr_ = AudioSystemManager::GetInstance()->GetGroupManager(groupId); if (groupmanagerNapi->audioGroupMngr_ == nullptr) { - HiLog::Error(LABEL, "Failed in AudioGroupManagerNapi::Construct()!"); + HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::Construct()!"); + return undefinedResult; } status = napi_wrap(env, jsThis, static_cast(groupmanagerNapi.get()), - AudioGroupManagerNapi::Destructor, nullptr, &(groupmanagerNapi->wrapper_)); + AudioVolumeGroupManagerNapi::Destructor, nullptr, &(groupmanagerNapi->wrapper_)); if (status == napi_ok) { groupmanagerNapi.release(); return jsThis; @@ -205,83 +254,75 @@ napi_value AudioGroupManagerNapi::Construct(napi_env env, napi_callback_info inf } } - HiLog::Error(LABEL, "Failed in AudioGroupManagerNapi::Construct()!"); + HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::Construct()!"); + return undefinedResult; } -void AudioGroupManagerNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint) +void AudioVolumeGroupManagerNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint) { if (nativeObject != nullptr) { - auto obj = static_cast(nativeObject); + auto obj = static_cast(nativeObject); delete obj; obj = nullptr; - AUDIO_DEBUG_LOG("AudioGroupManagerNapi::Destructor delete AudioGroupManagerNapi obj done"); + AUDIO_DEBUG_LOG("AudioVolumeGroupManagerNapi::Destructor delete AudioVolumeGroupManagerNapi obj done"); } } -napi_value AudioGroupManagerNapi::CreateAudioGroupManagerWrapper(napi_env env, int32_t groupId) +napi_value AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(napi_env env, int32_t groupId) { napi_status status; napi_value result = nullptr; napi_value constructor; - napi_value resul; - napi_create_int64(env, groupId, &resul); - napi_value args[1] = {resul}; - HiLog::Info(LABEL, "AudioGroupManagerNapi::CreateAudioGroupManagerWrapper() groupId %{public}d", groupId); + napi_value groupId_; + napi_create_int64(env, groupId, &groupId_); + napi_value args[PARAM1] = {groupId_}; status = napi_get_reference_value(env, g_groupmanagerConstructor, &constructor); + if (status == napi_ok) { - status = napi_new_instance(env, constructor, 1, args, &result); + status = napi_new_instance(env, constructor,1 , args, &result); if (status == napi_ok) { return result; } } - HiLog::Error(LABEL, "Failed in AudioGroupManagerNapi::CreateaudioMngrWrapper!"); + HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::CreateaudioMngrWrapper!"); napi_get_undefined(env, &result); return result; } -void GetGroupManagerAsyncCallbackComplete(napi_env env, napi_status status, void *data) -{ - napi_value valueParam = nullptr; - auto asyncContext = static_cast(data); - - if (asyncContext != nullptr) { - if (!asyncContext->status) { - unique_ptr capturerOptions = make_unique(); - valueParam = AudioGroupManagerNapi::CreateAudioGroupManagerWrapper(env, asyncContext->groupId); - } - CommonCallbackRoutine(env, asyncContext, valueParam); - } else { - HiLog::Error(LABEL, "ERROR: GetGroupManagerAsyncCallbackComplete is Null!"); - } -} - -napi_value AudioGroupManagerNapi::GetVolume(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -297,11 +338,13 @@ napi_value AudioGroupManagerNapi::GetVolume(napi_env env, napi_callback_info inf status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->volLevel = context->objectInfo->audioGroupMngr_->GetVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; + auto context = static_cast(data); + if(context->status == 0){ + context->volLevel = context->objectInfo->audioGroupMngr_->GetVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { result = nullptr; @@ -318,32 +361,41 @@ napi_value AudioGroupManagerNapi::GetVolume(napi_env env, napi_callback_info inf return result; } -napi_value AudioGroupManagerNapi::SetVolume(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); - - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_TWO){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } + } else if (i == PARAM2) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -359,9 +411,11 @@ napi_value AudioGroupManagerNapi::SetVolume(napi_env env, napi_callback_info inf status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = context->objectInfo->audioGroupMngr_->SetVolume(GetNativeAudioVolumeType( - context->volType), context->volLevel); + auto context = static_cast(data); + if(context->status == 0){ + context->status = context->objectInfo->audioGroupMngr_->SetVolume(GetNativeAudioVolumeType( + context->volType), context->volLevel); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { result = nullptr; @@ -378,31 +432,36 @@ napi_value AudioGroupManagerNapi::SetVolume(napi_env env, napi_callback_info inf return result; } -napi_value AudioGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - HiLog::Info(LABEL, " GetMaxVolume volType = %{public}d", asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break;; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -418,11 +477,13 @@ napi_value AudioGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback_info status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->volLevel = context->objectInfo->audioGroupMngr_->GetMaxVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; + auto context = static_cast(data); + if(context->status == 0){ + context->volLevel = context->objectInfo->audioGroupMngr_->GetMaxVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -440,28 +501,33 @@ napi_value AudioGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback_info return result; } -napi_value AudioGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - HiLog::Info(LABEL, " GetMinVolume volType = %{public}d", asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { NAPI_ASSERT(env, false, "type mismatch"); @@ -480,11 +546,13 @@ napi_value AudioGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->volLevel = context->objectInfo->audioGroupMngr_->GetMinVolume( - GetNativeAudioVolumeType(context->volType)); - context->intValue = context->volLevel; - context->status = 0; + auto context = static_cast(data); + if(context->status == 0){ + context->volLevel = context->objectInfo->audioGroupMngr_->GetMinVolume( + GetNativeAudioVolumeType(context->volType)); + context->intValue = context->volLevel; + context->status = 0; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -502,33 +570,38 @@ napi_value AudioGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info return result; } -napi_value AudioGroupManagerNapi::SetMute(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); - - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - HiLog::Info(LABEL, " SetMute volType = %{public}d", asyncContext->volType); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -544,9 +617,11 @@ napi_value AudioGroupManagerNapi::SetMute(napi_env env, napi_callback_info info) status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = context->objectInfo->audioGroupMngr_->SetMute(GetNativeAudioVolumeType( - context->volType), context->isMute); + auto context = static_cast(data); + if(context->status == 0){ + context->status = context->objectInfo->audioGroupMngr_->SetMute(GetNativeAudioVolumeType( + context->volType), context->isMute); + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -564,31 +639,37 @@ napi_value AudioGroupManagerNapi::SetMute(napi_env env, napi_callback_info info) return result; } -napi_value AudioGroupManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) +napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - unique_ptr asyncContext = make_unique(); + unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - HiLog::Info(LABEL, " IsStreamMute volType = %{public}d", asyncContext->volType); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function){ + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -604,11 +685,13 @@ napi_value AudioGroupManagerNapi::IsStreamMute(napi_env env, napi_callback_info status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->isMute = - context->objectInfo->audioGroupMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); - context->isTrue = context->isMute; - context->status = 0; + auto context = static_cast(data); + if(context->status == 0){ + context->isMute = + context->objectInfo->audioGroupMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); + context->isTrue = context->isMute; + context->status = 0; + } }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -626,7 +709,330 @@ napi_value AudioGroupManagerNapi::IsStreamMute(napi_env env, napi_callback_info return result; } -napi_value AudioGroupManagerNapi::Init(napi_env env, napi_value exports) +napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + + if (i == PARAM0 && valueType == napi_number) { + napi_get_value_int32(env, argv[i], &asyncContext->ringMode); + if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)){ + asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + } + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "SetRingerMode", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->status = + context->objectInfo->audioGroupMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode)); + } + + }, + SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioVolumeGroupManagerNapi::GetRingerMode(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc > PARAM0) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "GetRingerMode", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->ringMode = GetJsAudioRingMode(context->objectInfo->audioGroupMngr_->GetRingerMode()); + context->intValue = context->ringMode; + context->status = 0; + } + + }, + GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + + +napi_value AudioVolumeGroupManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + + if (i == PARAM0 && valueType == napi_boolean) { + napi_get_value_bool(env, argv[i], &asyncContext->isMute); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "SetMicrophoneMute", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->status = context->objectInfo->audioGroupMngr_->SetMicrophoneMute(context->isMute); + } + }, + SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc > PARAM0) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "IsMicrophoneMute", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->isMute = context->objectInfo->audioGroupMngr_->IsMicrophoneMute(); + context->isTrue = context->isMute; + } + }, + IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info) +{ + napi_value undefinedResult = nullptr; + napi_get_undefined(env, &undefinedResult); + + const size_t minArgCount = 2; + size_t argCount = 3; + napi_value args[minArgCount + 1] = {nullptr, nullptr, nullptr}; + napi_value jsThis = nullptr; + napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); + if (status != napi_ok || argCount < minArgCount) { + AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + } + + napi_valuetype eventType = napi_undefined; + if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + return undefinedResult; + } + std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); + AUDIO_INFO_LOG("AudioVolumeGroupManagerNapi::On callbackName: %{public}s", callbackName.c_str()); + + AudioVolumeGroupManagerNapi *volumeGroupManagerNapi = nullptr; + status = napi_unwrap(env, jsThis, reinterpret_cast(&volumeGroupManagerNapi)); + + napi_valuetype handler = napi_undefined; + if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::On type mismatch for parameter 2"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + return undefinedResult; + } + + + if (!callbackName.compare(RINGERMODE_CALLBACK_NAME)) { + if (volumeGroupManagerNapi->ringerModecallbackNapi_ == nullptr) { + volumeGroupManagerNapi->ringerModecallbackNapi_ = std::make_shared(env); + int32_t ret = volumeGroupManagerNapi->audioGroupMngr_->SetRingerModeCallback( + volumeGroupManagerNapi->cachedClientId, volumeGroupManagerNapi->ringerModecallbackNapi_); + if (ret) { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi:: SetRingerModeCallback Failed"); + return undefinedResult; + } else { + AUDIO_INFO_LOG("AudioVolumeGroupManagerNapi:: SetRingerModeCallback Success"); + } + } + + std::shared_ptr cb = + std::static_pointer_cast(volumeGroupManagerNapi->ringerModecallbackNapi_); + cb->SaveCallbackReference(callbackName, args[PARAM1]); + } else if (!callbackName.compare(MIC_STATE_CHANGE_CALLBACK_NAME)) { + if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) { + volumeGroupManagerNapi->micStateChangeCallbackNapi_= std::make_shared(env); + if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi:: Memory Allocation Failed !!"); + } + + int32_t ret = volumeGroupManagerNapi->audioGroupMngr_->SetMicStateChangeCallback( + volumeGroupManagerNapi->micStateChangeCallbackNapi_); + if (ret) { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi:: Registering Microphone Change Callback Failed"); + } + } + + std::shared_ptr cb = + std::static_pointer_cast(volumeGroupManagerNapi->micStateChangeCallbackNapi_); + cb->SaveCallbackReference(callbackName, args[PARAM1]); + + AUDIO_INFO_LOG("AudioVolumeGroupManagerNapi::On SetMicStateChangeCallback is successful"); + } else { + AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::No such callback supported"); + AudioCommonNapi::throwError(env, ERR_NUMBER101); + } + return undefinedResult; + +} + +napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports) { AUDIO_INFO_LOG("AudioRoutingManagerNapi::Init"); napi_status status; @@ -636,15 +1042,21 @@ napi_value AudioGroupManagerNapi::Init(napi_env env, napi_value exports) napi_get_undefined(env, &result); napi_property_descriptor audio_svc_group_mngr_properties[] = { - DECLARE_NAPI_FUNCTION("setVolume", AudioGroupManagerNapi::SetVolume), - DECLARE_NAPI_FUNCTION("getVolume", AudioGroupManagerNapi::GetVolume), - DECLARE_NAPI_FUNCTION("getMaxVolume", AudioGroupManagerNapi::GetMaxVolume), - DECLARE_NAPI_FUNCTION("getMinVolume", AudioGroupManagerNapi::GetMinVolume), - DECLARE_NAPI_FUNCTION("mute", AudioGroupManagerNapi::SetMute), - DECLARE_NAPI_FUNCTION("isMute", AudioGroupManagerNapi::IsStreamMute), + DECLARE_NAPI_FUNCTION("setVolume", AudioVolumeGroupManagerNapi::SetVolume), + DECLARE_NAPI_FUNCTION("getVolume", AudioVolumeGroupManagerNapi::GetVolume), + DECLARE_NAPI_FUNCTION("getMaxVolume", AudioVolumeGroupManagerNapi::GetMaxVolume), + DECLARE_NAPI_FUNCTION("getMinVolume", AudioVolumeGroupManagerNapi::GetMinVolume), + DECLARE_NAPI_FUNCTION("mute", AudioVolumeGroupManagerNapi::SetMute), + DECLARE_NAPI_FUNCTION("isMute", AudioVolumeGroupManagerNapi::IsStreamMute), + DECLARE_NAPI_FUNCTION("setRingerMode", SetRingerMode), + DECLARE_NAPI_FUNCTION("getRingerMode", GetRingerMode), + DECLARE_NAPI_FUNCTION("setMicrophoneMute", SetMicrophoneMute), + DECLARE_NAPI_FUNCTION("isMicrophoneMute", IsMicrophoneMute), + DECLARE_NAPI_FUNCTION("on", On), + }; - status = napi_define_class(env, AUDIO_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, + status = napi_define_class(env, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, sizeof(audio_svc_group_mngr_properties) / sizeof(audio_svc_group_mngr_properties[PARAM0]), audio_svc_group_mngr_properties, &constructor); if (status != napi_ok) { @@ -652,7 +1064,7 @@ napi_value AudioGroupManagerNapi::Init(napi_env env, napi_value exports) } status = napi_create_reference(env, constructor, refCount, &g_groupmanagerConstructor); if (status == napi_ok) { - status = napi_set_named_property(env, exports, AUDIO_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), constructor); + status = napi_set_named_property(env, exports, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), constructor); if (status == napi_ok) { return exports; } 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 new file mode 100644 index 0000000000..b27be35dc9 --- /dev/null +++ b/frameworks/js/napi/audio_manager/src/audio_volume_manager_napi.cpp @@ -0,0 +1,455 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_volume_manager_napi.h" +#include "audio_volume_group_manager_napi.h" + +#include "audio_common_napi.h" +#include "audio_volume_key_event_napi.h" +#include "audio_errors.h" +#include "audio_log.h" +#include "hilog/log.h" +#include "napi_base_context.h" + +using namespace std; +using OHOS::HiviewDFX::HiLog; +using OHOS::HiviewDFX::HiLogLabel; + +namespace OHOS { +namespace AudioStandard { +static __thread napi_ref g_volumeManagerConstructor = nullptr; + +namespace { + const int ARGS_ONE = 1; + const int ARGS_TWO = 2; + const int PARAM0 = 0; + const int PARAM1 = 1; + constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioVolumeManagerNapi"}; + const std::string VOLUME_CHANGE_CALLBACK_NAME = "volumeChange"; +} + +struct AudioVolumeManagerAsyncContext { + napi_env env; + napi_async_work work; + napi_deferred deferred; + napi_ref callbackRef = nullptr; + int32_t deviceFlag; + bool bArgTransFlag = true; + int32_t status = SUCCESS; + int32_t groupId; + int32_t intValue; + int32_t ringMode; + bool isMute; + bool isTrue; + std::string networkId; + AudioVolumeManagerNapi *objectInfo; + vector> volumeGroupInfos; +}; + +AudioVolumeManagerNapi::AudioVolumeManagerNapi() + : audioSystemMngr_(nullptr), env_(nullptr), wrapper_(nullptr) {} + +AudioVolumeManagerNapi::~AudioVolumeManagerNapi() +{ + if (wrapper_ != nullptr) { + napi_delete_reference(env_, wrapper_); + } +} + + +void AudioVolumeManagerNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint) +{ + if (nativeObject != nullptr) { + auto obj = static_cast(nativeObject); + delete obj; + obj = nullptr; + } +} + +napi_value AudioVolumeManagerNapi::Construct(napi_env env, napi_callback_info info) +{ + AUDIO_INFO_LOG("AudioVolumeManagerNapi::Construct"); + napi_status status; + napi_value result = nullptr; + napi_get_undefined(env, &result); + + size_t argc = ARGS_TWO; + napi_value argv[ARGS_TWO] = {0}; + napi_value thisVar = nullptr; + void *data = nullptr; + + napi_get_cb_info(env, info, &argc, argv, &thisVar, &data); + unique_ptr audioVolumeManagerNapi = make_unique(); + CHECK_AND_RETURN_RET_LOG(audioVolumeManagerNapi != nullptr, result, "No memory"); + + audioVolumeManagerNapi->audioSystemMngr_ = AudioSystemManager::GetInstance(); + audioVolumeManagerNapi->env_ = env; + + status = napi_wrap(env, thisVar, static_cast(audioVolumeManagerNapi.get()), + AudioVolumeManagerNapi::Destructor, nullptr, &(audioVolumeManagerNapi->wrapper_)); + if (status == napi_ok) { + audioVolumeManagerNapi.release(); + return thisVar; + } + + HiLog::Error(LABEL, "Failed in AudioVolumeManager::Construct()!"); + return result; +} + +napi_value AudioVolumeManagerNapi::CreateVolumeManagerWrapper(napi_env env) +{ + napi_status status; + napi_value result = nullptr; + napi_value constructor; + + status = napi_get_reference_value(env, g_volumeManagerConstructor, &constructor); + if (status == napi_ok) { + status = napi_new_instance(env, constructor, 0, nullptr, &result); + if (status == napi_ok) { + return result; + } + } + HiLog::Error(LABEL, "Failed in AudioVolumeManagerNapi::CreateVolumeManagerWrapper!"); + napi_get_undefined(env, &result); + + return result; +} + +napi_value AudioVolumeManagerNapi::Init(napi_env env, napi_value exports) +{ + AUDIO_INFO_LOG("AudioVolumeManagerNapi::Init"); + napi_status status; + napi_value constructor; + napi_value result = nullptr; + const int32_t refCount = 1; + napi_get_undefined(env, &result); + + napi_property_descriptor audio_routing_manager_properties[] = { + DECLARE_NAPI_FUNCTION("getVolumeGroupInfos", GetVolumeGroupInfos), + DECLARE_NAPI_FUNCTION("getVolumeGroupManager", GetVolumeGroupManager), + DECLARE_NAPI_FUNCTION("on", On), + + }; + + status = napi_define_class(env, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, + sizeof(audio_routing_manager_properties) / sizeof(audio_routing_manager_properties[PARAM0]), + audio_routing_manager_properties, &constructor); + if (status != napi_ok) { + return result; + } + status = napi_create_reference(env, constructor, refCount, &g_volumeManagerConstructor); + if (status == napi_ok) { + status = napi_set_named_property(env, exports, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), constructor); + if (status == napi_ok) { + return exports; + } + } + + HiLog::Error(LABEL, "Failure in AudioVolumeManagerNapi::Init()"); + return result; +} + +static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value& result) +{ + napi_value value = nullptr; + napi_create_int32(env, intValue, &value); + napi_set_named_property(env, result, fieldStr.c_str(), value); +} + +static void SetValueString(const napi_env& env, const std::string& fieldStr, const std::string stringValue, + napi_value& result) +{ + napi_value value = nullptr; + napi_create_string_utf8(env, stringValue.c_str(), NAPI_AUTO_LENGTH, &value); + napi_set_named_property(env, result, fieldStr.c_str(), value); +} + +static void CommonCallbackRoutine(napi_env env, AudioVolumeManagerAsyncContext *&asyncContext, + const napi_value &valueParam) +{ + napi_value result[ARGS_TWO] = {0}; + napi_value retVal; + + if (!asyncContext->status) { + napi_get_undefined(env, &result[PARAM0]); + result[PARAM1] = valueParam; + } else { + napi_value message = nullptr; + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); + napi_get_undefined(env, &result[PARAM1]); + } + + if (asyncContext->deferred) { + if (!asyncContext->status) { + napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]); + } else { + napi_reject_deferred(env, asyncContext->deferred, result[PARAM0]); + } + } else { + napi_value callback = nullptr; + napi_get_reference_value(env, asyncContext->callbackRef, &callback); + napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal); + napi_delete_reference(env, asyncContext->callbackRef); + } + napi_delete_async_work(env, asyncContext->work); + + delete asyncContext; + asyncContext = nullptr; +} + +static void GetVolumeGroupInfosAsyncCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + + napi_value result[ARGS_TWO] = { 0 }; + napi_value valueParam = nullptr; + if (asyncContext != nullptr) { + if (asyncContext->status) { + napi_get_undefined(env, &valueParam); + } else { + size_t size = asyncContext->volumeGroupInfos.size(); + HiLog::Info(LABEL, "number of devices = %{public}zu", size); + napi_create_array_with_length(env, size, &result[PARAM1]); + for (size_t i = 0; i < size; i++) { + if (asyncContext->volumeGroupInfos[i] != nullptr) { + (void)napi_create_object(env, &valueParam); + SetValueString(env, "networkId", static_cast( + asyncContext->volumeGroupInfos[i]->networkId_), valueParam); + SetValueInt32(env, "groupId", static_cast( + asyncContext->volumeGroupInfos[i]->volumeGroupId_), valueParam); + SetValueInt32(env, "mappingId", static_cast( + asyncContext->volumeGroupInfos[i]->mappingId_), valueParam); + SetValueString(env, "groupName", static_cast( + asyncContext->volumeGroupInfos[i]->groupName_), valueParam); + SetValueInt32(env, "ConnectType", static_cast( + asyncContext->volumeGroupInfos[i]->connectType_), valueParam); + napi_set_element(env, result[PARAM1], i, valueParam); + } + } + } + CommonCallbackRoutine(env, asyncContext, result[PARAM1]); + } else { + HiLog::Error(LABEL, "ERROR: AudioRoutingManagerAsyncContext* is Null!"); + } +} + +napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + if (i == PARAM0 && valueType == napi_string) { + asyncContext->networkId = AudioCommonNapi::GetStringArgument(env, argv[i]); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "GetVolumeGroupInfos", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void* data) { + auto context = static_cast(data); + if (!context->status) { + context->volumeGroupInfos = context->objectInfo->audioSystemMngr_->GetVolumeGroups(context->networkId); + context->status = 0; + } + }, + GetVolumeGroupInfosAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + AudioCommonNapi::throwError(env, ERR_NUMBER301); + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +static void GetGroupMgrAsyncCallbackComplete(napi_env env, napi_status status, void* data) +{ + napi_value valueParam = nullptr; + auto asyncContext = static_cast(data); + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + valueParam = AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(env, asyncContext->groupId); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR: GetStreamMgrAsyncCallbackComplete asyncContext is Null!"); + } +} + +napi_value AudioVolumeManagerNapi::GetVolumeGroupManager(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, " %{public}s IN", __func__); + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_TWO); + + unique_ptr asyncContext = make_unique(); + CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioVolumeManagerAsyncContext object creation failed"); + if (argc < ARGS_ONE){ + asyncContext->status = ERR_NUMBER101; + } + for (size_t i = PARAM0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + if (i == PARAM0 && valueType == napi_number) { + napi_get_value_int32(env, argv[i], &asyncContext->groupId); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } + break; + } else { + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "GetVolumeGroupManager", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (!context->status) { + context->status = SUCCESS; + } + }, + GetGroupMgrAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + + return result; +} + +napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) +{ + napi_value undefinedResult = nullptr; + napi_get_undefined(env, &undefinedResult); + + const size_t minArgCount = 2; + size_t argCount = 3; + napi_value args[minArgCount + 1] = {nullptr, nullptr, nullptr}; + napi_value jsThis = nullptr; + napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); + if (status != napi_ok || argCount < minArgCount) { + AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + } + + napi_valuetype eventType = napi_undefined; + if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + return undefinedResult; + } + std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); + AUDIO_INFO_LOG("AudioVolumeManagerNapi::On callbackName: %{public}s", callbackName.c_str()); + + AudioVolumeManagerNapi *volumeManagerNapi = nullptr; + status = napi_unwrap(env, jsThis, reinterpret_cast(&volumeManagerNapi)); + NAPI_ASSERT(env, status == napi_ok && volumeManagerNapi != nullptr, "Failed to retrieve audio manager napi instance."); + NAPI_ASSERT(env, volumeManagerNapi->audioSystemMngr_ != nullptr, "audio system manager instance is null."); + + napi_valuetype handler = napi_undefined; + if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { + AUDIO_ERR_LOG("AudioVolumeManagerNapi::On type mismatch for parameter 2"); + AudioCommonNapi::throwError(env, ERR_NUMBER_401); + return undefinedResult; + } + + + if (!callbackName.compare(VOLUME_CHANGE_CALLBACK_NAME)) { + if (volumeManagerNapi->volumeKeyEventCallbackNapi_ == nullptr) { + volumeManagerNapi->volumeKeyEventCallbackNapi_ = std::make_shared(env); + int32_t ret = volumeManagerNapi->audioSystemMngr_->RegisterVolumeKeyEventCallback(volumeManagerNapi->cachedClientId, + volumeManagerNapi->volumeKeyEventCallbackNapi_); + if (ret) { + AUDIO_ERR_LOG("AudioVolumeManagerNapi:: RegisterVolumeKeyEventCallback Failed"); + } else { + AUDIO_DEBUG_LOG("AudioVolumeManagerNapi:: RegisterVolumeKeyEventCallback Success"); + } + } + std::shared_ptr cb = + std::static_pointer_cast(volumeManagerNapi->volumeKeyEventCallbackNapi_); + cb->SaveCallbackReference(callbackName, args[PARAM1]); + }else { + AUDIO_ERR_LOG("AudioVolumeManagerNapi::No such callback supported"); + AudioCommonNapi::throwError(env, ERR_NUMBER101); + } + return undefinedResult; + +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index 183dc002ab..935d7a1308 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -276,7 +276,53 @@ enum FocusType { /** * Recording type. */ - FOCUS_TYPE_RECORDING = 0, + FOCUS_TYPE_DEFAULT = 0, +}; + +enum AudioErrors { + /** + * Common errors. + */ + ERROR_INVALID_PARAM = 6800101, + ERROR_NO_MEMORY = 6800102, + ERROR_ILLEGAL_STATE = 6800103, + ERROR_UNSUPPORTED = 6800104, + ERROR_TIMEOUT = 6800105, + /** + * Audio specific errors. + */ + ERROR_STREAM_LIMIT = 6800201, + /** + * Default error. + */ + ERROR_SYSTEM = 6800301 +}; + +enum CommunicationDeviceType { + /** + * Speaker. + * @since 7 + * @syscap SystemCapability.Multimedia.Audio.Communication + */ + COMMUNICATION_SPEAKER = 2 +}; + +enum AudioOutputChannelMask { + CHANNEL_OUT_FRONT_LEFT = 0x1 << 0, + CHANNEL_OUT_FRONT_RIGHT = 0x1 << 1, + CHANNEL_OUT_FRONT_CENTER = 0x1 << 2, + CHANNEL_OUT_LOW_FREQUENCY = 0x1 << 3, + CHANNEL_OUT_SIDE_LEFT = 0x1 << 4, + CHANNEL_OUT_SIDE_RIGHT = 0x1 << 5, + CHANNEL_OUT_BACK_LEFT = 0x1 << 6, + CHANNEL_OUT_BACK_RIGHT = 0x1 << 7 +}; + +enum AudioInputChannelMask { + CHANNEL_IN_LEFT = 0x1 << 0, + CHANNEL_IN_RIGHT = 0x1 << 1, + CHANNEL_IN_FRONT = 0x1 << 2, + CHANNEL_IN_BACK = 0x1 << 3 }; enum InterruptMode { @@ -511,6 +557,8 @@ struct AudioStreamInfo { AudioEncodingType encoding; AudioSampleFormat format; AudioChannel channels; + AudioOutputChannelMask channelOut; + AudioInputChannelMask channelIn; }; struct AudioRendererInfo { diff --git a/interfaces/kits/js/audio_manager/include/audio_interrupt_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_interrupt_manager_napi.h new file mode 100644 index 0000000000..3517a615c7 --- /dev/null +++ b/interfaces/kits/js/audio_manager/include/audio_interrupt_manager_napi.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_INTERRUPT_MANAGER_NAPI_H_ +#define AUDIO_INTERRUPT_MANAGER_NAPI_H_ + +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "audio_system_manager.h" +#include "audio_manager_callback_napi.h" + +namespace OHOS { +namespace AudioStandard { +static const std::string AUDIO_INTERRUPT_MANAGER_NAPI_CLASS_NAME = "AudioInterruptManager"; + +struct AudioInterruptManagerAsyncContext; +class AudioInterruptManagerNapi { +public: + AudioInterruptManagerNapi(); + ~AudioInterruptManagerNapi(); + + static napi_value Init(napi_env env, napi_value exports); + static napi_value CreateInterruptManagerWrapper(napi_env env); +private: + + static napi_value On(napi_env env, napi_callback_info info); + + static napi_value Construct(napi_env env, napi_callback_info info); + static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); + AudioSystemManager *audioSystemMngr_; + + napi_env env_; + napi_ref wrapper_; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif /* AUDIO_INTERRUPT_MANAGER_NAPI_H_ */ 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 a7bbd2a503..da1986b411 100644 --- a/interfaces/kits/js/audio_manager/include/audio_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_manager_napi.h @@ -56,7 +56,7 @@ public: }; enum FocusType { - FOCUS_TYPE_RECORDING + FOCUS_TYPE_DEFAULT }; static napi_value Init(napi_env env, napi_value exports); @@ -104,11 +104,9 @@ private: static napi_value AbandonIndependentInterrupt(napi_env env, napi_callback_info info); static napi_value GetStreamManager(napi_env env, napi_callback_info info); static napi_value GetRoutingManager(napi_env env, napi_callback_info info); - static void GetStreamMgrAsyncCallbackComplete(napi_env env, napi_status status, void *data); + static napi_value GetVolumeManager(napi_env env, napi_callback_info info); + static napi_value GetInterruptManager(napi_env env, napi_callback_info info); static void AddPropName(std::string& propName, napi_status& status, napi_env env, napi_value& result); - static napi_value GetVolumeGroups(napi_env env, napi_callback_info info); - static napi_value GetGroupManager(napi_env env, napi_callback_info info); - static void GetGroupMgrAsyncCallbackComplete(napi_env env, napi_status status, void* data); template static napi_value CreatePropertyBase(napi_env env, T& t_map, napi_ref ref); @@ -126,6 +124,10 @@ private: static napi_ref interruptMode_; static napi_ref focusType_; static napi_ref connectTypeRef_; + static napi_ref audioErrors_; + static napi_ref communicationDeviceType_; + static napi_ref audioOutputChannelMask_; + static napi_ref audioInputChannelMask_; AudioSystemManager *audioMngr_; int32_t cachedClientId = -1; @@ -171,7 +173,37 @@ static const std::map interruptModeMa {"INDEPENDENT_MODE", INDEPENDENT_MODE} }; static const std::map focusTypeMap = { - {"FOCUS_TYPE_RECORDING", FOCUS_TYPE_RECORDING} + {"FOCUS_TYPE_DEFAULT", FOCUS_TYPE_DEFAULT} +}; + +static const std::map audioErrorsMap = { + {"ERROR_INVALID_PARAM", ERROR_INVALID_PARAM}, + {"ERROR_NO_MEMORY", ERROR_NO_MEMORY}, + {"ERROR_ILLEGAL_STATE", ERROR_ILLEGAL_STATE}, + {"ERROR_UNSUPPORTED", ERROR_UNSUPPORTED}, + {"ERROR_TIMEOUT", ERROR_TIMEOUT}, + {"ERROR_STREAM_LIMIT", ERROR_STREAM_LIMIT}, + {"ERROR_SYSTEM", ERROR_SYSTEM} +}; + +static const std::map communicationDeviceTypeMap = { + {"SPEAKER", COMMUNICATION_SPEAKER} +}; +static const std::map audioOutputChannelMaskMap = { + {"CHANNEL_OUT_FRONT_LEFT", CHANNEL_OUT_FRONT_LEFT}, + {"CHANNEL_OUT_FRONT_RIGHT", CHANNEL_OUT_FRONT_RIGHT}, + {"CHANNEL_OUT_FRONT_CENTER", CHANNEL_OUT_FRONT_CENTER}, + {"CHANNEL_OUT_LOW_FREQUENCY", CHANNEL_OUT_LOW_FREQUENCY}, + {"CHANNEL_OUT_SIDE_LEFT", CHANNEL_OUT_SIDE_LEFT}, + {"CHANNEL_OUT_SIDE_RIGHT", CHANNEL_OUT_SIDE_RIGHT}, + {"CHANNEL_OUT_BACK_LEFT", CHANNEL_OUT_BACK_LEFT}, + {"CHANNEL_OUT_BACK_RIGHT", CHANNEL_OUT_BACK_RIGHT}, +}; +static const std::map audioInputChannelMaskMap = { + {"CHANNEL_IN_LEFT", CHANNEL_IN_LEFT}, + {"CHANNEL_IN_RIGHT", CHANNEL_IN_RIGHT}, + {"CHANNEL_IN_FRONT", CHANNEL_IN_FRONT}, + {"CHANNEL_IN_BACK", CHANNEL_IN_BACK}, }; } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/js/napi/audio_manager/include/audio_routing_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h similarity index 94% rename from frameworks/js/napi/audio_manager/include/audio_routing_manager_napi.h rename to interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h index aaf2e232b0..2461915de9 100644 --- a/frameworks/js/napi/audio_manager/include/audio_routing_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_routing_manager_napi.h @@ -45,10 +45,11 @@ private: static napi_value SelectInputDevice(napi_env env, napi_callback_info info); static napi_value SelectOutputDeviceByFilter(napi_env env, napi_callback_info info); 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 void RegisterDeviceChangeCallback(napi_env env, napi_value* args, const std::string& cbName, int32_t flag, AudioRoutingManagerNapi* routingMgrNapi); - static void RegisterMicStateChangeCallback(napi_env env, napi_value* args, const std::string& cbName, - AudioRoutingManagerNapi* routingMgrNapi); static void RegisterCallback(napi_env env, napi_value jsThis, napi_value* args, const std::string& cbName, int32_t flag); static napi_value On(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/audio_stream_manager/include/audio_stream_mgr_napi.h b/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h similarity index 95% rename from interfaces/kits/js/audio_stream_manager/include/audio_stream_mgr_napi.h rename to interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h index 2ca06fe804..ab11d4a148 100644 --- a/interfaces/kits/js/audio_stream_manager/include/audio_stream_mgr_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_stream_mgr_napi.h @@ -20,6 +20,7 @@ #include "napi/native_api.h" #include "napi/native_node_api.h" #include "audio_stream_manager.h" +#include "audio_system_manager.h" namespace OHOS { namespace AudioStandard { @@ -40,6 +41,7 @@ private: 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 void RegisterCallback(napi_env env, napi_value jsThis, napi_value* args, const std::string& cbName); static void RegisterCapturerStateChangeCallback(napi_env env, napi_value* args, @@ -54,6 +56,7 @@ private: napi_env env_; napi_ref wrapper_; AudioStreamManager *audioStreamMngr_; + AudioSystemManager *audioMngr_; int32_t cachedClientId_ = -1; std::shared_ptr rendererStateChangeCallbackNapi_ = nullptr; std::shared_ptr capturerStateChangeCallbackNapi_ = nullptr; diff --git a/frameworks/js/napi/audio_manager/include/audio_group_manager_napi.h b/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h similarity index 56% rename from frameworks/js/napi/audio_manager/include/audio_group_manager_napi.h rename to interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h index 914914e3fe..244b441bd6 100755 --- a/frameworks/js/napi/audio_manager/include/audio_group_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_volume_group_manager_napi.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef AUDIO_GROUP_MNGR_NAPI_H_ -#define AUDIO_GROUP_MNGR_NAPI_H_ +#ifndef AUDIO_VOLUME_GROUP_MNGR_NAPI_H_ +#define AUDIO_VOLUME_GROUP_MNGR_NAPI_H_ #include #include @@ -22,21 +22,28 @@ #include "audio_system_manager.h" #include "napi/native_api.h" #include "napi/native_node_api.h" -#include "audio_manager_napi.h" +#include "audio_common_napi.h" +#include "audio_ringermode_callback_napi.h" +#include "audio_micstatechange_callback_napi.h" namespace OHOS { namespace AudioStandard { -static const std::string AUDIO_GROUP_MNGR_NAPI_CLASS_NAME = "AudioGroupManager"; +static const std::string AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME = "AudioVolumeGroupManager"; -class AudioGroupManagerNapi { +class AudioVolumeGroupManagerNapi { public: + enum AudioRingMode { + RINGER_MODE_SILENT = 0, + RINGER_MODE_VIBRATE, + RINGER_MODE_NORMAL + }; + static napi_value Init(napi_env env, napi_value exports); - static napi_value CreateAudioGroupManagerWrapper(napi_env env, int32_t groupId); + static napi_value CreateAudioVolumeGroupManagerWrapper(napi_env env, int32_t groupId); private: static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); - static void GetGroupManagerAsyncCallbackComplete(napi_env env, napi_status status, void *data); 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 SetVolume(napi_env env, napi_callback_info info); @@ -44,10 +51,18 @@ private: static napi_value GetMinVolume(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 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); + static napi_value IsMicrophoneMute(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); std::shared_ptr audioGroupMngr_ = nullptr; + int32_t cachedClientId = -1; + std::shared_ptr ringerModecallbackNapi_ = nullptr; + std::shared_ptr micStateChangeCallbackNapi_ = nullptr; napi_ref wrapper_; }; } // namespace AudioStandard } // namespace OHOS -#endif // AUDIO_GROUP_MNGR_NAPI_H_ +#endif // AUDIO_VOLUME_GROUP_MNGR_NAPI_H_ 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 new file mode 100644 index 0000000000..817aa54761 --- /dev/null +++ b/interfaces/kits/js/audio_manager/include/audio_volume_manager_napi.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_VOLUME_MANAGER_NAPI_H_ +#define AUDIO_VOLUME_MANAGER_NAPI_H_ + +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "audio_system_manager.h" +#include "audio_manager_callback_napi.h" +#include "audio_volume_group_manager_napi.h" + +namespace OHOS { +namespace AudioStandard { +static const std::string AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME = "AudioVolumeManager"; + +struct AudioVolumeManagerAsyncContext; +class AudioVolumeManagerNapi { +public: + AudioVolumeManagerNapi(); + ~AudioVolumeManagerNapi(); + + static napi_value Init(napi_env env, napi_value exports); + static napi_value CreateVolumeManagerWrapper(napi_env env); +private: + static napi_value GetVolumeGroupInfos(napi_env env, napi_callback_info info); + static napi_value GetVolumeGroupManager(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); + static napi_value IsMicrophoneMute(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); + + static napi_value Construct(napi_env env, napi_callback_info info); + static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); + AudioSystemManager *audioSystemMngr_; + + int32_t cachedClientId = -1; + std::shared_ptr volumeKeyEventCallbackNapi_ = nullptr; + + napi_env env_; + napi_ref wrapper_; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif /* AUDIO_ROUTING_MANAGER_NAPI_H_ */ -- Gitee From eb85ee873c509da029c92af6832885713619fcc4 Mon Sep 17 00:00:00 2001 From: liyuhang Date: Fri, 14 Oct 2022 18:34:47 +0800 Subject: [PATCH 2/5] Added NapiErr for AudioRenderer, AudioCapturer, TonePlayer. Signed-off-by: liyuhang Change-Id: I1f291113f79f1abc000bd70f9448d86bc191fbe1 Signed-off-by: liyuhang --- .../src/audio_capturer_napi.cpp | 316 ++++++---- .../audio_common/include/audio_common_napi.h | 18 +- .../audio_common/src/audio_common_napi.cpp | 3 +- .../src/audio_renderer_callback_napi.cpp | 2 +- .../src/audio_renderer_napi.cpp | 564 ++++++++++++------ .../napi/toneplayer/src/toneplayer_napi.cpp | 93 +-- .../include/audio_capturer_private.h | 1 + .../audiocapturer/src/audio_capturer.cpp | 5 + .../include/audio_renderer_private.h | 1 + .../audiorenderer/src/audio_renderer.cpp | 5 + .../audiocapturer/include/audio_capturer.h | 10 + .../audiorenderer/include/audio_renderer.h | 9 + .../include/audio_capturer_napi.h | 3 + .../include/audio_renderer_napi.h | 11 +- .../include/audio_policy_manager_stub.h | 2 +- 15 files changed, 688 insertions(+), 355 deletions(-) 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 717b245c34..43f9584756 100644 --- a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp +++ b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp @@ -101,6 +101,7 @@ napi_value AudioCapturerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("stop", Stop), DECLARE_NAPI_FUNCTION("release", Release), DECLARE_NAPI_FUNCTION("getBufferSize", GetBufferSize), + DECLARE_NAPI_FUNCTION("getAudioStreamId", GetAudioStreamId), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_GETTER("state", GetState) @@ -235,9 +236,11 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in bool inputRight = true; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameters minimum"); - unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + if (asyncContext == nullptr) { return result; } @@ -250,11 +253,13 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in HiLog::Error(LABEL, "Parsing of capturer options failed"); inputRight = false; } - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -272,7 +277,7 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_INVALID_PARAM; + context->status = ERR_NUMBER101; HiLog::Error(LABEL, "ParseCapturerOptions fail, invalid param!"); }, CheckCapturerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -309,16 +314,15 @@ void AudioCapturerNapi::CommonCallbackRoutine(napi_env env, AudioCapturerAsyncCo if (!asyncContext->status) { napi_get_undefined(env, &result[PARAM0]); result[PARAM1] = valueParam; - } else if (ERR_INVALID_PARAM == asyncContext->status) { - napi_value message = nullptr; - napi_create_string_utf8(env, "Error, The input parameters are incorrect, please check!", - NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); - napi_get_undefined(env, &result[PARAM1]); } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -491,6 +495,21 @@ void AudioCapturerNapi::GetBufferSizeAsyncCallbackComplete(napi_env env, napi_st } } +void AudioCapturerNapi::GetAudioStreamIdCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + napi_value valueParam = nullptr; + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_create_uint32(env, asyncContext->audioStreamId, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR::GetAudioStreamIdCallbackComplete* is Null!"); + } +} + void AudioCapturerNapi::GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data) { auto asyncContext = static_cast(data); @@ -531,18 +550,14 @@ napi_value AudioCapturerNapi::GetCapturerInfo(napi_env env, napi_callback_info i GET_PARAMS(env, info, ARGS_ONE); unique_ptr asyncContext = make_unique(); - NAPI_ASSERT(env, asyncContext != nullptr, "no memory"); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -593,15 +608,11 @@ napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info inf unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -643,7 +654,7 @@ napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info inf return result; } -napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) +napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info info) { napi_status status; const int32_t refCount = 1; @@ -652,19 +663,76 @@ napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) GET_PARAMS(env, info, ARGS_ONE); unique_ptr asyncContext = make_unique(); - NAPI_ASSERT(env, asyncContext != nullptr, "no memory"); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } + } - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "GetAudioStreamId", NAPI_AUTO_LENGTH, &resource); + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + size_t audioStreamId; + int32_t streamIdStatus; + streamIdStatus = context->objectInfo->audioCapturer_->GetAudioStreamId(audioStreamId); + if (streamIdStatus == ERR_ILLEGAL_STATE) { + context->status = ERR_NUMBER103; + } else if (streamIdStatus == ERR_INVALID_INDEX) { + context->status = ERR_NUMBER301; + } else { + context->status = SUCCESS; + } + context->audioStreamId = audioStreamId; + }, + GetAudioStreamIdCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); } else { - NAPI_ASSERT(env, false, "type mismatch"); + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + unique_ptr asyncContext = make_unique(); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc > PARAM0) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -682,7 +750,11 @@ napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioCapturer_->Start(); - context->status = SUCCESS; + if (context->isTrue) { + context->status = SUCCESS; + } else { + context->status = ERR_NUMBER301; + } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -707,9 +779,11 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_THREE); - NAPI_ASSERT(env, argc >= ARGS_TWO, "requires 2 parameters minimum"); unique_ptr asyncContext = make_unique(); + if (argc < ARGS_TWO) { + asyncContext->status = ERR_NUMBER101; + } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { @@ -721,11 +795,13 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) napi_get_value_uint32(env, argv[i], &asyncContext->userSize); } else if ((i == PARAM1) && (valueType == napi_boolean)) { napi_get_value_bool(env, argv[i], &asyncContext->isBlocking); - } else if (i == PARAM2 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM2) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -742,31 +818,33 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERROR; - uint32_t userSize = context->userSize; - auto buffer = std::make_unique(userSize); - if (!buffer) { - return; - } + if (context->status == SUCCESS) { + context->status = ERR_NUMBER301; + uint32_t userSize = context->userSize; + auto buffer = std::make_unique(userSize); + if (!buffer) { + return; + } - size_t bytesRead = 0; - while (bytesRead < context->userSize) { - int32_t len = context->objectInfo->audioCapturer_->Read(*(buffer.get() + bytesRead), - userSize - bytesRead, - context->isBlocking); - if (len >= 0) { - bytesRead += len; - } else { - bytesRead = len; - break; + size_t bytesRead = 0; + while (bytesRead < context->userSize) { + int32_t len = context->objectInfo->audioCapturer_->Read(*(buffer.get() + bytesRead), + userSize - bytesRead, + context->isBlocking); + if (len >= 0) { + bytesRead += len; + } else { + bytesRead = len; + break; + } } - } - if (bytesRead > 0) { - context->bytesRead = bytesRead; - context->buffer = buffer.get(); - buffer.release(); - context->status = SUCCESS; + if (bytesRead > 0) { + context->bytesRead = bytesRead; + context->buffer = buffer.get(); + buffer.release(); + context->status = SUCCESS; + } } }, ReadAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -797,15 +875,11 @@ napi_value AudioCapturerNapi::GetAudioTime(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -822,7 +896,7 @@ napi_value AudioCapturerNapi::GetAudioTime(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERROR; + context->status = ERR_NUMBER301; Timestamp timestamp; if (context->objectInfo->audioCapturer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC)) { const uint64_t secToNanosecond = 1000000000; @@ -858,15 +932,11 @@ napi_value AudioCapturerNapi::Stop(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -884,7 +954,11 @@ napi_value AudioCapturerNapi::Stop(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioCapturer_->Stop(); - context->status = SUCCESS; + if (context->isTrue) { + context->status = SUCCESS; + } else { + context->status = ERR_NUMBER301; + } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -914,15 +988,11 @@ napi_value AudioCapturerNapi::Release(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -943,7 +1013,7 @@ napi_value AudioCapturerNapi::Release(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERROR; + context->status = ERR_NUMBER301; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -971,20 +1041,22 @@ napi_value AudioCapturerNapi::RegisterPeriodPositionCallback(napi_env env, napi_ if (frameCount > 0) { if (capturerNapi->periodPositionCBNapi_ == nullptr) { capturerNapi->periodPositionCBNapi_ = std::make_shared(env); - NAPI_ASSERT(env, capturerNapi->periodPositionCBNapi_ != nullptr, "AudioCapturerNapi: No memory."); + THROW_ERROR_ASSERT(env, capturerNapi->periodPositionCBNapi_ != nullptr, ERR_NUMBER102); int32_t ret = capturerNapi->audioCapturer_->SetCapturerPeriodPositionCallback(frameCount, capturerNapi->periodPositionCBNapi_); - NAPI_ASSERT(env, ret == SUCCESS, "AudioCapturerNapi: SetCapturerPositionCallback failed."); + THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->periodPositionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_DEBUG_LOG("AudioCapturerNapi: periodReach already subscribed."); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); } } else { AUDIO_ERR_LOG("AudioCapturerNapi: frameCount value not supported!!"); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); } napi_value result = nullptr; @@ -1000,16 +1072,17 @@ napi_value AudioCapturerNapi::RegisterPositionCallback(napi_env env, napi_value* if (markPosition > 0) { capturerNapi->positionCBNapi_ = std::make_shared(env); - NAPI_ASSERT(env, capturerNapi->positionCBNapi_ != nullptr, "AudioCapturerNapi: No memory."); + THROW_ERROR_ASSERT(env, capturerNapi->positionCBNapi_ != nullptr, ERR_NUMBER102); int32_t ret = capturerNapi->audioCapturer_->SetCapturerPositionCallback(markPosition, capturerNapi->positionCBNapi_); - NAPI_ASSERT(env, ret == SUCCESS, "AudioCapturerNapi: SetCapturerPositionCallback failed."); + THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->positionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_ERR_LOG("AudioCapturerNapi: Mark Position value not supported!!"); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); } napi_value result = nullptr; @@ -1020,7 +1093,7 @@ napi_value AudioCapturerNapi::RegisterPositionCallback(napi_env env, napi_value* napi_value AudioCapturerNapi::RegisterCapturerCallback(napi_env env, napi_value* argv, const std::string& cbName, AudioCapturerNapi *capturerNapi) { - NAPI_ASSERT(env, capturerNapi->callbackNapi_ != nullptr, "AudioCapturerNapi: callbackNapi_ is nullptr"); + THROW_ERROR_ASSERT(env, capturerNapi->callbackNapi_ != nullptr, ERR_NUMBER102); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->callbackNapi_); @@ -1043,8 +1116,9 @@ napi_value AudioCapturerNapi::RegisterCallback(napi_env env, napi_value jsThis, { AudioCapturerNapi *capturerNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&capturerNapi)); - NAPI_ASSERT(env, status == napi_ok && capturerNapi != nullptr, "Failed to retrieve audio capturer napi instance."); - NAPI_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, "Audio capturer instance is null."); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, capturerNapi != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, ERR_NUMBER102); napi_value result = nullptr; napi_get_undefined(env, &result); @@ -1057,7 +1131,7 @@ napi_value AudioCapturerNapi::RegisterCallback(napi_env env, napi_value jsThis, result = RegisterPeriodPositionCallback(env, argv, cbName, capturerNapi); } else { bool unknownCallback = true; - NAPI_ASSERT(env, !unknownCallback, "No such on callback supported"); + THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER_101); } return result; @@ -1071,11 +1145,12 @@ napi_value AudioCapturerNapi::On(napi_env env, napi_callback_info info) napi_value argv[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - NAPI_ASSERT(env, status == napi_ok && argc >= requireArgc, "AudioCapturerNapi: On: requires min 2 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER_401); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioCapturerNapi:On: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioCapturerNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -1083,21 +1158,16 @@ napi_value AudioCapturerNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; if (argc == requireArgc) { napi_typeof(env, argv[1], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); } else { napi_valuetype paramArg1 = napi_undefined; napi_typeof(env, argv[1], ¶mArg1); napi_valuetype expectedValType = napi_number; // Default. Reset it with 'callbackName' if check, if required. - if (paramArg1 != expectedValType) { - AUDIO_ERR_LOG("Type mismatch for param 2!!"); - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; - } + THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, ERR_NUMBER_401); const int32_t arg2 = 2; napi_typeof(env, argv[arg2], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 3"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); } return RegisterCallback(env, jsThis, argv, callbackName); @@ -1107,8 +1177,9 @@ napi_value AudioCapturerNapi::UnregisterCallback(napi_env env, napi_value jsThis { AudioCapturerNapi *capturerNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&capturerNapi)); - NAPI_ASSERT(env, status == napi_ok && capturerNapi != nullptr, "Failed to retrieve audio capturer napi instance."); - NAPI_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, "Audio capturer instance is null."); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, capturerNapi != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, ERR_NUMBER102); if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { capturerNapi->audioCapturer_->UnsetCapturerPositionCallback(); @@ -1118,7 +1189,7 @@ napi_value AudioCapturerNapi::UnregisterCallback(napi_env env, napi_value jsThis capturerNapi->periodPositionCBNapi_ = nullptr; } else { bool unknownCallback = true; - NAPI_ASSERT(env, !unknownCallback, "No such off callback supported"); + THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER104); } napi_value result = nullptr; @@ -1134,11 +1205,12 @@ napi_value AudioCapturerNapi::Off(napi_env env, napi_callback_info info) napi_value argv[requireArgc] = {nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - NAPI_ASSERT(env, status == napi_ok && argc >= requireArgc, "AudioCapturerNapi: Off: requires min 1 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER101); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioCapturerNapi:Off: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER101); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioCapturerNapi: Off callbackName: %{public}s", callbackName.c_str()); @@ -1158,15 +1230,11 @@ napi_value AudioCapturerNapi::GetBufferSize(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } 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 d56732e80d..19d38d3f21 100644 --- a/frameworks/js/napi/audio_common/include/audio_common_napi.h +++ b/frameworks/js/napi/audio_common/include/audio_common_napi.h @@ -40,6 +40,7 @@ namespace OHOS { namespace AudioStandard { namespace { const std::string INTERRUPT_CALLBACK_NAME = "interrupt"; + const std::string AUDIO_INTERRUPT_CALLBACK_NAME = "audioInterrupt"; const std::string INDEPENDENTINTERRUPT_CALLBACK_NAME = "independentInterrupt"; const std::string STATE_CHANGE_CALLBACK_NAME = "stateChange"; } @@ -83,15 +84,18 @@ struct AutoRef { napi_env env_; napi_ref cb_; }; + +const int32_t ERR_NUMBER_101 = 6800101; const int32_t ERR_NUMBER_401 = 401; -const int32_t ERR_NUMBER101 = ERROR_INVALID_PARAM; -const int32_t ERR_NUMBER102 = ERROR_NO_MEMORY; -const int32_t ERR_NUMBER103 = ERROR_ILLEGAL_STATE; -const int32_t ERR_NUMBER104 = ERROR_UNSUPPORTED; -const int32_t ERR_NUMBER105 = ERROR_TIMEOUT; -const int32_t ERR_NUMBER201 = ERROR_STREAM_LIMIT; -const int32_t ERR_NUMBER301 = ERROR_SYSTEM; +const int32_t ERR_NUMBER101 = 6800101; +const int32_t ERR_NUMBER102 = 6800102; +const int32_t ERR_NUMBER103 = 6800103; +const int32_t ERR_NUMBER104 = 6800104; +const int32_t ERR_NUMBER105 = 6800105; +const int32_t ERR_NUMBER201 = 6800201; +const int32_t ERR_NUMBER301 = 6800301; +const std::string ERR_MESSAGE_101 = "input parameter value error"; const std::string ERR_MESSAGE_401 = "input parameter type or number mismatch"; const std::string ERR_MESSAGE101 = "invalid parameter"; const std::string ERR_MESSAGE102 = "allocate memory failed"; 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 77fc790dff..9eeca53c86 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -16,6 +16,7 @@ #include "audio_common_napi.h" #include "audio_log.h" #include "audio_manager_napi.h" +#include "audio_info.h" namespace OHOS { namespace AudioStandard { @@ -171,4 +172,4 @@ bool AudioCommonNapi::IsLegalInputArgumentRingMode(int32_t ringerMode) } } // namespace AudioStandard -} // namespace OHOS +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/audio_renderer/src/audio_renderer_callback_napi.cpp b/frameworks/js/napi/audio_renderer/src/audio_renderer_callback_napi.cpp index 111835605c..48af825d0d 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_callback_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_callback_napi.cpp @@ -43,7 +43,7 @@ void AudioRendererCallbackNapi::SaveCallbackReference(const std::string &callbac "AudioRendererCallbackNapi: creating reference for callback fail"); std::shared_ptr cb = std::make_shared(env_, callback); - if (callbackName == INTERRUPT_CALLBACK_NAME) { + if (callbackName == INTERRUPT_CALLBACK_NAME || callbackName == AUDIO_INTERRUPT_CALLBACK_NAME) { interruptCallback_ = cb; } else if (callbackName == STATE_CHANGE_CALLBACK_NAME) { stateChangeCallback_ = cb; 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 936282e42f..1963464be2 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp @@ -49,6 +49,7 @@ mutex AudioRendererNapi::createMutex_; namespace { const int ARGS_ONE = 1; const int ARGS_TWO = 2; + const int ARGS_THREE = 3; const int PARAM0 = 0; const int PARAM1 = 1; @@ -353,6 +354,8 @@ napi_value AudioRendererNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("stop", Stop), DECLARE_NAPI_FUNCTION("release", Release), DECLARE_NAPI_FUNCTION("getBufferSize", GetBufferSize), + DECLARE_NAPI_FUNCTION("getAudioStreamId", GetAudioStreamId), + DECLARE_NAPI_FUNCTION("setVolume", SetVolume), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), DECLARE_NAPI_FUNCTION("getRendererInfo", GetRendererInfo), @@ -412,6 +415,35 @@ static shared_ptr GetAbilityContext(napi_env env) return faContext; } +static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) +{ + AudioVolumeType result = STREAM_MUSIC; + + switch (volumeType) { + case AudioManagerNapi::RINGTONE: + result = STREAM_RING; + break; + case AudioManagerNapi::MEDIA: + result = STREAM_MUSIC; + break; + case AudioManagerNapi::VOICE_CALL: + result = STREAM_VOICE_CALL; + break; + case AudioManagerNapi::VOICE_ASSISTANT: + result = STREAM_VOICE_ASSISTANT; + break; + case AudioManagerNapi::ALL: + result = STREAM_ALL; + break; + default: + result = STREAM_MUSIC; + HiLog::Error(LABEL, "Unknown volume type, Set it to default MEDIA!"); + break; + } + + return result; +} + napi_value AudioRendererNapi::Construct(napi_env env, napi_callback_info info) { napi_status status; @@ -446,6 +478,7 @@ napi_value AudioRendererNapi::Construct(napi_env env, napi_callback_info info) cacheDir = "/data/storage/el2/base/haps/entry/files"; } rendererNapi->audioRenderer_ = AudioRenderer::Create(cacheDir, rendererOptions); + rendererNapi->audioMngr_ = AudioSystemManager::GetInstance(); CHECK_AND_RETURN_RET_LOG(rendererNapi->audioRenderer_ != nullptr, result, "Renderer Create failed"); @@ -476,9 +509,11 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameters minimum"); unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioRendererAsyncContext object creation failed"); for (size_t i = PARAM0; i < argc; i++) { @@ -489,11 +524,13 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in HiLog::Error(LABEL, "Parsing of renderer options failed"); return result; } - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -538,8 +575,13 @@ void AudioRendererNapi::CommonCallbackRoutine(napi_env env, AudioRendererAsyncCo result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -572,14 +614,20 @@ void AudioRendererNapi::WriteAsyncCallbackComplete(napi_env env, napi_status sta if (asyncContext != nullptr) { if (!asyncContext->status) { napi_create_uint32(env, asyncContext->totalBytesWritten, &valueParam); + napi_get_undefined(env, &valueParam); } if (!asyncContext->status) { - napi_get_undefined(env, &result[PARAM0]); - result[PARAM1] = valueParam; + napi_get_undefined(env, &result[PARAM0]); + result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -623,17 +671,23 @@ void AudioRendererNapi::PauseAsyncCallbackComplete(napi_env env, napi_status sta if (asyncContext != nullptr) { if (!asyncContext->status) { + // set pause result to doNotScheduleWrite_ asyncContext->objectInfo->doNotScheduleWrite_ = asyncContext->isTrue; napi_get_undefined(env, &valueParam); } if (!asyncContext->status) { - napi_get_undefined(env, &result[PARAM0]); - result[PARAM1] = valueParam; + napi_get_undefined(env, &result[PARAM0]); + result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -681,12 +735,17 @@ void AudioRendererNapi::StartAsyncCallbackComplete(napi_env env, napi_status sta napi_get_undefined(env, &valueParam); } if (!asyncContext->status) { - napi_get_undefined(env, &result[PARAM0]); - result[PARAM1] = valueParam; + napi_get_undefined(env, &result[PARAM0]); + result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -731,17 +790,23 @@ void AudioRendererNapi::StopAsyncCallbackComplete(napi_env env, napi_status stat if (asyncContext != nullptr) { if (!asyncContext->status) { + // set pause result to doNotScheduleWrite_ asyncContext->objectInfo->doNotScheduleWrite_ = asyncContext->isTrue; napi_get_undefined(env, &valueParam); } if (!asyncContext->status) { - napi_get_undefined(env, &result[PARAM0]); - result[PARAM1] = valueParam; + napi_get_undefined(env, &result[PARAM0]); + result[PARAM1] = valueParam; } else { napi_value message = nullptr; - napi_create_string_utf8(env, "Error, Operation not supported or Failed", NAPI_AUTO_LENGTH, &message); - napi_create_error(env, nullptr, message, &result[PARAM0]); + std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -826,6 +891,21 @@ void AudioRendererNapi::GetBufferSizeAsyncCallbackComplete(napi_env env, napi_st } } +void AudioRendererNapi::GetAudioStreamIdCallbackComplete(napi_env env, napi_status status, void *data) +{ + auto asyncContext = static_cast(data); + napi_value valueParam = nullptr; + + if (asyncContext != nullptr) { + if (!asyncContext->status) { + napi_create_uint32(env, asyncContext->audioStreamId, &valueParam); + } + CommonCallbackRoutine(env, asyncContext, valueParam); + } else { + HiLog::Error(LABEL, "ERROR::GetAudioStreamIdCallbackComplete* is Null!"); + } +} + void AudioRendererNapi::GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data) { auto asyncContext = static_cast(data); @@ -924,9 +1004,11 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); - unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { for (size_t i = PARAM0; i < argc; i++) { @@ -935,11 +1017,13 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[PARAM0], &asyncContext->audioRendererRate); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -956,9 +1040,19 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - AudioRendererRate audioRenderRate = static_cast(context->audioRendererRate); - context->intValue = context->objectInfo->audioRenderer_->SetRenderRate(audioRenderRate); - context->status = SUCCESS; + if (context->status == SUCCESS) { + AudioRendererRate audioRenderRate = static_cast(context->audioRendererRate); + int32_t AUDIO_CLIENT_INVALID_PARAMS_ERR = -2; + context->intValue = context->objectInfo->audioRenderer_->SetRenderRate(audioRenderRate); + if (context->intValue == SUCCESS) { + context->status = SUCCESS; + } else if (context->intValue == AUDIO_CLIENT_INVALID_PARAMS_ERR){ + context->status = ERR_NUMBER104; + } else { + context->status = ERR_NUMBER301; + } + } + }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -987,15 +1081,11 @@ napi_value AudioRendererNapi::GetRenderRate(napi_env env, napi_callback_info inf unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1043,15 +1133,11 @@ napi_value AudioRendererNapi::Start(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1069,7 +1155,7 @@ napi_value AudioRendererNapi::Start(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Start(); - context->status = SUCCESS; + context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; }, StartAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1094,10 +1180,11 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameters minimum"); - unique_ptr asyncContext = make_unique(); - + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { for (size_t i = PARAM0; i < argc; i++) { @@ -1106,11 +1193,13 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) if ((i == PARAM0) && (valueType == napi_object)) { napi_get_arraybuffer_info(env, argv[i], &asyncContext->data, &asyncContext->bufferLen); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1127,34 +1216,36 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERROR; - size_t bufferLen = context->bufferLen; - auto buffer = std::make_unique(bufferLen); - if (buffer == nullptr) { - HiLog::Error(LABEL, "Renderer write buffer allocation failed"); - return; - } + if (context->status == SUCCESS) { + context->status = ERR_NUMBER301; + size_t bufferLen = context->bufferLen; + auto buffer = std::make_unique(bufferLen); + if (buffer == nullptr) { + HiLog::Error(LABEL, "Renderer write buffer allocation failed"); + return; + } - if (memcpy_s(buffer.get(), bufferLen, context->data, bufferLen)) { - HiLog::Info(LABEL, "Renderer mem copy failed"); - return; - } + if (memcpy_s(buffer.get(), bufferLen, context->data, bufferLen)) { + HiLog::Info(LABEL, "Renderer mem copy failed"); + return; + } - int32_t bytesWritten = 0; - size_t totalBytesWritten = 0; - size_t minBytes = 4; - while ((totalBytesWritten < bufferLen) && ((bufferLen - totalBytesWritten) > minBytes)) { - bytesWritten = context->objectInfo->audioRenderer_->Write(buffer.get() + totalBytesWritten, - bufferLen - totalBytesWritten); - if (bytesWritten < 0) { - break; + int32_t bytesWritten = 0; + size_t totalBytesWritten = 0; + size_t minBytes = 4; + while ((totalBytesWritten < bufferLen) && ((bufferLen - totalBytesWritten) > minBytes)) { + bytesWritten = context->objectInfo->audioRenderer_->Write(buffer.get() + totalBytesWritten, + bufferLen - totalBytesWritten); + if (bytesWritten < 0) { + break; + } + + totalBytesWritten += bytesWritten; } - totalBytesWritten += bytesWritten; + context->status = SUCCESS; + context->totalBytesWritten = totalBytesWritten; } - - context->status = SUCCESS; - context->totalBytesWritten = totalBytesWritten; }, WriteAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1188,15 +1279,11 @@ napi_value AudioRendererNapi::GetAudioTime(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1213,12 +1300,13 @@ napi_value AudioRendererNapi::GetAudioTime(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERROR; Timestamp timestamp; if (context->objectInfo->audioRenderer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC)) { const uint64_t secToNanosecond = 1000000000; context->time = timestamp.time.tv_nsec + timestamp.time.tv_sec * secToNanosecond; context->status = SUCCESS; + } else { + context->status = ERR_NUMBER301; } }, GetInt64ValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1249,15 +1337,11 @@ napi_value AudioRendererNapi::Drain(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1275,7 +1359,7 @@ napi_value AudioRendererNapi::Drain(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Drain(); - context->status = SUCCESS; + context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1313,15 +1397,11 @@ napi_value AudioRendererNapi::Pause(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1339,7 +1419,7 @@ napi_value AudioRendererNapi::Pause(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Pause(); - context->status = SUCCESS; + context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; }, PauseAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1370,15 +1450,11 @@ napi_value AudioRendererNapi::Stop(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1396,7 +1472,7 @@ napi_value AudioRendererNapi::Stop(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Stop(); - context->status = SUCCESS; + context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; }, StopAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1426,15 +1502,11 @@ napi_value AudioRendererNapi::Release(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1455,7 +1527,7 @@ napi_value AudioRendererNapi::Release(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERROR; + context->status = ERR_NUMBER301; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1486,15 +1558,11 @@ napi_value AudioRendererNapi::GetBufferSize(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1533,9 +1601,8 @@ napi_value AudioRendererNapi::GetBufferSize(napi_env env, napi_callback_info inf return result; } -napi_value AudioRendererNapi::GetRendererInfo(napi_env env, napi_callback_info info) +napi_value AudioRendererNapi::GetAudioStreamId(napi_env env, napi_callback_info info) { - HiLog::Info(LABEL, "Entered GetRendererInfo"); napi_status status; const int32_t refCount = 1; napi_value result = nullptr; @@ -1544,17 +1611,152 @@ napi_value AudioRendererNapi::GetRendererInfo(napi_env env, napi_callback_info i unique_ptr asyncContext = make_unique(); + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc > PARAM0) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "GetAudioStreamId", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + size_t audioStreamId; + int32_t streamIdStatus; + streamIdStatus = context->objectInfo->audioRenderer_->GetAudioStreamId(audioStreamId); + if (streamIdStatus == ERR_ILLEGAL_STATE) { + context->status = ERR_NUMBER103; + } else if (streamIdStatus == ERR_INVALID_INDEX) { + context->status = ERR_NUMBER301; + } else { + context->status = SUCCESS; + } + context->audioStreamId = audioStreamId; + }, + GetAudioStreamIdCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + +napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) +{ + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_THREE); + + unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + if (i == PARAM0 && valueType == napi_number) { + AudioRendererInfo rendererInfo = {}; + int32_t rendererInfoStatus; + rendererInfoStatus = asyncContext->objectInfo->audioRenderer_->GetRendererInfo(rendererInfo); + if (rendererInfoStatus == SUCCESS) { + asyncContext->volType = asyncContext->objectInfo->audioMngr_->GetStreamType(rendererInfo.contentType, rendererInfo.streamUsage); + } else { + asyncContext->status = ERR_NUMBER301; + } + napi_get_value_int32(env, argv[i], &asyncContext->volLevel); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; + } + } + + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(env, &asyncContext->deferred, &result); + } else { + napi_get_undefined(env, &result); + } + + napi_value resource = nullptr; + napi_create_string_utf8(env, "SetVolume", NAPI_AUTO_LENGTH, &resource); + + status = napi_create_async_work( + env, nullptr, resource, + [](napi_env env, void *data) { + auto context = static_cast(data); + if (context->status == SUCCESS) { + if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(context->volLevel)){ + context->status = ERR_NUMBER101; + } else { + context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), + context->volLevel); + } + } + }, + SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); + if (status != napi_ok) { + result = nullptr; + } else { + status = napi_queue_async_work(env, asyncContext->work); + if (status == napi_ok) { + asyncContext.release(); + } else { + result = nullptr; + } + } + } + + return result; +} + + +napi_value AudioRendererNapi::GetRendererInfo(napi_env env, napi_callback_info info) +{ + HiLog::Info(LABEL, "Entered GetRendererInfo"); + napi_status status; + const int32_t refCount = 1; + napi_value result = nullptr; + + GET_PARAMS(env, info, ARGS_ONE); + + unique_ptr asyncContext = make_unique(); + + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); + if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc > PARAM0) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1607,15 +1809,11 @@ napi_value AudioRendererNapi::GetStreamInfo(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -1694,20 +1892,22 @@ napi_value AudioRendererNapi::RegisterPeriodPositionCallback(napi_env env, napi_ if (frameCount > 0) { if (rendererNapi->periodPositionCBNapi_ == nullptr) { rendererNapi->periodPositionCBNapi_ = std::make_shared(env); - NAPI_ASSERT(env, rendererNapi->periodPositionCBNapi_ != nullptr, "AudioRendererNapi: No memory."); + THROW_ERROR_ASSERT(env, rendererNapi->periodPositionCBNapi_ != nullptr, ERR_NUMBER102); int32_t ret = rendererNapi->audioRenderer_->SetRendererPeriodPositionCallback(frameCount, rendererNapi->periodPositionCBNapi_); - NAPI_ASSERT(env, ret == SUCCESS, "AudioRendererNapi: SetRendererPositionCallback failed."); + THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->periodPositionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_DEBUG_LOG("AudioRendererNapi: periodReach already subscribed."); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); } } else { AUDIO_ERR_LOG("AudioRendererNapi: frameCount value not supported!!"); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); } napi_value result = nullptr; @@ -1723,16 +1923,17 @@ napi_value AudioRendererNapi::RegisterPositionCallback(napi_env env, napi_value* if (markPosition > 0) { rendererNapi->positionCBNapi_ = std::make_shared(env); - NAPI_ASSERT(env, rendererNapi->positionCBNapi_ != nullptr, "AudioRendererNapi: No memory."); + THROW_ERROR_ASSERT(env, rendererNapi->positionCBNapi_ != nullptr, ERR_NUMBER102); int32_t ret = rendererNapi->audioRenderer_->SetRendererPositionCallback(markPosition, rendererNapi->positionCBNapi_); - NAPI_ASSERT(env, ret == SUCCESS, "AudioRendererNapi: SetRendererPositionCallback failed."); + THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->positionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_ERR_LOG("AudioRendererNapi: Mark Position value not supported!!"); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); } napi_value result = nullptr; @@ -1743,7 +1944,7 @@ napi_value AudioRendererNapi::RegisterPositionCallback(napi_env env, napi_value* napi_value AudioRendererNapi::RegisterRendererCallback(napi_env env, napi_value* argv, const std::string& cbName, AudioRendererNapi *rendererNapi) { - NAPI_ASSERT(env, rendererNapi->callbackNapi_ != nullptr, "AudioRendererNapi: callbackNapi_ is nullptr"); + THROW_ERROR_ASSERT(env, rendererNapi->callbackNapi_ != nullptr, ERR_NUMBER102); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->callbackNapi_); @@ -1760,14 +1961,15 @@ napi_value AudioRendererNapi::RegisterDataRequestCallback(napi_env env, napi_val if (rendererNapi->dataRequestCBNapi_ == nullptr) { rendererNapi->dataRequestCBNapi_ = std::make_shared(env, rendererNapi); rendererNapi->audioRenderer_->SetRenderMode(RENDER_MODE_CALLBACK); - NAPI_ASSERT(env, rendererNapi->dataRequestCBNapi_ != nullptr, "AudioRendererNapi: No memory."); + THROW_ERROR_ASSERT(env, rendererNapi->dataRequestCBNapi_ != nullptr, ERR_NUMBER102); int32_t ret = rendererNapi->audioRenderer_->SetRendererWriteCallback(rendererNapi->dataRequestCBNapi_); - NAPI_ASSERT(env, ret == SUCCESS, "AudioRendererNapi:SetRendererWriteCallback failed."); + THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->dataRequestCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM1]); } else { AUDIO_DEBUG_LOG("AudioRendererNapi:dataRequest already subscribed."); + THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); } napi_value result = nullptr; napi_get_undefined(env, &result); @@ -1779,13 +1981,15 @@ napi_value AudioRendererNapi::RegisterCallback(napi_env env, napi_value jsThis, { AudioRendererNapi *rendererNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&rendererNapi)); - NAPI_ASSERT(env, status == napi_ok && rendererNapi != nullptr, "Failed to retrieve audio renderer napi instance."); - NAPI_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, "Audio renderer instance is null."); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, rendererNapi != nullptr, ERR_NUMBER102); + + THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, ERR_NUMBER102); napi_value result = nullptr; napi_get_undefined(env, &result); - if (!cbName.compare(INTERRUPT_CALLBACK_NAME) || !cbName.compare(STATE_CHANGE_CALLBACK_NAME)) { + if (!cbName.compare(INTERRUPT_CALLBACK_NAME) || !cbName.compare(AUDIO_INTERRUPT_CALLBACK_NAME) || !cbName.compare(STATE_CHANGE_CALLBACK_NAME)) { result = RegisterRendererCallback(env, argv, cbName, rendererNapi); } else if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { result = RegisterPositionCallback(env, argv, cbName, rendererNapi); @@ -1795,7 +1999,7 @@ napi_value AudioRendererNapi::RegisterCallback(napi_env env, napi_value jsThis, result = RegisterDataRequestCallback(env, argv, cbName, rendererNapi); } else { bool unknownCallback = true; - NAPI_ASSERT(env, !unknownCallback, "No such on callback supported"); + THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER_101); } return result; @@ -1809,11 +2013,12 @@ napi_value AudioRendererNapi::On(napi_env env, napi_callback_info info) napi_value argv[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - NAPI_ASSERT(env, status == napi_ok && argc >= requireArgc, "AudioRendererNapi: On: requires min 2 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER_401); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioRendererNapi:On: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioRendererNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -1821,21 +2026,16 @@ napi_value AudioRendererNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; if (argc == requireArgc) { napi_typeof(env, argv[1], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); } else { napi_valuetype paramArg1 = napi_undefined; napi_typeof(env, argv[1], ¶mArg1); napi_valuetype expectedValType = napi_number; // Default. Reset it with 'callbackName' if check, if required. - if (paramArg1 != expectedValType) { - AUDIO_ERR_LOG("Type mismatch for param 2!!"); - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; - } + THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, ERR_NUMBER_401); const int32_t arg2 = 2; napi_typeof(env, argv[arg2], &handler); - NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 3"); + THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); } return RegisterCallback(env, jsThis, argv, callbackName); @@ -1845,8 +2045,9 @@ napi_value AudioRendererNapi::UnregisterCallback(napi_env env, napi_value jsThis { AudioRendererNapi *rendererNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&rendererNapi)); - NAPI_ASSERT(env, status == napi_ok && rendererNapi != nullptr, "Failed to retrieve audio renderer napi instance."); - NAPI_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, "Audio renderer instance is null."); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, rendererNapi != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, ERR_NUMBER102); if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { rendererNapi->audioRenderer_->UnsetRendererPositionCallback(); @@ -1856,7 +2057,7 @@ napi_value AudioRendererNapi::UnregisterCallback(napi_env env, napi_value jsThis rendererNapi->periodPositionCBNapi_ = nullptr; } else { bool unknownCallback = true; - NAPI_ASSERT(env, !unknownCallback, "No such off callback supported"); + THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER104); } napi_value result = nullptr; @@ -1872,11 +2073,13 @@ napi_value AudioRendererNapi::Off(napi_env env, napi_callback_info info) napi_value argv[requireArgc] = {nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - NAPI_ASSERT(env, status == napi_ok && argc >= requireArgc, "AudioRendererNapi: Off: requires min 1 parameters"); + THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER101); + napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - NAPI_ASSERT(env, eventType == napi_string, "AudioRendererNapi:Off: type mismatch for event name, parameter 1"); + THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER101); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioRendererNapi: Off callbackName: %{public}s", callbackName.c_str()); @@ -1981,9 +2184,12 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioRendererAsyncContext object creation failed"); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -1993,11 +2199,13 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->interruptMode); - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -2014,10 +2222,12 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - AudioStandard::InterruptMode interruptMode_ = GetNativeInterruptMode(context->interruptMode); - context->objectInfo->audioRenderer_->SetInterruptMode(interruptMode_); - context->status = SUCCESS; - context->intValue = SUCCESS; + if (context->status == SUCCESS) { + AudioStandard::InterruptMode interruptMode_ = GetNativeInterruptMode(context->interruptMode); + context->objectInfo->audioRenderer_->SetInterruptMode(interruptMode_); + context->status = SUCCESS; + context->intValue = SUCCESS; + } }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { diff --git a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp index 12294f6032..bfa067428e 100644 --- a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp +++ b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp @@ -161,7 +161,7 @@ napi_value TonePlayerNapi::CreateTonePlayerWrapper(napi_env env, unique_ptrstatus); + napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message); + + napi_value code = nullptr; + napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code); + + napi_create_error(env, code, message, &result[PARAM0]); napi_get_undefined(env, &result[PARAM1]); } @@ -222,9 +227,12 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf bool inputRight = true; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires one parameters minimum"); unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "TonePlayerAsyncContext object creation failed"); for (size_t i = PARAM0; i < argc; i++) { @@ -235,8 +243,10 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf HiLog::Error(LABEL, "Parsing of renderer options failed"); inputRight = false; } - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], REFERENCE_CREATION_COUNT, &asyncContext->callbackRef); + } break; } else { HiLog::Error(LABEL, "type mismatch"); @@ -258,7 +268,7 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_INVALID_PARAM; + context->status = ERR_NUMBER101; HiLog::Error(LABEL, "CreateTonePlayer fail, invalid param!"); }, GetTonePlayerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -266,8 +276,6 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - context->status = SUCCESS; }, GetTonePlayerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); } @@ -358,9 +366,12 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) bool inputRight = true; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } + status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { for (size_t i = PARAM0; i < argc; i++) { @@ -373,8 +384,10 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) HiLog::Error(LABEL, "The Load parameter is invalid"); inputRight = false; } - } else if (i == PARAM1 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } else if (i == PARAM1) { + if (valueType == napi_function) { + napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); + } break; } else { HiLog::Error(LABEL, "type mismatch"); @@ -396,8 +409,8 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); + context->status = ERR_NUMBER101; HiLog::Error(LABEL, "The Load parameter is invalid"); - context->status = ERR_INVALID_PARAM; }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); } else { @@ -405,9 +418,15 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - ToneType toneType = static_cast(context->toneType); - context->intValue = context->objectInfo->tonePlayer_->LoadTone(toneType); - context->status = SUCCESS; + if (context->status == SUCCESS) { + ToneType toneType = static_cast(context->toneType); + context->intValue = context->objectInfo->tonePlayer_->LoadTone(toneType); + if (context->intValue) { + context->status = SUCCESS; + } else { + context->status = ERR_NUMBER301; + } + } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); } @@ -437,15 +456,11 @@ napi_value TonePlayerNapi::Start(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -467,7 +482,7 @@ napi_value TonePlayerNapi::Start(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Start call failed, wrong timing!"); - context->status = ERR_INVALID_PARAM; + context->status = ERR_NUMBER301; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -497,15 +512,11 @@ napi_value TonePlayerNapi::Stop(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -527,7 +538,7 @@ napi_value TonePlayerNapi::Stop(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Stop call failed, wrong timing"); - context->status = ERR_INVALID_PARAM; + context->status = ERR_NUMBER301; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -557,15 +568,11 @@ napi_value TonePlayerNapi::Release(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { + if (argc > PARAM0) { napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[i], &valueType); - - if (i == PARAM0 && valueType == napi_function) { - napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - break; - } else { - NAPI_ASSERT(env, false, "type mismatch"); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); } } @@ -587,7 +594,7 @@ napi_value TonePlayerNapi::Release(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Release call failed, wrong timing"); - context->status = ERR_INVALID_PARAM; + context->status = ERR_NUMBER301; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); diff --git a/frameworks/native/audiocapturer/include/audio_capturer_private.h b/frameworks/native/audiocapturer/include/audio_capturer_private.h index e176bd36bb..954c669b26 100644 --- a/frameworks/native/audiocapturer/include/audio_capturer_private.h +++ b/frameworks/native/audiocapturer/include/audio_capturer_private.h @@ -38,6 +38,7 @@ public: bool Flush() const override; bool Release() const override; int32_t GetBufferSize(size_t &bufferSize) const override; + int32_t GetAudioStreamId(uint32_t &sessionID) const override; int32_t SetCapturerPositionCallback(int64_t markPosition, const std::shared_ptr &callback) override; void UnsetCapturerPositionCallback() override; diff --git a/frameworks/native/audiocapturer/src/audio_capturer.cpp b/frameworks/native/audiocapturer/src/audio_capturer.cpp index eb2e4b84ee..36837d6531 100644 --- a/frameworks/native/audiocapturer/src/audio_capturer.cpp +++ b/frameworks/native/audiocapturer/src/audio_capturer.cpp @@ -320,6 +320,11 @@ int32_t AudioCapturerPrivate::GetBufferSize(size_t &bufferSize) const return audioStream_->GetBufferSize(bufferSize); } +int32_t AudioCapturerPrivate::GetAudioStreamId(uint32_t &sessionID) const +{ + return audioStream_->GetAudioSessionID(sessionID); +} + int32_t AudioCapturerPrivate::SetBufferDuration(uint64_t bufferDuration) const { if (bufferDuration < MINIMUM_BUFFER_SIZE_MSEC || bufferDuration > MAXIMUM_BUFFER_SIZE_MSEC) { diff --git a/frameworks/native/audiorenderer/include/audio_renderer_private.h b/frameworks/native/audiorenderer/include/audio_renderer_private.h index ad5d7cad83..b492fdb25f 100644 --- a/frameworks/native/audiorenderer/include/audio_renderer_private.h +++ b/frameworks/native/audiorenderer/include/audio_renderer_private.h @@ -43,6 +43,7 @@ public: bool Flush() const override; bool Release() const override; int32_t GetBufferSize(size_t &bufferSize) const override; + int32_t GetAudioStreamId(uint32_t &sessionID) const override; int32_t SetAudioRendererDesc(AudioRendererDesc audioRendererDesc) const override; int32_t SetStreamType(AudioStreamType audioStreamType) const override; int32_t SetVolume(float volume) const override; diff --git a/frameworks/native/audiorenderer/src/audio_renderer.cpp b/frameworks/native/audiorenderer/src/audio_renderer.cpp index 49456c61aa..7b77ae163c 100644 --- a/frameworks/native/audiorenderer/src/audio_renderer.cpp +++ b/frameworks/native/audiorenderer/src/audio_renderer.cpp @@ -448,6 +448,11 @@ int32_t AudioRendererPrivate::GetBufferSize(size_t &bufferSize) const return audioStream_->GetBufferSize(bufferSize); } +int32_t AudioRendererPrivate::GetAudioStreamId(uint32_t &sessionID) const +{ + return audioStream_->GetAudioSessionID(sessionID); +} + int32_t AudioRendererPrivate::SetAudioRendererDesc(AudioRendererDesc audioRendererDesc) const { ContentType contentType = audioRendererDesc.contentType; diff --git a/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h b/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h index ecc1005aef..3c53cf6cdd 100644 --- a/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h +++ b/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h @@ -284,6 +284,16 @@ public: */ virtual int32_t GetBufferSize(size_t &bufferSize) const = 0; + /** + * @brief Obtains the capturer stream id. + * + * @param sessionId Indicates the reference variable into which stream id value will be written. + * @return Returns {@link SUCCESS} if stream id is successfully obtained; returns an error code + * defined in {@link audio_errors.h} otherwise. + */ + virtual int32_t GetAudioStreamId(uint32_t &sessionID) const = 0; + + /* @brief Obtains the number of frames required in the current condition, in bytes per sample. * * @param frameCount Indicates the pointer in which framecount will be written diff --git a/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h b/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h index b8ffe2d7a1..8f26850498 100644 --- a/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h +++ b/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h @@ -315,6 +315,15 @@ public: */ virtual int32_t GetBufferSize(size_t &bufferSize) const = 0; + /** + * @brief Obtains the renderer stream id. + * + * @param sessionId Indicates the reference variable into which stream id value will be written. + * @return Returns {@link SUCCESS} if stream id is successfully obtained; returns an error code + * defined in {@link audio_errors.h} otherwise. + */ + virtual int32_t GetAudioStreamId(uint32_t &sessionID) const = 0; + /** * @brief Obtains the number of frames required in the current condition, in bytes per sample. * 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 8d9a861079..9f1ac790ea 100644 --- a/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h +++ b/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h @@ -55,6 +55,7 @@ private: uint8_t *buffer = nullptr; size_t bytesRead; size_t bufferSize; + uint32_t audioStreamId; bool isBlocking; bool isTrue; AudioSampleFormat audioSampleFormat; @@ -82,6 +83,7 @@ private: 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 GetAudioStreamId(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); @@ -96,6 +98,7 @@ private: static void ReadAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void GetBufferSizeAsyncCallbackComplete(napi_env env, napi_status status, void *data); + static void GetAudioStreamIdCallbackComplete(napi_env env, napi_status status, void *data); static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void GetInt64ValueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void VoidAsyncCallbackComplete(napi_env env, napi_status status, void *data); 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 210d85c273..7f8da94c49 100644 --- a/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h +++ b/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h @@ -21,6 +21,8 @@ #include #include "audio_renderer.h" +#include "audio_errors.h" +#include "audio_system_manager.h" #include "napi/native_api.h" #include "napi/native_node_api.h" @@ -55,7 +57,7 @@ private: napi_async_work work; napi_deferred deferred; napi_ref callbackRef = nullptr; - int32_t status; + int32_t status = SUCCESS; int32_t intValue; int32_t audioRendererRate; int32_t rendererFlags; @@ -64,6 +66,9 @@ private: uint64_t time; size_t bufferLen; size_t bufferSize; + int32_t volType; + int32_t volLevel; + uint32_t audioStreamId; size_t totalBytesWritten; void *data; AudioSampleFormat sampleFormat; @@ -91,6 +96,8 @@ private: 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 GetAudioStreamId(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 GetStreamInfo(napi_env env, napi_callback_info info); @@ -109,6 +116,7 @@ private: static void AudioParamsAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void GetBufferSizeAsyncCallbackComplete(napi_env env, napi_status status, void *data); + static void GetAudioStreamIdCallbackComplete(napi_env env, napi_status status, void *data); static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void GetInt64ValueAsyncCallbackComplete(napi_env env, napi_status status, void *data); static void WriteAsyncCallbackComplete(napi_env env, napi_status status, void *data); @@ -165,6 +173,7 @@ private: std::shared_ptr positionCBNapi_ = nullptr; std::shared_ptr periodPositionCBNapi_ = nullptr; std::shared_ptr dataRequestCBNapi_ = nullptr; + AudioSystemManager *audioMngr_; }; static const std::map interruptEventTypeMap = { diff --git a/services/audio_policy/client/include/audio_policy_manager_stub.h b/services/audio_policy/client/include/audio_policy_manager_stub.h index 4d4df232e9..a59d02590f 100644 --- a/services/audio_policy/client/include/audio_policy_manager_stub.h +++ b/services/audio_policy/client/include/audio_policy_manager_stub.h @@ -28,7 +28,7 @@ public: private: void SetStreamVolumeInternal(MessageParcel &data, MessageParcel &reply); void SetRingerModeInternal(MessageParcel &data, MessageParcel &reply); - void GetToneInfoInternal(MessageParcel &data, MessageParcel &reply); + // void GetToneInfoInternal(MessageParcel &data, MessageParcel &reply); void GetSupportedTonesInternal(MessageParcel &data, MessageParcel &reply); void GetRingerModeInternal(MessageParcel &data); void SetAudioSceneInternal(MessageParcel &data, MessageParcel &reply); -- Gitee From 7eaa5d7d35b2392be63ed7586098e50a7bad532e Mon Sep 17 00:00:00 2001 From: liyuhang Date: Thu, 20 Oct 2022 15:08:21 +0800 Subject: [PATCH 3/5] Added new elements for stream info Signed-off-by: liyuhang Change-Id: I626a74c9803882d4572e03edfd628f0011a2f477 --- .../src/audio_capturer_napi.cpp | 18 ++++++++ .../audio_common/src/audio_common_napi.cpp | 3 -- .../src/audio_renderer_napi.cpp | 18 ++++++++ .../native/audiocommon/include/audio_info.h | 46 +++++++++++-------- .../include/audio_capturer_napi.h | 2 + .../include/audio_renderer_napi.h | 2 + .../include/audio_policy_manager_stub.h | 2 +- 7 files changed, 69 insertions(+), 22 deletions(-) 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 43f9584756..978b8c99da 100644 --- a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp +++ b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp @@ -193,6 +193,8 @@ napi_value AudioCapturerNapi::Construct(napi_env env, napi_callback_info info) capturerOptions.streamInfo.encoding = sCapturerOptions_->streamInfo.encoding; capturerOptions.streamInfo.format = sCapturerOptions_->streamInfo.format; capturerOptions.streamInfo.channels = sCapturerOptions_->streamInfo.channels; + capturerOptions.streamInfo.channelOut = sCapturerOptions_->streamInfo.channelOut; + capturerOptions.streamInfo.channelIn = sCapturerOptions_->streamInfo.channelIn; capturerOptions.capturerInfo.sourceType = sCapturerOptions_->capturerInfo.sourceType; capturerOptions.capturerInfo.capturerFlags = sCapturerOptions_->capturerInfo.capturerFlags; @@ -356,6 +358,8 @@ void AudioCapturerNapi::GetCapturerAsyncCallbackComplete(napi_env env, napi_stat capturerOptions->streamInfo.encoding = asyncContext->capturerOptions.streamInfo.encoding; capturerOptions->streamInfo.format = asyncContext->capturerOptions.streamInfo.format; capturerOptions->streamInfo.channels = asyncContext->capturerOptions.streamInfo.channels; + capturerOptions->streamInfo.channelOut = asyncContext->capturerOptions.streamInfo.channelOut; + capturerOptions->streamInfo.channelIn = asyncContext->capturerOptions.streamInfo.channelIn; capturerOptions->capturerInfo.sourceType = asyncContext->capturerOptions.capturerInfo.sourceType; capturerOptions->capturerInfo.capturerFlags = asyncContext->capturerOptions.capturerInfo.capturerFlags; @@ -420,6 +424,8 @@ void AudioCapturerNapi::AudioStreamInfoAsyncCallbackComplete(napi_env env, napi_ (void)napi_create_object(env, &valueParam); SetValueInt32(env, "samplingRate", static_cast(asyncContext->samplingRate), valueParam); SetValueInt32(env, "channels", static_cast(asyncContext->audioChannel), valueParam); + SetValueInt32(env, "channelOut", static_cast(asyncContext->audioChannelOut), valueParam); + SetValueInt32(env, "channelIn", static_cast(asyncContext->audioChannelIn), valueParam); SetValueInt32(env, "sampleFormat", static_cast(asyncContext->audioSampleFormat), valueParam); SetValueInt32(env, "encodingType", static_cast(asyncContext->audioEncoding), valueParam); } @@ -635,6 +641,8 @@ napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info inf context->audioSampleFormat = static_cast(streamInfo.format); context->samplingRate = streamInfo.samplingRate; context->audioChannel = streamInfo.channels; + context->audioChannelOut = streamInfo.channelOut; + context->audioChannelIn = streamInfo.channelIn; context->audioEncoding = streamInfo.encoding; } }, @@ -1369,6 +1377,16 @@ bool AudioCapturerNapi::ParseStreamInfo(napi_env env, napi_value root, AudioStre streamInfo->channels = static_cast(intValue); } + if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + streamInfo->channelOut = static_cast(intValue); + } + + if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + streamInfo->channelIn = static_cast(intValue); + } + if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); streamInfo->format = static_cast(intValue); 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 9eeca53c86..2275baabd8 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -127,10 +127,8 @@ bool AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceF { bool result = false; switch (activeDeviceFlag) { - case ActiveDeviceType::SPEAKER: case ActiveDeviceType::BLUETOOTH_SCO: - result = true; break; default: @@ -144,7 +142,6 @@ bool AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(int32_t commun { bool result = false; switch (communicationDeviceType) { - case CommunicationDeviceType::COMMUNICATION_SPEAKER: result = true; break; 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 1963464be2..55ac51f350 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp @@ -465,6 +465,8 @@ napi_value AudioRendererNapi::Construct(napi_env env, napi_callback_info info) rendererOptions.streamInfo.encoding = sRendererOptions_->streamInfo.encoding; rendererOptions.streamInfo.format = sRendererOptions_->streamInfo.format; rendererOptions.streamInfo.channels = sRendererOptions_->streamInfo.channels; + rendererOptions.streamInfo.channelOut = sRendererOptions_->streamInfo.channelOut; + rendererOptions.streamInfo.channelIn = sRendererOptions_->streamInfo.channelIn; rendererOptions.rendererInfo.contentType = sRendererOptions_->rendererInfo.contentType; rendererOptions.rendererInfo.streamUsage = sRendererOptions_->rendererInfo.streamUsage; @@ -933,6 +935,8 @@ void AudioRendererNapi::GetRendererAsyncCallbackComplete(napi_env env, napi_stat rendererOptions->streamInfo.encoding = asyncContext->rendererOptions.streamInfo.encoding; rendererOptions->streamInfo.format = asyncContext->rendererOptions.streamInfo.format; rendererOptions->streamInfo.channels = asyncContext->rendererOptions.streamInfo.channels; + rendererOptions->streamInfo.channelOut = asyncContext->rendererOptions.streamInfo.channelOut; + rendererOptions->streamInfo.channelIn = asyncContext->rendererOptions.streamInfo.channelIn; rendererOptions->rendererInfo.contentType = asyncContext->rendererOptions.rendererInfo.contentType; rendererOptions->rendererInfo.streamUsage = asyncContext->rendererOptions.rendererInfo.streamUsage; rendererOptions->rendererInfo.rendererFlags = asyncContext->rendererOptions.rendererInfo.rendererFlags; @@ -988,6 +992,8 @@ void AudioRendererNapi::AudioStreamInfoAsyncCallbackComplete(napi_env env, napi_ (void)napi_create_object(env, &valueParam); SetValueInt32(env, "samplingRate", static_cast(asyncContext->samplingRate), valueParam); SetValueInt32(env, "channels", static_cast(asyncContext->channelCount), valueParam); + SetValueInt32(env, "channelOut", static_cast(asyncContext->audioChannelOut), valueParam); + SetValueInt32(env, "channelIn", static_cast(asyncContext->audioChannelIn), valueParam); SetValueInt32(env, "sampleFormat", static_cast(asyncContext->sampleFormat), valueParam); SetValueInt32(env, "encodingType", static_cast(asyncContext->encodingType), valueParam); } @@ -1836,6 +1842,8 @@ napi_value AudioRendererNapi::GetStreamInfo(napi_env env, napi_callback_info inf context->sampleFormat = static_cast(streamInfo.format); context->samplingRate = streamInfo.samplingRate; context->channelCount = streamInfo.channels; + context->audioChannelOut = streamInfo.channelOut; + context->audioChannelIn = streamInfo.channelIn; context->encodingType = streamInfo.encoding; } }, @@ -2139,6 +2147,16 @@ bool AudioRendererNapi::ParseStreamInfo(napi_env env, napi_value root, AudioStre streamInfo->channels = static_cast(intValue); } + if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + streamInfo->channelOut = static_cast(intValue); + } + + if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { + napi_get_value_int32(env, tempValue, &intValue); + streamInfo->channelIn = static_cast(intValue); + } + if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); streamInfo->format = static_cast(intValue); diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index 935d7a1308..ba2bc34234 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -307,24 +307,6 @@ enum CommunicationDeviceType { COMMUNICATION_SPEAKER = 2 }; -enum AudioOutputChannelMask { - CHANNEL_OUT_FRONT_LEFT = 0x1 << 0, - CHANNEL_OUT_FRONT_RIGHT = 0x1 << 1, - CHANNEL_OUT_FRONT_CENTER = 0x1 << 2, - CHANNEL_OUT_LOW_FREQUENCY = 0x1 << 3, - CHANNEL_OUT_SIDE_LEFT = 0x1 << 4, - CHANNEL_OUT_SIDE_RIGHT = 0x1 << 5, - CHANNEL_OUT_BACK_LEFT = 0x1 << 6, - CHANNEL_OUT_BACK_RIGHT = 0x1 << 7 -}; - -enum AudioInputChannelMask { - CHANNEL_IN_LEFT = 0x1 << 0, - CHANNEL_IN_RIGHT = 0x1 << 1, - CHANNEL_IN_FRONT = 0x1 << 2, - CHANNEL_IN_BACK = 0x1 << 3 -}; - enum InterruptMode { SHARE_MODE = 0, INDEPENDENT_MODE = 1 @@ -364,6 +346,34 @@ enum AudioChannel { CHANNEL_8 = 8 }; + /** + * Enumerates the audio renderer channel mask. + * @since 9 + * @syscap SystemCapability.Multimedia.Audio.Core + */ + enum AudioOutputChannelMask { + CHANNEL_OUT_FRONT_LEFT = 0x1 << 0, + CHANNEL_OUT_FRONT_RIGHT = 0x1 << 1, + CHANNEL_OUT_FRONT_CENTER = 0x1 << 2, + CHANNEL_OUT_LOW_FREQUENCY = 0x1 << 3, + CHANNEL_OUT_SIDE_LEFT = 0x1 << 4, + CHANNEL_OUT_SIDE_RIGHT = 0x1 << 5, + CHANNEL_OUT_BACK_LEFT = 0x1 << 6, + CHANNEL_OUT_BACK_RIGHT = 0x1 << 7 + }; + + /** + * Enumerates the audio capturer channel mask. + * @since 9 + * @syscap SystemCapability.Multimedia.Audio.Core + */ + enum AudioInputChannelMask { + CHANNEL_IN_LEFT = 0x1 << 0, + CHANNEL_IN_RIGHT = 0x1 << 1, + CHANNEL_IN_FRONT = 0x1 << 2, + CHANNEL_IN_BACK = 0x1 << 3 + }; + // sampling rate enum AudioSamplingRate { SAMPLE_RATE_8000 = 8000, 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 9f1ac790ea..d35a0ddb4d 100644 --- a/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h +++ b/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h @@ -61,6 +61,8 @@ private: AudioSampleFormat audioSampleFormat; AudioSamplingRate samplingRate; AudioChannel audioChannel; + AudioOutputChannelMask audioChannelOut; + AudioInputChannelMask audioChannelIn; AudioEncodingType audioEncoding; ContentType contentType; StreamUsage usage; 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 7f8da94c49..97785949e3 100644 --- a/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h +++ b/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h @@ -74,6 +74,8 @@ private: AudioSampleFormat sampleFormat; AudioSamplingRate samplingRate; AudioChannel channelCount; + AudioOutputChannelMask audioChannelOut; + AudioInputChannelMask audioChannelIn; AudioEncodingType encodingType; ContentType contentType; StreamUsage usage; diff --git a/services/audio_policy/client/include/audio_policy_manager_stub.h b/services/audio_policy/client/include/audio_policy_manager_stub.h index a59d02590f..4d4df232e9 100644 --- a/services/audio_policy/client/include/audio_policy_manager_stub.h +++ b/services/audio_policy/client/include/audio_policy_manager_stub.h @@ -28,7 +28,7 @@ public: private: void SetStreamVolumeInternal(MessageParcel &data, MessageParcel &reply); void SetRingerModeInternal(MessageParcel &data, MessageParcel &reply); - // void GetToneInfoInternal(MessageParcel &data, MessageParcel &reply); + void GetToneInfoInternal(MessageParcel &data, MessageParcel &reply); void GetSupportedTonesInternal(MessageParcel &data, MessageParcel &reply); void GetRingerModeInternal(MessageParcel &data); void SetAudioSceneInternal(MessageParcel &data, MessageParcel &reply); -- Gitee From 13bf98ee1dfc555a516cd9e5b579c5f5868ecc43 Mon Sep 17 00:00:00 2001 From: wangtao Date: Thu, 20 Oct 2022 19:47:06 +0800 Subject: [PATCH 4/5] fix some Signed-off-by: wangtao Change-Id: I3aad054f63906034ef05590faeb68fc44e6848e6 Signed-off-by: liyuhang --- frameworks/js/napi/BUILD.gn | 10 +- .../src/audio_capturer_napi.cpp | 1 - .../audio_common/include/audio_common_napi.h | 3 + .../audio_common/src/audio_common_napi.cpp | 10 +- .../audio_micstatechange_callback_napi.h | 6 +- .../src/audio_interrupt_manager_napi.cpp | 2 - .../audio_manager/src/audio_manager_napi.cpp | 108 ++++++++++-------- .../src/audio_routing_manager_napi.cpp | 24 ++-- .../src/audio_stream_mgr_napi.cpp | 6 +- .../src/audio_volume_group_manager_napi.cpp | 56 +++++---- .../src/audio_volume_manager_napi.cpp | 7 +- .../src/audio_renderer_napi.cpp | 25 ++-- .../napi/toneplayer/src/toneplayer_napi.cpp | 2 +- .../native/audiocommon/include/audio_info.h | 53 ++++++--- .../include/audio_manager_napi.h | 13 ++- 15 files changed, 174 insertions(+), 152 deletions(-) diff --git a/frameworks/js/napi/BUILD.gn b/frameworks/js/napi/BUILD.gn index 0fe2435c65..9b2ec3384c 100644 --- a/frameworks/js/napi/BUILD.gn +++ b/frameworks/js/napi/BUILD.gn @@ -48,24 +48,24 @@ ohos_shared_library("audio") { "audio_capturer/src/capturer_position_callback_napi.cpp", "audio_common/src/audio_common_napi.cpp", "audio_manager/src/audio_capturer_state_callback_napi.cpp", - "audio_manager/src/audio_volume_group_manager_napi.cpp", + "audio_manager/src/audio_interrupt_manager_napi.cpp", "audio_manager/src/audio_manager_callback_napi.cpp", "audio_manager/src/audio_manager_interrupt_callback_napi.cpp", "audio_manager/src/audio_manager_napi.cpp", + "audio_manager/src/audio_micstatechange_callback_napi.cpp", "audio_manager/src/audio_renderer_state_callback_napi.cpp", "audio_manager/src/audio_ringermode_callback_napi.cpp", - "audio_manager/src/audio_micstatechange_callback_napi.cpp", "audio_manager/src/audio_routing_manager_napi.cpp", + "audio_manager/src/audio_stream_mgr_napi.cpp", + "audio_manager/src/audio_volume_group_manager_napi.cpp", "audio_manager/src/audio_volume_key_event_napi.cpp", + "audio_manager/src/audio_volume_manager_napi.cpp", "audio_renderer/src/audio_renderer_callback_napi.cpp", "audio_renderer/src/audio_renderer_napi.cpp", "audio_renderer/src/renderer_data_request_callback_napi.cpp", "audio_renderer/src/renderer_period_position_callback_napi.cpp", "audio_renderer/src/renderer_position_callback_napi.cpp", "toneplayer/src/toneplayer_napi.cpp", - "audio_manager/src/audio_volume_manager_napi.cpp", - "audio_manager/src/audio_interrupt_manager_napi.cpp", - "audio_manager/src/audio_stream_mgr_napi.cpp", ] deps = [ 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 978b8c99da..1cfc507689 100644 --- a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp +++ b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp @@ -719,7 +719,6 @@ napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info } } } - return result; } 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 19d38d3f21..5a83fc5aec 100644 --- a/frameworks/js/napi/audio_common/include/audio_common_napi.h +++ b/frameworks/js/napi/audio_common/include/audio_common_napi.h @@ -68,6 +68,9 @@ public: static bool IsLegalInputArgumentCommunicationDeviceType(int32_t deviceType); static bool IsLegalInputArgumentRingMode(int32_t ringerMode); static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType); +private: + static constexpr int32_t MAX_VOLUME_LEVEL = 15; + static constexpr int32_t MIN_VOLUME_LEVEL = 0; }; struct AutoRef { 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 2275baabd8..2dd78a7e18 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -39,7 +39,7 @@ std::string AudioCommonNapi::GetStringArgument(napi_env env, napi_value value) return strValue; } -std::string AudioCommonNapi::getMessageByCode(int32_t &code){ +std::string AudioCommonNapi::getMessageByCode(int32_t &code) { std::string err_message; switch (code) { case ERR_NUMBER101: @@ -59,7 +59,7 @@ std::string AudioCommonNapi::getMessageByCode(int32_t &code){ break; case ERR_NUMBER201: err_message = ERR_MESSAGE201; - break; + break; case ERR_NUMBER301: err_message = ERR_MESSAGE301; break; @@ -74,14 +74,14 @@ std::string AudioCommonNapi::getMessageByCode(int32_t &code){ return err_message; } -void AudioCommonNapi::throwError(napi_env env,int32_t code){ +void AudioCommonNapi::throwError(napi_env env, int32_t code) { std::string messageValue = AudioCommonNapi::getMessageByCode(code); napi_throw_error(env, (std::to_string(code)).c_str(), messageValue.c_str()); } bool AudioCommonNapi::IsLegalInputArgumentVolLevel(int32_t volLevel) { - return (volLevel < 0 || volLevel > 15) ? false : true; + return (volLevel < MIN_VOLUME_LEVEL || volLevel > MAX_VOLUME_LEVEL) ? false : true; } bool AudioCommonNapi::IsLegalInputArgumentVolType(int32_t inputType) @@ -142,7 +142,7 @@ bool AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(int32_t commun { bool result = false; switch (communicationDeviceType) { - case CommunicationDeviceType::COMMUNICATION_SPEAKER: + case CommunicationDeviceType::COMMUNICATION_SPEAKER: result = true; break; default: diff --git a/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h b/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h index dd11006813..3bbb69243c 100644 --- a/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h +++ b/frameworks/js/napi/audio_manager/include/audio_micstatechange_callback_napi.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef AUDIO_ROUTING_MANAGER_CALLBACK_NAPI_H -#define AUDIO_ROUTING_MANAGER_CALLBACK_NAPI_H +#ifndef AUDIO_MIC_STATE_CHANGE_MANAGER_CALLBACK_NAPI_H +#define AUDIO_MIC_STATE_CHANGE_MANAGER_CALLBACK_NAPI_H #include "audio_common_napi.h" #include "audio_routing_manager_napi.h" @@ -46,4 +46,4 @@ private: }; } // namespace AudioStandard } // namespace OHOS -#endif // AUDIO_MANAGER_CALLBACK_NAPI_H_ +#endif // AUDIO_MIC_STATE_CHANGE_MANAGER_CALLBACK_NAPI_H diff --git a/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp index df72b56b79..d1394f4f9a 100644 --- a/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp @@ -31,10 +31,8 @@ namespace AudioStandard { static __thread napi_ref g_interruptManagerConstructor = nullptr; namespace { - // const int ARGS_ONE = 1; const int ARGS_TWO = 2; const int PARAM0 = 0; - // const int PARAM1 = 1; constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioInterruptManagerNapi"}; } 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 b5f7db2676..74201450ef 100644 --- a/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp @@ -64,6 +64,8 @@ napi_ref AudioManagerNapi::audioErrors_ = nullptr; napi_ref AudioManagerNapi::communicationDeviceType_ = nullptr; napi_ref AudioManagerNapi::audioOutputChannelMask_ = nullptr; napi_ref AudioManagerNapi::audioInputChannelMask_ = nullptr; +napi_ref AudioManagerNapi::interruptRequestType_ = nullptr; +napi_ref AudioManagerNapi::interruptRequestResultType_ = nullptr; #define GET_PARAMS(env, info, num) \ @@ -161,13 +163,13 @@ static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType) static AudioStandard::FocusType GetNativeFocusType(int32_t focusType) { - AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_DEFAULT; + AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING; switch (focusType) { - case AudioManagerNapi::FocusType::FOCUS_TYPE_DEFAULT: - result = AudioStandard::FocusType::FOCUS_TYPE_DEFAULT; + case AudioManagerNapi::FocusType::FOCUS_TYPE_RECORDING: + result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING; break; default: - HiLog::Error(LABEL, "Unknown focusType type, Set it to default FOCUS_TYPE_DEFAULT!"); + HiLog::Error(LABEL, "Unknown focusType type, Set it to default FOCUS_TYPE_RECORDING!"); break; } @@ -781,10 +783,16 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_PROPERTY("DEFAULT_VOLUME_GROUP_ID", defaultVolumeGroupId), DECLARE_NAPI_PROPERTY("DEFAULT_INTERRUPT_GROUP_ID", defaultInterruptId), DECLARE_NAPI_PROPERTY("AudioErrors", CreatePropertyBase(env, audioErrorsMap, audioErrors_)), - DECLARE_NAPI_PROPERTY("CommunicationDeviceType", CreatePropertyBase(env, communicationDeviceTypeMap, communicationDeviceType_)), - DECLARE_NAPI_PROPERTY("AudioOutputChannelMask", CreatePropertyBase(env, audioOutputChannelMaskMap, audioOutputChannelMask_)), - DECLARE_NAPI_PROPERTY("AudioInputChannelMask", CreatePropertyBase(env, audioInputChannelMaskMap, audioInputChannelMask_)), - + DECLARE_NAPI_PROPERTY("CommunicationDeviceType", + CreatePropertyBase(env, communicationDeviceTypeMap, communicationDeviceType_)), + DECLARE_NAPI_PROPERTY("AudioOutputChannelMask", + CreatePropertyBase(env, audioOutputChannelMaskMap, audioOutputChannelMask_)), + DECLARE_NAPI_PROPERTY("AudioInputChannelMask", + CreatePropertyBase(env, audioInputChannelMaskMap, audioInputChannelMask_)), + DECLARE_NAPI_PROPERTY("InterruptRequestType", + CreatePropertyBase(env, interruptRequestTypeMap, interruptRequestType_)), + DECLARE_NAPI_PROPERTY("InterruptRequestResultType", + CreatePropertyBase(env, interruptRequestResultTypeMap, interruptRequestResultType_)), }; status = napi_define_class(env, AUDIO_MNGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -988,11 +996,13 @@ napi_value AudioManagerNapi::RequestIndependentInterrupt(napi_env env, napi_call napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -1005,7 +1015,7 @@ napi_value AudioManagerNapi::RequestIndependentInterrupt(napi_env env, napi_call } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1050,11 +1060,13 @@ napi_value AudioManagerNapi::AbandonIndependentInterrupt(napi_env env, napi_call napi_value result = nullptr; GET_PARAMS(env, info, ARGS_TWO); - NAPI_ASSERT(env, argc >= ARGS_ONE, "requires 1 parameter minimum"); unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { + if (argc < ARGS_ONE) { + asyncContext->status = ERR_NUMBER101; + } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -1066,7 +1078,7 @@ napi_value AudioManagerNapi::AbandonIndependentInterrupt(napi_env env, napi_call } break; } else { - NAPI_ASSERT(env, false, "type mismatch"); + asyncContext->status = ERR_NUMBER101; } } @@ -1243,7 +1255,7 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->ringMode); - if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)){ + if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -1428,7 +1440,7 @@ napi_value AudioManagerNapi::GetAudioScene(napi_env env, napi_callback_info info if (valueType == napi_function) { napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); - } + } } if (asyncContext->callbackRef == nullptr) { @@ -1477,7 +1489,7 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_TWO){ + if (argc < ARGS_TWO) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -1486,13 +1498,13 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); } else if (i == PARAM2) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -1514,7 +1526,7 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->status = context->objectInfo->audioMngr_->SetMute(GetNativeAudioVolumeType(context->volType), context->isMute); } @@ -1547,7 +1559,7 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -1556,11 +1568,11 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -1582,7 +1594,7 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->isMute = context->objectInfo->audioMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); context->isTrue = context->isMute; @@ -1617,7 +1629,7 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -1626,10 +1638,10 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } - } else if (i == PARAM1){ + } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } @@ -1696,7 +1708,7 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_boolean) { @@ -1766,7 +1778,7 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -1779,7 +1791,6 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf } } - if (asyncContext->callbackRef == nullptr) { napi_create_promise(env, &asyncContext->deferred, &result); } else { @@ -1959,7 +1970,7 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_TWO){ + if (argc < ARGS_TWO) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -1968,15 +1979,16 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)){ - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } + if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { + asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + } } else if (i == PARAM2) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -1998,10 +2010,10 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), context->volLevel); - } + } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -2031,7 +2043,7 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -2040,7 +2052,7 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -2066,7 +2078,7 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioMngr_->GetVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -2101,7 +2113,7 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -2110,14 +2122,14 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } - break;; + break; } else { asyncContext->status = ERR_NUMBER101; } @@ -2136,7 +2148,7 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioMngr_->GetMaxVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -2171,7 +2183,7 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -2180,11 +2192,11 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -2206,7 +2218,7 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioMngr_->GetMinVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -2332,7 +2344,7 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); - if( !AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)){ + if( !AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { 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 02b2fdf45e..923df1d14b 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 @@ -480,7 +480,6 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - CheckParams(argc, env, argv, asyncContext, refCount, result); napi_value resource = nullptr; @@ -489,7 +488,7 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->deviceDescriptors = context->objectInfo->audioMngr_->GetDevices( static_cast(context->deviceFlag)); context->status = 0; @@ -513,7 +512,7 @@ napi_value AudioRoutingManagerNapi::GetDevices(napi_env env, napi_callback_info void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* argv, std::unique_ptr& asyncContext, const int32_t refCount, napi_value& result) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -523,7 +522,7 @@ void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); HiLog::Info(LABEL, " GetDevices deviceFlag = %{public}d", asyncContext->deviceFlag); - if(!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)){ + if(!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -559,7 +558,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -629,7 +628,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_TWO){ + if (argc < ARGS_TWO) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -649,7 +648,6 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap } else { asyncContext->status = ERR_NUMBER101; } - } if (asyncContext->callbackRef == nullptr) { @@ -730,7 +728,7 @@ napi_value AudioRoutingManagerNapi::SelectInputDevice(napi_env env, napi_callbac status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -805,7 +803,7 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_TWO){ + if (argc < ARGS_TWO) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -848,7 +846,6 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi context->audioCapturerFilter, context->deviceDescriptors); } else { context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; - } }, SelectInputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1021,7 +1018,7 @@ napi_value AudioRoutingManagerNapi::SetCommunicationDevice(napi_env env, napi_ca if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(asyncContext->deviceType)){ + if(!AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(asyncContext->deviceType)) { asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_boolean) { @@ -1053,7 +1050,6 @@ napi_value AudioRoutingManagerNapi::SetCommunicationDevice(napi_env env, napi_ca context->status = context->objectInfo->audioMngr_->SetDeviceActive( static_cast(context->deviceType), context->isActive); } - }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1092,7 +1088,7 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)){ + if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -1124,7 +1120,6 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na context->isTrue = context->isActive; context->status = 0; } - }, IsTrueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1142,6 +1137,5 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na 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 812466cfb7..35ba4ecbcc 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 @@ -845,7 +845,7 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -854,10 +854,10 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } - } else if (i == PARAM1){ + } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } 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 f5e25c3918..c5bd22b2d9 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 @@ -280,7 +280,7 @@ napi_value AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(nap status = napi_get_reference_value(env, g_groupmanagerConstructor, &constructor); if (status == napi_ok) { - status = napi_new_instance(env, constructor,1 , args, &result); + status = napi_new_instance(env, constructor, PARAM1, args, &result); if (status == napi_ok) { return result; } @@ -304,7 +304,7 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -313,7 +313,7 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -339,7 +339,7 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioGroupMngr_->GetVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -373,7 +373,7 @@ napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_in status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_TWO){ + if (argc < ARGS_TWO) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -382,15 +382,15 @@ napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM2) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -412,7 +412,7 @@ napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_in env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->status = context->objectInfo->audioGroupMngr_->SetVolume(GetNativeAudioVolumeType( context->volType), context->volLevel); } @@ -443,7 +443,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -452,11 +452,11 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break;; @@ -478,7 +478,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioGroupMngr_->GetMaxVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -512,7 +512,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -521,11 +521,11 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -547,7 +547,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->volLevel = context->objectInfo->audioGroupMngr_->GetMinVolume( GetNativeAudioVolumeType(context->volType)); context->intValue = context->volLevel; @@ -581,7 +581,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info unique_ptr asyncContext = make_unique(); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -590,13 +590,13 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); } else if (i == PARAM2) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -618,7 +618,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->status = context->objectInfo->audioGroupMngr_->SetMute(GetNativeAudioVolumeType( context->volType), context->isMute); } @@ -651,7 +651,7 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -660,11 +660,11 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)){ + if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { - if (valueType == napi_function){ + if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; @@ -686,7 +686,7 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - if(context->status == 0){ + if (context->status == SUCCESS) { context->isMute = context->objectInfo->audioGroupMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType)); context->isTrue = context->isMute; @@ -731,7 +731,7 @@ napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callbac if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->ringMode); - if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)){ + if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; } } else if (i == PARAM1) { @@ -761,7 +761,6 @@ napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callbac context->status = context->objectInfo->audioGroupMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode)); } - }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -818,7 +817,6 @@ napi_value AudioVolumeGroupManagerNapi::GetRingerMode(napi_env env, napi_callbac context->intValue = context->ringMode; context->status = 0; } - }, GetIntValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -918,7 +916,7 @@ napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMute(napi_env env, napi_call napi_typeof(env, argv[PARAM0], &valueType); if (valueType == napi_function) { napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); - } + } } if (asyncContext->callbackRef == nullptr) { 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 b27be35dc9..3a35b57b5b 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 @@ -262,12 +262,11 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callba GET_PARAMS(env, info, ARGS_TWO); unique_ptr asyncContext = make_unique(); - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { - for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; napi_typeof(env, argv[i], &valueType); @@ -344,7 +343,7 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupManager(napi_env env, napi_call unique_ptr asyncContext = make_unique(); CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioVolumeManagerAsyncContext object creation failed"); - if (argc < ARGS_ONE){ + if (argc < ARGS_ONE) { asyncContext->status = ERR_NUMBER101; } for (size_t i = PARAM0; i < argc; i++) { @@ -429,7 +428,6 @@ napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) return undefinedResult; } - if (!callbackName.compare(VOLUME_CHANGE_CALLBACK_NAME)) { if (volumeManagerNapi->volumeKeyEventCallbackNapi_ == nullptr) { volumeManagerNapi->volumeKeyEventCallbackNapi_ = std::make_shared(env); @@ -449,7 +447,6 @@ napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) AudioCommonNapi::throwError(env, ERR_NUMBER101); } return undefinedResult; - } } // namespace AudioStandard } // namespace OHOS 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 55ac51f350..c56f237799 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp @@ -562,7 +562,6 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in result = nullptr; } } - return result; } @@ -673,7 +672,6 @@ void AudioRendererNapi::PauseAsyncCallbackComplete(napi_env env, napi_status sta if (asyncContext != nullptr) { if (!asyncContext->status) { - // set pause result to doNotScheduleWrite_ asyncContext->objectInfo->doNotScheduleWrite_ = asyncContext->isTrue; napi_get_undefined(env, &valueParam); @@ -792,7 +790,6 @@ void AudioRendererNapi::StopAsyncCallbackComplete(napi_env env, napi_status stat if (asyncContext != nullptr) { if (!asyncContext->status) { - // set pause result to doNotScheduleWrite_ asyncContext->objectInfo->doNotScheduleWrite_ = asyncContext->isTrue; napi_get_undefined(env, &valueParam); @@ -1052,13 +1049,12 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf context->intValue = context->objectInfo->audioRenderer_->SetRenderRate(audioRenderRate); if (context->intValue == SUCCESS) { context->status = SUCCESS; - } else if (context->intValue == AUDIO_CLIENT_INVALID_PARAMS_ERR){ + } else if (context->intValue == AUDIO_CLIENT_INVALID_PARAMS_ERR) { context->status = ERR_NUMBER104; } else { context->status = ERR_NUMBER301; } } - }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1241,7 +1237,7 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) size_t minBytes = 4; while ((totalBytesWritten < bufferLen) && ((bufferLen - totalBytesWritten) > minBytes)) { bytesWritten = context->objectInfo->audioRenderer_->Write(buffer.get() + totalBytesWritten, - bufferLen - totalBytesWritten); + bufferLen - totalBytesWritten); if (bytesWritten < 0) { break; } @@ -1688,10 +1684,10 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) napi_typeof(env, argv[i], &valueType); if (i == PARAM0 && valueType == napi_number) { AudioRendererInfo rendererInfo = {}; - int32_t rendererInfoStatus; - rendererInfoStatus = asyncContext->objectInfo->audioRenderer_->GetRendererInfo(rendererInfo); + int32_t rendererInfoStatus = asyncContext->objectInfo->audioRenderer_->GetRendererInfo(rendererInfo); if (rendererInfoStatus == SUCCESS) { - asyncContext->volType = asyncContext->objectInfo->audioMngr_->GetStreamType(rendererInfo.contentType, rendererInfo.streamUsage); + asyncContext->volType = asyncContext->objectInfo->audioMngr_-> + GetStreamType(rendererInfo.contentType, rendererInfo.streamUsage); } else { asyncContext->status = ERR_NUMBER301; } @@ -1720,11 +1716,11 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(context->volLevel)){ + if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(context->volLevel)) { context->status = ERR_NUMBER101; } else { - context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), - context->volLevel); + context->status = context->objectInfo->audioMngr_-> + SetVolume(GetNativeAudioVolumeType(context->volType),context->volLevel); } } }, @@ -1997,7 +1993,9 @@ napi_value AudioRendererNapi::RegisterCallback(napi_env env, napi_value jsThis, napi_value result = nullptr; napi_get_undefined(env, &result); - if (!cbName.compare(INTERRUPT_CALLBACK_NAME) || !cbName.compare(AUDIO_INTERRUPT_CALLBACK_NAME) || !cbName.compare(STATE_CHANGE_CALLBACK_NAME)) { + if (!cbName.compare(INTERRUPT_CALLBACK_NAME) || + !cbName.compare(AUDIO_INTERRUPT_CALLBACK_NAME) || + !cbName.compare(STATE_CHANGE_CALLBACK_NAME)) { result = RegisterRendererCallback(env, argv, cbName, rendererNapi); } else if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { result = RegisterPositionCallback(env, argv, cbName, rendererNapi); @@ -2084,7 +2082,6 @@ napi_value AudioRendererNapi::Off(napi_env env, napi_callback_info info) THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER101); - napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER101); diff --git a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp index bfa067428e..7ceaa86f91 100644 --- a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp +++ b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp @@ -161,7 +161,7 @@ napi_value TonePlayerNapi::CreateTonePlayerWrapper(napi_env env, unique_ptr interruptModeMa {"INDEPENDENT_MODE", INDEPENDENT_MODE} }; static const std::map focusTypeMap = { - {"FOCUS_TYPE_DEFAULT", FOCUS_TYPE_DEFAULT} + {"FOCUS_TYPE_RECORDING", FOCUS_TYPE_RECORDING} }; static const std::map audioErrorsMap = { @@ -205,6 +207,13 @@ static const std::map audioIn {"CHANNEL_IN_FRONT", CHANNEL_IN_FRONT}, {"CHANNEL_IN_BACK", CHANNEL_IN_BACK}, }; +static const std::map interruptRequestTypeMap = { + {"INTERRUPT_REQUEST_TYPE_DEFAULT", INTERRUPT_REQUEST_TYPE_DEFAULT}, +}; +static const std::map interruptRequestResultTypeMap = { + {"INTERRUPT_REQUEST_GRANT", INTERRUPT_REQUEST_GRANT}, + {"INTERRUPT_REQUEST_REJECT", INTERRUPT_REQUEST_REJECT}, +}; } // namespace AudioStandard } // namespace OHOS #endif /* AUDIO_MNGR_NAPI_H_ */ -- Gitee From b388fbf27a24abb28c7d9ef52d620a19ab441de8 Mon Sep 17 00:00:00 2001 From: liyuhang Date: Mon, 24 Oct 2022 21:27:17 +0800 Subject: [PATCH 5/5] Deleted mask and fixed formats Signed-off-by: liyuhang Change-Id: I9c08691d57d8c9bdfcc28f5d4b840f04aedfeca2 Signed-off-by: liyuhang Signed-off-by: wangtao Change-Id: Iee2f2bfdcdacab505c549f70d04b6fcc88496b7d Signed-off-by: liyuhang --- .../src/audio_capturer_napi.cpp | 100 ++++----- .../audio_common/include/audio_common_napi.h | 36 ++-- .../audio_common/src/audio_common_napi.cpp | 42 ++-- .../src/audio_interrupt_manager_napi.cpp | 8 +- .../audio_manager/src/audio_manager_napi.cpp | 194 +++++++++--------- .../audio_micstatechange_callback_napi.cpp | 8 +- .../src/audio_routing_manager_napi.cpp | 89 ++++---- .../src/audio_stream_mgr_napi.cpp | 70 +++---- .../src/audio_volume_group_manager_napi.cpp | 98 +++++---- .../src/audio_volume_manager_napi.cpp | 39 ++-- .../src/audio_renderer_napi.cpp | 127 +++++------- .../napi/toneplayer/src/toneplayer_napi.cpp | 20 +- .../audiocapturer/include/audio_capturer.h | 1 - .../native/audiocommon/include/audio_info.h | 29 --- .../include/audio_capturer_napi.h | 2 - .../include/audio_manager_napi.h | 21 +- .../include/audio_volume_group_manager_napi.h | 2 +- .../include/audio_volume_manager_napi.h | 2 +- .../include/audio_renderer_napi.h | 2 - 19 files changed, 393 insertions(+), 497 deletions(-) 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 1cfc507689..c799f64ed1 100644 --- a/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp +++ b/frameworks/js/napi/audio_capturer/src/audio_capturer_napi.cpp @@ -193,8 +193,6 @@ napi_value AudioCapturerNapi::Construct(napi_env env, napi_callback_info info) capturerOptions.streamInfo.encoding = sCapturerOptions_->streamInfo.encoding; capturerOptions.streamInfo.format = sCapturerOptions_->streamInfo.format; capturerOptions.streamInfo.channels = sCapturerOptions_->streamInfo.channels; - capturerOptions.streamInfo.channelOut = sCapturerOptions_->streamInfo.channelOut; - capturerOptions.streamInfo.channelIn = sCapturerOptions_->streamInfo.channelIn; capturerOptions.capturerInfo.sourceType = sCapturerOptions_->capturerInfo.sourceType; capturerOptions.capturerInfo.capturerFlags = sCapturerOptions_->capturerInfo.capturerFlags; @@ -240,7 +238,7 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in GET_PARAMS(env, info, ARGS_TWO); unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } if (asyncContext == nullptr) { @@ -261,7 +259,7 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -279,7 +277,7 @@ napi_value AudioCapturerNapi::CreateAudioCapturer(napi_env env, napi_callback_in env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_NUMBER101; + context->status = NAPI_ERR_INVALID_PARAM; HiLog::Error(LABEL, "ParseCapturerOptions fail, invalid param!"); }, CheckCapturerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -358,8 +356,6 @@ void AudioCapturerNapi::GetCapturerAsyncCallbackComplete(napi_env env, napi_stat capturerOptions->streamInfo.encoding = asyncContext->capturerOptions.streamInfo.encoding; capturerOptions->streamInfo.format = asyncContext->capturerOptions.streamInfo.format; capturerOptions->streamInfo.channels = asyncContext->capturerOptions.streamInfo.channels; - capturerOptions->streamInfo.channelOut = asyncContext->capturerOptions.streamInfo.channelOut; - capturerOptions->streamInfo.channelIn = asyncContext->capturerOptions.streamInfo.channelIn; capturerOptions->capturerInfo.sourceType = asyncContext->capturerOptions.capturerInfo.sourceType; capturerOptions->capturerInfo.capturerFlags = asyncContext->capturerOptions.capturerInfo.capturerFlags; @@ -424,8 +420,6 @@ void AudioCapturerNapi::AudioStreamInfoAsyncCallbackComplete(napi_env env, napi_ (void)napi_create_object(env, &valueParam); SetValueInt32(env, "samplingRate", static_cast(asyncContext->samplingRate), valueParam); SetValueInt32(env, "channels", static_cast(asyncContext->audioChannel), valueParam); - SetValueInt32(env, "channelOut", static_cast(asyncContext->audioChannelOut), valueParam); - SetValueInt32(env, "channelIn", static_cast(asyncContext->audioChannelIn), valueParam); SetValueInt32(env, "sampleFormat", static_cast(asyncContext->audioSampleFormat), valueParam); SetValueInt32(env, "encodingType", static_cast(asyncContext->audioEncoding), valueParam); } @@ -556,7 +550,7 @@ napi_value AudioCapturerNapi::GetCapturerInfo(napi_env env, napi_callback_info i GET_PARAMS(env, info, ARGS_ONE); unique_ptr asyncContext = make_unique(); - THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, NAPI_ERR_NO_MEMORY); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc > PARAM0) { @@ -641,8 +635,6 @@ napi_value AudioCapturerNapi::GetStreamInfo(napi_env env, napi_callback_info inf context->audioSampleFormat = static_cast(streamInfo.format); context->samplingRate = streamInfo.samplingRate; context->audioChannel = streamInfo.channels; - context->audioChannelOut = streamInfo.channelOut; - context->audioChannelIn = streamInfo.channelIn; context->audioEncoding = streamInfo.encoding; } }, @@ -671,7 +663,7 @@ napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info GET_PARAMS(env, info, ARGS_ONE); unique_ptr asyncContext = make_unique(); - THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, NAPI_ERR_NO_MEMORY); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { @@ -699,9 +691,9 @@ napi_value AudioCapturerNapi::GetAudioStreamId(napi_env env, napi_callback_info int32_t streamIdStatus; streamIdStatus = context->objectInfo->audioCapturer_->GetAudioStreamId(audioStreamId); if (streamIdStatus == ERR_ILLEGAL_STATE) { - context->status = ERR_NUMBER103; + context->status = NAPI_ERR_ILLEGAL_STATE; } else if (streamIdStatus == ERR_INVALID_INDEX) { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } else { context->status = SUCCESS; } @@ -731,7 +723,7 @@ napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) GET_PARAMS(env, info, ARGS_ONE); unique_ptr asyncContext = make_unique(); - THROW_ERROR_ASSERT(env, asyncContext != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, asyncContext != nullptr, NAPI_ERR_NO_MEMORY); status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { @@ -760,7 +752,7 @@ napi_value AudioCapturerNapi::Start(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -789,7 +781,7 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) unique_ptr asyncContext = make_unique(); if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -808,7 +800,7 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -826,7 +818,7 @@ napi_value AudioCapturerNapi::Read(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; uint32_t userSize = context->userSize; auto buffer = std::make_unique(userSize); if (!buffer) { @@ -903,7 +895,7 @@ napi_value AudioCapturerNapi::GetAudioTime(napi_env env, napi_callback_info info env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; Timestamp timestamp; if (context->objectInfo->audioCapturer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC)) { const uint64_t secToNanosecond = 1000000000; @@ -964,7 +956,7 @@ napi_value AudioCapturerNapi::Stop(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1020,7 +1012,7 @@ napi_value AudioCapturerNapi::Release(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1048,22 +1040,22 @@ napi_value AudioCapturerNapi::RegisterPeriodPositionCallback(napi_env env, napi_ if (frameCount > 0) { if (capturerNapi->periodPositionCBNapi_ == nullptr) { capturerNapi->periodPositionCBNapi_ = std::make_shared(env); - THROW_ERROR_ASSERT(env, capturerNapi->periodPositionCBNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, capturerNapi->periodPositionCBNapi_ != nullptr, NAPI_ERR_NO_MEMORY); int32_t ret = capturerNapi->audioCapturer_->SetCapturerPeriodPositionCallback(frameCount, capturerNapi->periodPositionCBNapi_); - THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, ret == SUCCESS, NAPI_ERR_SYSTEM); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->periodPositionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_DEBUG_LOG("AudioCapturerNapi: periodReach already subscribed."); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_ILLEGAL_STATE); } } else { - AUDIO_ERR_LOG("AudioCapturerNapi: frameCount value not supported!!"); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); + AUDIO_ERR_LOG("AudioCapturerNapi: frameCount value not supported!"); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_INPUT_INVALID); } napi_value result = nullptr; @@ -1079,17 +1071,17 @@ napi_value AudioCapturerNapi::RegisterPositionCallback(napi_env env, napi_value* if (markPosition > 0) { capturerNapi->positionCBNapi_ = std::make_shared(env); - THROW_ERROR_ASSERT(env, capturerNapi->positionCBNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, capturerNapi->positionCBNapi_ != nullptr, NAPI_ERR_NO_MEMORY); int32_t ret = capturerNapi->audioCapturer_->SetCapturerPositionCallback(markPosition, capturerNapi->positionCBNapi_); - THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, ret == SUCCESS, NAPI_ERR_SYSTEM); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->positionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_ERR_LOG("AudioCapturerNapi: Mark Position value not supported!!"); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_INPUT_INVALID); } napi_value result = nullptr; @@ -1100,7 +1092,7 @@ napi_value AudioCapturerNapi::RegisterPositionCallback(napi_env env, napi_value* napi_value AudioCapturerNapi::RegisterCapturerCallback(napi_env env, napi_value* argv, const std::string& cbName, AudioCapturerNapi *capturerNapi) { - THROW_ERROR_ASSERT(env, capturerNapi->callbackNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, capturerNapi->callbackNapi_ != nullptr, NAPI_ERR_NO_MEMORY); std::shared_ptr cb = std::static_pointer_cast(capturerNapi->callbackNapi_); @@ -1123,9 +1115,9 @@ napi_value AudioCapturerNapi::RegisterCallback(napi_env env, napi_value jsThis, { AudioCapturerNapi *capturerNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&capturerNapi)); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, capturerNapi != nullptr, ERR_NUMBER102); - THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, capturerNapi != nullptr, NAPI_ERR_NO_MEMORY); + THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, NAPI_ERR_NO_MEMORY); napi_value result = nullptr; napi_get_undefined(env, &result); @@ -1138,7 +1130,7 @@ napi_value AudioCapturerNapi::RegisterCallback(napi_env env, napi_value jsThis, result = RegisterPeriodPositionCallback(env, argv, cbName, capturerNapi); } else { bool unknownCallback = true; - THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER_101); + THROW_ERROR_ASSERT(env, !unknownCallback, NAPI_ERROR_INVALID_PARAM); } return result; @@ -1152,12 +1144,12 @@ napi_value AudioCapturerNapi::On(napi_env env, napi_callback_info info) napi_value argv[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, argc >= requireArgc, NAPI_ERR_INPUT_INVALID); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INPUT_INVALID); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioCapturerNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -1165,16 +1157,16 @@ napi_value AudioCapturerNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; if (argc == requireArgc) { napi_typeof(env, argv[1], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); } else { napi_valuetype paramArg1 = napi_undefined; napi_typeof(env, argv[1], ¶mArg1); napi_valuetype expectedValType = napi_number; // Default. Reset it with 'callbackName' if check, if required. - THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, NAPI_ERR_INPUT_INVALID); const int32_t arg2 = 2; napi_typeof(env, argv[arg2], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); } return RegisterCallback(env, jsThis, argv, callbackName); @@ -1184,9 +1176,9 @@ napi_value AudioCapturerNapi::UnregisterCallback(napi_env env, napi_value jsThis { AudioCapturerNapi *capturerNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&capturerNapi)); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, capturerNapi != nullptr, ERR_NUMBER102); - THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, capturerNapi != nullptr, NAPI_ERR_NO_MEMORY); + THROW_ERROR_ASSERT(env, capturerNapi->audioCapturer_ != nullptr, NAPI_ERR_NO_MEMORY); if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { capturerNapi->audioCapturer_->UnsetCapturerPositionCallback(); @@ -1196,7 +1188,7 @@ napi_value AudioCapturerNapi::UnregisterCallback(napi_env env, napi_value jsThis capturerNapi->periodPositionCBNapi_ = nullptr; } else { bool unknownCallback = true; - THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER104); + THROW_ERROR_ASSERT(env, !unknownCallback, NAPI_ERR_UNSUPPORTED); } napi_value result = nullptr; @@ -1212,12 +1204,12 @@ napi_value AudioCapturerNapi::Off(napi_env env, napi_callback_info info) napi_value argv[requireArgc] = {nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER101); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, argc >= requireArgc, NAPI_ERR_INVALID_PARAM); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER101); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INVALID_PARAM); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioCapturerNapi: Off callbackName: %{public}s", callbackName.c_str()); @@ -1376,16 +1368,6 @@ bool AudioCapturerNapi::ParseStreamInfo(napi_env env, napi_value root, AudioStre streamInfo->channels = static_cast(intValue); } - if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - streamInfo->channelOut = static_cast(intValue); - } - - if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - streamInfo->channelIn = static_cast(intValue); - } - if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); streamInfo->format = static_cast(intValue); 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 5a83fc5aec..489580173d 100644 --- a/frameworks/js/napi/audio_common/include/audio_common_napi.h +++ b/frameworks/js/napi/audio_common/include/audio_common_napi.h @@ -88,25 +88,25 @@ struct AutoRef { napi_ref cb_; }; -const int32_t ERR_NUMBER_101 = 6800101; -const int32_t ERR_NUMBER_401 = 401; -const int32_t ERR_NUMBER101 = 6800101; -const int32_t ERR_NUMBER102 = 6800102; -const int32_t ERR_NUMBER103 = 6800103; -const int32_t ERR_NUMBER104 = 6800104; -const int32_t ERR_NUMBER105 = 6800105; -const int32_t ERR_NUMBER201 = 6800201; -const int32_t ERR_NUMBER301 = 6800301; +const int32_t NAPI_ERROR_INVALID_PARAM = 6800101; +const int32_t NAPI_ERR_INPUT_INVALID = 401; +const int32_t NAPI_ERR_INVALID_PARAM = 6800101; +const int32_t NAPI_ERR_NO_MEMORY = 6800102; +const int32_t NAPI_ERR_ILLEGAL_STATE = 6800103; +const int32_t NAPI_ERR_UNSUPPORTED = 6800104; +const int32_t NAPI_ERR_TIMEOUT = 6800105; +const int32_t NAPI_ERR_STREAM_LIMIT = 6800201; +const int32_t NAPI_ERR_SYSTEM = 6800301; -const std::string ERR_MESSAGE_101 = "input parameter value error"; -const std::string ERR_MESSAGE_401 = "input parameter type or number mismatch"; -const std::string ERR_MESSAGE101 = "invalid parameter"; -const std::string ERR_MESSAGE102 = "allocate memory failed"; -const std::string ERR_MESSAGE103 = "Operation not permit at current state"; -const std::string ERR_MESSAGE104 = "unsupported option"; -const std::string ERR_MESSAGE105 = "time out"; -const std::string ERR_MESSAGE201 = "stream number limited"; -const std::string ERR_MESSAGE301 = "system error"; +const std::string NAPI_ERROR_INVALID_PARAM_INFO = "input parameter value error"; +const std::string NAPI_ERR_INPUT_INVALID_INFO = "input parameter type or number mismatch"; +const std::string NAPI_ERR_INVALID_PARAM_INFO = "invalid parameter"; +const std::string NAPI_ERR_NO_MEMORY_INFO = "allocate memory failed"; +const std::string NAPI_ERR_ILLEGAL_STATE_INFO = "Operation not permit at current state"; +const std::string NAPI_ERR_UNSUPPORTED_INFO = "unsupported option"; +const std::string NAPI_ERR_TIMEOUT_INFO = "time out"; +const std::string NAPI_ERR_STREAM_LIMIT_INFO = "stream number limited"; +const std::string NAPI_ERR_SYSTEM_INFO = "system error"; } // namespace AudioStandard } // namespace OHOS #endif // AUDIO_COMMON_NAPI_H_ 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 2dd78a7e18..23b9c5a83c 100644 --- a/frameworks/js/napi/audio_common/src/audio_common_napi.cpp +++ b/frameworks/js/napi/audio_common/src/audio_common_napi.cpp @@ -39,42 +39,44 @@ std::string AudioCommonNapi::GetStringArgument(napi_env env, napi_value value) return strValue; } -std::string AudioCommonNapi::getMessageByCode(int32_t &code) { +std::string AudioCommonNapi::getMessageByCode(int32_t &code) +{ std::string err_message; switch (code) { - case ERR_NUMBER101: - err_message = ERR_MESSAGE101; + case NAPI_ERR_INVALID_PARAM: + err_message = NAPI_ERR_INVALID_PARAM_INFO; break; - case ERR_NUMBER102: - err_message = ERR_MESSAGE102; + case NAPI_ERR_NO_MEMORY: + err_message = NAPI_ERR_NO_MEMORY_INFO; break; - case ERR_NUMBER103: - err_message = ERR_MESSAGE103; + case NAPI_ERR_ILLEGAL_STATE: + err_message = NAPI_ERR_ILLEGAL_STATE_INFO; break; - case ERR_NUMBER104: - err_message = ERR_MESSAGE104; + case NAPI_ERR_UNSUPPORTED: + err_message = NAPI_ERR_UNSUPPORTED_INFO; break; - case ERR_NUMBER105: - err_message = ERR_MESSAGE105; + case NAPI_ERR_TIMEOUT: + err_message = NAPI_ERR_TIMEOUT_INFO; break; - case ERR_NUMBER201: - err_message = ERR_MESSAGE201; + case NAPI_ERR_STREAM_LIMIT: + err_message = NAPI_ERR_STREAM_LIMIT_INFO; break; - case ERR_NUMBER301: - err_message = ERR_MESSAGE301; + case NAPI_ERR_SYSTEM: + err_message = NAPI_ERR_SYSTEM_INFO; break; - case ERR_NUMBER_401: - err_message = ERR_MESSAGE_401; + case NAPI_ERR_INPUT_INVALID: + err_message = NAPI_ERR_INPUT_INVALID_INFO; break; default: - err_message = ERR_MESSAGE301; - code = ERR_NUMBER301; + err_message = NAPI_ERR_SYSTEM_INFO; + code = NAPI_ERR_SYSTEM; break; } return err_message; } -void AudioCommonNapi::throwError(napi_env env, int32_t code) { +void AudioCommonNapi::throwError(napi_env env, int32_t code) +{ std::string messageValue = AudioCommonNapi::getMessageByCode(code); napi_throw_error(env, (std::to_string(code)).c_str(), messageValue.c_str()); } diff --git a/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp index d1394f4f9a..0a3d23b1a2 100644 --- a/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_interrupt_manager_napi.cpp @@ -126,13 +126,13 @@ napi_value AudioInterruptManagerNapi::Init(napi_env env, napi_value exports) const int32_t refCount = 1; napi_get_undefined(env, &result); - napi_property_descriptor audio_routing_manager_properties[] = { + napi_property_descriptor audio_interrupt_manager_properties[] = { }; - status = napi_define_class(env, AUDIO_INTERRUPT_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, - sizeof(audio_routing_manager_properties) / sizeof(audio_routing_manager_properties[PARAM0]), - audio_routing_manager_properties, &constructor); + status = napi_define_class(env, AUDIO_INTERRUPT_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, + nullptr, sizeof(audio_interrupt_manager_properties) / sizeof(audio_interrupt_manager_properties[PARAM0]), + audio_interrupt_manager_properties, &constructor); if (status != napi_ok) { return result; } 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 74201450ef..5ed9dfd84a 100644 --- a/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp @@ -62,8 +62,6 @@ napi_ref AudioManagerNapi::interruptMode_ = nullptr; napi_ref AudioManagerNapi::focusType_ = nullptr; napi_ref AudioManagerNapi::audioErrors_ = nullptr; napi_ref AudioManagerNapi::communicationDeviceType_ = nullptr; -napi_ref AudioManagerNapi::audioOutputChannelMask_ = nullptr; -napi_ref AudioManagerNapi::audioInputChannelMask_ = nullptr; napi_ref AudioManagerNapi::interruptRequestType_ = nullptr; napi_ref AudioManagerNapi::interruptRequestResultType_ = nullptr; @@ -785,10 +783,6 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_PROPERTY("AudioErrors", CreatePropertyBase(env, audioErrorsMap, audioErrors_)), DECLARE_NAPI_PROPERTY("CommunicationDeviceType", CreatePropertyBase(env, communicationDeviceTypeMap, communicationDeviceType_)), - DECLARE_NAPI_PROPERTY("AudioOutputChannelMask", - CreatePropertyBase(env, audioOutputChannelMaskMap, audioOutputChannelMask_)), - DECLARE_NAPI_PROPERTY("AudioInputChannelMask", - CreatePropertyBase(env, audioInputChannelMaskMap, audioInputChannelMask_)), DECLARE_NAPI_PROPERTY("InterruptRequestType", CreatePropertyBase(env, interruptRequestTypeMap, interruptRequestType_)), DECLARE_NAPI_PROPERTY("InterruptRequestResultType", @@ -833,10 +827,10 @@ napi_value AudioManagerNapi::Construct(napi_env env, napi_callback_info info) if (managerNapi != nullptr) { managerNapi->env_ = env; managerNapi->audioMngr_ = AudioSystemManager::GetInstance(); - managerNapi->cachedClientId = getpid(); + managerNapi->cachedClientId_ = getpid(); managerNapi->volumeKeyEventCallbackNapi_ = std::make_shared(env); - ret = managerNapi->audioMngr_->RegisterVolumeKeyEventCallback(managerNapi->cachedClientId, + ret = managerNapi->audioMngr_->RegisterVolumeKeyEventCallback(managerNapi->cachedClientId_, managerNapi->volumeKeyEventCallbackNapi_); if (ret) { AUDIO_ERR_LOG("AudioManagerNapi: RegisterVolumeKeyEventCallback Failed"); @@ -1001,7 +995,7 @@ napi_value AudioManagerNapi::RequestIndependentInterrupt(napi_env env, napi_call status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1015,7 +1009,7 @@ napi_value AudioManagerNapi::RequestIndependentInterrupt(napi_env env, napi_call } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1065,7 +1059,7 @@ napi_value AudioManagerNapi::AbandonIndependentInterrupt(napi_env env, napi_call status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1078,7 +1072,7 @@ napi_value AudioManagerNapi::AbandonIndependentInterrupt(napi_env env, napi_call } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1129,7 +1123,7 @@ napi_value AudioManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1143,7 +1137,7 @@ napi_value AudioManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1197,7 +1191,7 @@ napi_value AudioManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info i napi_typeof(env, argv[PARAM0], &valueType); if (valueType == napi_function) { napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); - } + } } if (asyncContext->callbackRef == nullptr) { @@ -1247,7 +1241,7 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1255,8 +1249,9 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->ringMode); - if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -1264,7 +1259,7 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1319,7 +1314,7 @@ napi_value AudioManagerNapi::GetRingerMode(napi_env env, napi_callback_info info napi_typeof(env, argv[PARAM0], &valueType); if (valueType == napi_function) { napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); - } + } } if (asyncContext->callbackRef == nullptr) { @@ -1382,7 +1377,7 @@ napi_value AudioManagerNapi::SetAudioScene(napi_env env, napi_callback_info info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1400,7 +1395,7 @@ napi_value AudioManagerNapi::SetAudioScene(napi_env env, napi_callback_info info [](napi_env env, void *data) { auto context = static_cast(data); if ((context->scene < AUDIO_SCENE_DEFAULT) || (context->scene > AUDIO_SCENE_PHONE_CHAT)) { - context->status = ERR_NUMBER101; + context->status = NAPI_ERR_INVALID_PARAM; } else { context->status = context->objectInfo->audioMngr_->SetAudioScene(static_cast(context->scene)); @@ -1490,7 +1485,7 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1498,8 +1493,9 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); @@ -1509,7 +1505,7 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1527,8 +1523,8 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->status = context->objectInfo->audioMngr_->SetMute(GetNativeAudioVolumeType(context->volType), - context->isMute); + context->status = context->objectInfo->audioMngr_-> + SetMute(GetNativeAudioVolumeType(context->volType), context->isMute); } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1560,7 +1556,7 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1568,8 +1564,9 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -1577,7 +1574,7 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1630,7 +1627,7 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1638,8 +1635,9 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -1647,7 +1645,7 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1700,7 +1698,7 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1708,18 +1706,19 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isActive); } else if (i == PARAM2) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - } + } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1770,7 +1769,7 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1778,16 +1777,17 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - } + } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1805,8 +1805,8 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->isActive = - context->objectInfo->audioMngr_->IsDeviceActive(static_cast(context->deviceType)); + context->isActive = context->objectInfo->audioMngr_-> + IsDeviceActive(static_cast(context->deviceType)); context->isTrue = context->isActive; context->status = 0; } @@ -1840,7 +1840,7 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1856,7 +1856,7 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1907,7 +1907,7 @@ napi_value AudioManagerNapi::GetAudioParameter(napi_env env, napi_callback_info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1921,7 +1921,7 @@ napi_value AudioManagerNapi::GetAudioParameter(napi_env env, napi_callback_info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1971,7 +1971,7 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1979,13 +1979,15 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM2) { if (valueType == napi_function) { @@ -1993,7 +1995,7 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -2011,8 +2013,8 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType), - context->volLevel); + context->status = context->objectInfo->audioMngr_-> + SetVolume(GetNativeAudioVolumeType(context->volType), context->volLevel); } }, SetFunctionAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -2044,7 +2046,7 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -2052,8 +2054,9 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -2061,7 +2064,7 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -2114,7 +2117,7 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -2122,8 +2125,9 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -2131,7 +2135,7 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -2184,7 +2188,7 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -2192,8 +2196,9 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -2201,7 +2206,7 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -2290,18 +2295,6 @@ static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, vo napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); - napi_value channelOut; - napi_create_array_with_length(env, 1, &channelOut); - napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelOut, &value); - napi_set_element(env, channelOut, 0, value); - napi_set_named_property(env, valueParam, "channelOut", channelOut); - - napi_value channelIn; - napi_create_array_with_length(env, 1, &channelIn); - napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelIn, &value); - napi_set_element(env, channelIn, 0, value); - napi_set_named_property(env, valueParam, "channelIn", channelIn); - napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, asyncContext->deviceDescriptors[i]->channelMasks_, &value); @@ -2336,7 +2329,7 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < PARAM0) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -2344,8 +2337,9 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); - if( !AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -2353,7 +2347,7 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -2471,13 +2465,13 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -2490,7 +2484,7 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::On type mismatch for parameter 2"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } } else { @@ -2499,12 +2493,12 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) if (!callbackName.compare(INTERRUPT_CALLBACK_NAME)) { if (paramArg1 != napi_object) { AUDIO_ERR_LOG("AudioManagerNapi::On Type mismatch for parameter 2"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } if (napi_typeof(env, args[PARAM2], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::On type mismatch for parameter 3"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } } @@ -2535,7 +2529,7 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) if (managerNapi->ringerModecallbackNapi_ == nullptr) { managerNapi->ringerModecallbackNapi_ = std::make_shared(env); int32_t ret = managerNapi->audioMngr_->SetRingerModeCallback( - managerNapi->cachedClientId, managerNapi->ringerModecallbackNapi_); + managerNapi->cachedClientId_, managerNapi->ringerModecallbackNapi_); if (ret) { AUDIO_ERR_LOG("AudioManagerNapi: SetRingerModeCallback Failed"); return undefinedResult; @@ -2567,7 +2561,7 @@ napi_value AudioManagerNapi::On(napi_env env, napi_callback_info info) AUDIO_INFO_LOG("AudioManagerNapi::On SetDeviceChangeCallback is successful"); } else { AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::No such callback supported"); - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } return undefinedResult; } @@ -2584,13 +2578,13 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("Off fail to napi_get_cb_info/Requires min 1 parameters"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -2604,13 +2598,13 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) napi_valuetype paramArg1 = napi_undefined; if (napi_typeof(env, args[PARAM1], ¶mArg1) != napi_ok || paramArg1 != napi_object) { AUDIO_ERR_LOG("AudioManagerNapi::Off type mismatch for parameter 2"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } if (argCount == ARGS_THREE) { if (napi_typeof(env, args[PARAM2], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioManagerNapi::Off type mismatch for parameter 3"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } } @@ -2642,7 +2636,7 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info) } AUDIO_INFO_LOG("AudioManagerNapi::Off UnsetDeviceChangeCallback Success"); } else { - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } return undefinedResult; } diff --git a/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp b/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp index 43e3959fa5..4500728f20 100644 --- a/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp +++ b/frameworks/js/napi/audio_manager/src/audio_micstatechange_callback_napi.cpp @@ -46,7 +46,7 @@ void AudioManagerMicStateChangeCallbackNapi::SaveCallbackReference(const std::st if (callbackName == MIC_STATE_CHANGE_CALLBACK_NAME) { micStateChangeCallback_ = cb; } else { - AUDIO_ERR_LOG("AudioManagerMicStateChangeCallbackNapi: Unknown callback type: %{public}s", callbackName.c_str()); + AUDIO_ERR_LOG("AudioManagerMicStateChangeCallbackNapi:Unknown callback type:%{public}s", callbackName.c_str()); } } @@ -78,7 +78,8 @@ void AudioManagerMicStateChangeCallbackNapi::OnMicStateUpdated(const MicStateCha return OnJsCallbackMicStateChange(cb); } -void AudioManagerMicStateChangeCallbackNapi::OnJsCallbackMicStateChange(std::unique_ptr &jsCb) +void AudioManagerMicStateChangeCallbackNapi::OnJsCallbackMicStateChange + (std::unique_ptr &jsCb) { uv_loop_s *loop = nullptr; napi_get_uv_event_loop(env_, &loop); @@ -102,7 +103,8 @@ void AudioManagerMicStateChangeCallbackNapi::OnJsCallbackMicStateChange(std::uni int ret = uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { // Js Thread - AudioManagerMicStateChangeJsCallback *event = reinterpret_cast(work->data); + AudioManagerMicStateChangeJsCallback *event = + reinterpret_cast(work->data); std::string request = event->callbackName; napi_env env = event->callback->env_; napi_ref callback = event->callback->cb_; 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 923df1d14b..276603e004 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 @@ -51,7 +51,7 @@ struct AudioRoutingManagerAsyncContext { int32_t deviceFlag; int32_t status = SUCCESS; int32_t deviceType; - bool isActive; + bool isActive; bool isTrue; bool bArgTransFlag = true; AudioRoutingManagerNapi *objectInfo; @@ -425,18 +425,6 @@ static void SetDevicesInfo(AudioRoutingManagerAsyncContext* asyncContext, napi_e napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); - napi_value channelOut; - napi_create_array_with_length(env, 1, &channelOut); - napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelOut, &value); - napi_set_element(env, channelOut, 0, value); - napi_set_named_property(env, valueParam, "channelOut", channelOut); - - napi_value channelIn; - napi_create_array_with_length(env, 1, &channelIn); - napi_create_int32(env, asyncContext->deviceDescriptors[i]->audioStreamInfo_.channelIn, &value); - napi_set_element(env, channelIn, 0, value); - napi_set_named_property(env, valueParam, "channelIn", channelIn); - napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, asyncContext->deviceDescriptors[i]->channelMasks_, &value); @@ -513,7 +501,7 @@ void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* std::unique_ptr& asyncContext, const int32_t refCount, napi_value& result) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -522,8 +510,9 @@ void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceFlag); HiLog::Info(LABEL, " GetDevices deviceFlag = %{public}d", asyncContext->deviceFlag); - if(!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentDeviceFlag(asyncContext->deviceFlag)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -531,8 +520,8 @@ void AudioRoutingManagerNapi::CheckParams(size_t argc, napi_env env, napi_value* } break; } else { - asyncContext->status = ERR_NUMBER101; - HiLog::Error(LABEL, "ERROR: type mismatch"); + asyncContext->status = NAPI_ERR_INVALID_PARAM; + HiLog::Error(LABEL, "ERROR: type mismatch"); } } @@ -559,7 +548,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -574,9 +563,8 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } - } if (asyncContext->callbackRef == nullptr) { @@ -595,7 +583,8 @@ napi_value AudioRoutingManagerNapi::SelectOutputDevice(napi_env env, napi_callba if (context->bArgTransFlag) { context->status = context->objectInfo->audioMngr_->SelectOutputDevice(context->deviceDescriptors); } else { - context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + context->status = context->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } }, SelectOutputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -629,7 +618,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -646,7 +635,7 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -667,7 +656,8 @@ napi_value AudioRoutingManagerNapi::SelectOutputDeviceByFilter(napi_env env, nap context->status = context->objectInfo->audioMngr_->SelectOutputDevice( context->audioRendererFilter, context->deviceDescriptors); } else { - context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + context->status = context->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } }, SelectOutputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -729,7 +719,7 @@ napi_value AudioRoutingManagerNapi::SelectInputDevice(napi_env env, napi_callbac status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -737,13 +727,13 @@ napi_value AudioRoutingManagerNapi::SelectInputDevice(napi_env env, napi_callbac if (i == PARAM0 && valueType == napi_object) { ParseAudioDeviceDescriptorVector(env, argv[i], asyncContext->deviceDescriptors, asyncContext->bArgTransFlag); - } else if (i == PARAM1 ) { + } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } if (!asyncContext->bArgTransFlag) { @@ -804,7 +794,7 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -820,7 +810,7 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } if (!asyncContext->bArgTransFlag) { @@ -845,7 +835,8 @@ napi_value AudioRoutingManagerNapi::SelectInputDeviceByFilter(napi_env env, napi context->status = context->objectInfo->audioMngr_->SelectInputDevice( context->audioCapturerFilter, context->deviceDescriptors); } else { - context->status = context->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + context->status = context->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } }, SelectInputDeviceAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -906,7 +897,7 @@ void AudioRoutingManagerNapi::RegisterCallback(napi_env env, napi_value jsThis, RegisterDeviceChangeCallback(env, args, cbName, flag, routingMgrNapi); } else { AUDIO_ERR_LOG("AudioRoutingMgrNapi::No such supported"); - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } } @@ -925,11 +916,11 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr); bool isArgcCountRight = argc == requireArgc || argc == maxArgc; - THROW_ERROR_ASSERT(env, status == napi_ok && isArgcCountRight, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, status == napi_ok && isArgcCountRight, NAPI_ERR_INPUT_INVALID); napi_valuetype eventType = napi_undefined; napi_typeof(env, args[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INPUT_INVALID); std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); AUDIO_INFO_LOG("AaudioRoutingManagerNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -938,7 +929,7 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) if (argc == requireArgc) { napi_valuetype handler = napi_undefined; napi_typeof(env, args[1], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); deviceFlag = 3; // 3 for ALL_DEVICES_FLAG } if (argc == maxArgc) { @@ -947,7 +938,7 @@ napi_value AudioRoutingManagerNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; napi_typeof(env, args[PARAM2], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); } RegisterCallback(env, jsThis, args, callbackName, deviceFlag); @@ -1010,7 +1001,7 @@ napi_value AudioRoutingManagerNapi::SetCommunicationDevice(napi_env env, napi_ca status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1018,18 +1009,19 @@ napi_value AudioRoutingManagerNapi::SetCommunicationDevice(napi_env env, napi_ca if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(asyncContext->deviceType)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(asyncContext->deviceType)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isActive); } else if (i == PARAM2) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - } + } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1080,7 +1072,7 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -1088,16 +1080,17 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->deviceType); - if(!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(asyncContext->deviceType)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); - } + } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1115,8 +1108,8 @@ napi_value AudioRoutingManagerNapi::IsCommunicationDeviceActive(napi_env env, na [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->isActive = - context->objectInfo->audioMngr_->IsDeviceActive(static_cast(context->deviceType)); + context->isActive = context->objectInfo->audioMngr_-> + IsDeviceActive(static_cast(context->deviceType)); context->isTrue = context->isActive; context->status = 0; } 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 35ba4ecbcc..a2bc36e4f5 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 @@ -159,18 +159,6 @@ static void SetDeviceDescriptors(const napi_env& env, napi_value &jsChangeInfoOb napi_set_element(env, channelCounts, 0, value); napi_set_named_property(env, valueParam, "channelCounts", channelCounts); - napi_value channelOut; - napi_create_array_with_length(env, 1, &channelOut); - napi_create_int32(env, deviceInfo.audioStreamInfo.channelOut, &value); - napi_set_element(env, channelOut, 0, value); - napi_set_named_property(env, valueParam, "channelOut", channelOut); - - napi_value channelIn; - napi_create_array_with_length(env, 1, &channelIn); - napi_create_int32(env, deviceInfo.audioStreamInfo.channelIn, &value); - napi_set_element(env, channelIn, 0, value); - napi_set_named_property(env, valueParam, "channelIn", channelIn); - napi_value channelMasks; napi_create_array_with_length(env, 1, &channelMasks); napi_create_int32(env, deviceInfo.channelMasks, &value); @@ -430,7 +418,7 @@ void AudioStreamMgrNapi::RegisterCallback(napi_env env, napi_value jsThis, RegisterCapturerStateChangeCallback(env, args, cbName, streamMgrNapi); } else { AUDIO_ERR_LOG("AudioStreamMgrNapi::No such callback supported"); - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } } @@ -445,11 +433,11 @@ napi_value AudioStreamMgrNapi::On(napi_env env, napi_callback_info info) napi_value args[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr); - THROW_ERROR_ASSERT(env, status == napi_ok && argc == requireArgc, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, status == napi_ok && argc == requireArgc, NAPI_ERR_INPUT_INVALID); napi_valuetype eventType = napi_undefined; napi_typeof(env, args[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INPUT_INVALID); std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); AUDIO_DEBUG_LOG("AudioStreamMgrNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -457,7 +445,7 @@ napi_value AudioStreamMgrNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; napi_typeof(env, args[1], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); RegisterCallback(env, jsThis, args, callbackName); @@ -554,7 +542,7 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -574,9 +562,8 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_c if (context->status == SUCCESS) { context->status = context->objectInfo->audioStreamMngr_-> GetCurrentRendererChangeInfos(context->audioRendererChangeInfos); - context->status = context->status == SUCCESS ? SUCCESS : ERR_NUMBER301; + context->status = context->status == SUCCESS ? SUCCESS : NAPI_ERR_SYSTEM; } - }, GetCurrentRendererChangeInfosCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -621,7 +608,7 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_c } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -639,10 +626,10 @@ napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_c [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->objectInfo->audioStreamMngr_->GetCurrentCapturerChangeInfos(context->audioCapturerChangeInfos); + context->objectInfo->audioStreamMngr_-> + GetCurrentCapturerChangeInfos(context->audioCapturerChangeInfos); context->status = SUCCESS; } - }, GetCurrentCapturerChangeInfosCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -679,7 +666,8 @@ napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, if (i == PARAM0 && valueType == napi_object) { if (!ParseAudioStreamInfo(env, argv[i], asyncContext->audioStreamInfo)) { HiLog::Error(LABEL, "Parsing of audiostream failed"); - asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -687,7 +675,7 @@ napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } if (asyncContext->callbackRef == nullptr) { @@ -701,14 +689,13 @@ napi_value AudioStreamMgrNapi::IsAudioRendererLowLatencySupported(napi_env env, status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { - auto context = static_cast(data); - if (context->status == SUCCESS) { - context->isLowLatencySupported = - context->objectInfo->audioStreamMngr_->IsAudioRendererLowLatencySupported(context->audioStreamInfo); - context->isTrue = context->isLowLatencySupported; - context->status = SUCCESS; - } - + auto context = static_cast(data); + if (context->status == SUCCESS) { + context->isLowLatencySupported = + context->objectInfo->audioStreamMngr_->IsAudioRendererLowLatencySupported(context->audioStreamInfo); + context->isTrue = context->isLowLatencySupported; + context->status = SUCCESS; + } }, IsLowLatencySupportedCallback, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -740,16 +727,6 @@ bool AudioStreamMgrNapi::ParseAudioStreamInfo(napi_env env, napi_value root, Aud audioStreamInfo.channels = static_cast(intValue); } - if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - audioStreamInfo.channelOut = static_cast(intValue); - } - - if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - audioStreamInfo.channelIn = static_cast(intValue); - } - if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); audioStreamInfo.format = static_cast(intValue); @@ -846,7 +823,7 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -854,8 +831,9 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -863,7 +841,7 @@ napi_value AudioStreamMgrNapi::IsStreamActive(napi_env env, napi_callback_info i } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } 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 c5bd22b2d9..e27be4306d 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 @@ -12,6 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + #include "audio_volume_group_manager_napi.h" #include "audio_common_napi.h" #include "audio_errors.h" @@ -278,7 +279,6 @@ napi_value AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(nap napi_create_int64(env, groupId, &groupId_); napi_value args[PARAM1] = {groupId_}; status = napi_get_reference_value(env, g_groupmanagerConstructor, &constructor); - if (status == napi_ok) { status = napi_new_instance(env, constructor, PARAM1, args, &result); if (status == napi_ok) { @@ -305,7 +305,7 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -313,8 +313,9 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -322,7 +323,7 @@ napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_in } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -374,7 +375,7 @@ napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_in status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_TWO) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -382,20 +383,23 @@ napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_in if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volLevel); - if(!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; } + if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(asyncContext->volLevel)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; + } } else if (i == PARAM2) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -444,7 +448,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -452,16 +456,17 @@ napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef); } - break;; + break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -513,7 +518,7 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -521,8 +526,9 @@ napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -582,7 +588,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -590,8 +596,9 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1 && valueType == napi_boolean) { napi_get_value_bool(env, argv[i], &asyncContext->isMute); @@ -601,7 +608,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -652,7 +659,7 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -660,8 +667,9 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->volType); - if(!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { - asyncContext->status = (asyncContext->status == ERR_NUMBER101) ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) { + asyncContext->status = (asyncContext->status == + NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -669,7 +677,7 @@ napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -723,7 +731,7 @@ napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callbac status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -731,8 +739,9 @@ napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callbac if (i == PARAM0 && valueType == napi_number) { napi_get_value_int32(env, argv[i], &asyncContext->ringMode); - if(!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { - asyncContext->status = asyncContext->status == ERR_NUMBER101 ? ERR_NUMBER101 : ERR_NUMBER104; + if (!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) { + asyncContext->status = asyncContext->status == + NAPI_ERR_INVALID_PARAM ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED; } } else if (i == PARAM1) { if (valueType == napi_function) { @@ -740,7 +749,7 @@ napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callbac } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -796,7 +805,7 @@ napi_value AudioVolumeGroupManagerNapi::GetRingerMode(napi_env env, napi_callbac napi_typeof(env, argv[PARAM0], &valueType); if (valueType == napi_function) { napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef); - } + } } if (asyncContext->callbackRef == nullptr) { @@ -848,7 +857,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMicrophoneMute(napi_env env, napi_cal status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -862,7 +871,7 @@ napi_value AudioVolumeGroupManagerNapi::SetMicrophoneMute(napi_env env, napi_cal } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -965,12 +974,12 @@ napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -982,16 +991,15 @@ napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info napi_valuetype handler = napi_undefined; if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::On type mismatch for parameter 2"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } - if (!callbackName.compare(RINGERMODE_CALLBACK_NAME)) { if (volumeGroupManagerNapi->ringerModecallbackNapi_ == nullptr) { volumeGroupManagerNapi->ringerModecallbackNapi_ = std::make_shared(env); int32_t ret = volumeGroupManagerNapi->audioGroupMngr_->SetRingerModeCallback( - volumeGroupManagerNapi->cachedClientId, volumeGroupManagerNapi->ringerModecallbackNapi_); + volumeGroupManagerNapi->cachedClientId_, volumeGroupManagerNapi->ringerModecallbackNapi_); if (ret) { AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi:: SetRingerModeCallback Failed"); return undefinedResult; @@ -1005,7 +1013,8 @@ napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info cb->SaveCallbackReference(callbackName, args[PARAM1]); } else if (!callbackName.compare(MIC_STATE_CHANGE_CALLBACK_NAME)) { if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) { - volumeGroupManagerNapi->micStateChangeCallbackNapi_= std::make_shared(env); + volumeGroupManagerNapi->micStateChangeCallbackNapi_= + std::make_shared(env); if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) { AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi:: Memory Allocation Failed !!"); } @@ -1018,16 +1027,16 @@ napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info } std::shared_ptr cb = - std::static_pointer_cast(volumeGroupManagerNapi->micStateChangeCallbackNapi_); + std::static_pointer_cast(volumeGroupManagerNapi-> + micStateChangeCallbackNapi_); cb->SaveCallbackReference(callbackName, args[PARAM1]); AUDIO_INFO_LOG("AudioVolumeGroupManagerNapi::On SetMicStateChangeCallback is successful"); } else { AUDIO_ERR_LOG("AudioVolumeGroupManagerNapi::No such callback supported"); - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } return undefinedResult; - } napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports) @@ -1054,7 +1063,8 @@ napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports) }; - status = napi_define_class(env, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, + status = napi_define_class(env, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), + NAPI_AUTO_LENGTH, Construct, nullptr, sizeof(audio_svc_group_mngr_properties) / sizeof(audio_svc_group_mngr_properties[PARAM0]), audio_svc_group_mngr_properties, &constructor); if (status != napi_ok) { 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 3a35b57b5b..2514ab186c 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 @@ -136,7 +136,7 @@ napi_value AudioVolumeManagerNapi::Init(napi_env env, napi_value exports) const int32_t refCount = 1; napi_get_undefined(env, &result); - napi_property_descriptor audio_routing_manager_properties[] = { + napi_property_descriptor audio_volume_manager_properties[] = { DECLARE_NAPI_FUNCTION("getVolumeGroupInfos", GetVolumeGroupInfos), DECLARE_NAPI_FUNCTION("getVolumeGroupManager", GetVolumeGroupManager), DECLARE_NAPI_FUNCTION("on", On), @@ -144,8 +144,8 @@ napi_value AudioVolumeManagerNapi::Init(napi_env env, napi_value exports) }; status = napi_define_class(env, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, - sizeof(audio_routing_manager_properties) / sizeof(audio_routing_manager_properties[PARAM0]), - audio_routing_manager_properties, &constructor); + sizeof(audio_volume_manager_properties) / sizeof(audio_volume_manager_properties[PARAM0]), + audio_volume_manager_properties, &constructor); if (status != napi_ok) { return result; } @@ -263,7 +263,7 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callba unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); if (status == napi_ok && asyncContext->objectInfo != nullptr) { @@ -278,7 +278,7 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callba } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -296,13 +296,14 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupInfos(napi_env env, napi_callba [](napi_env env, void* data) { auto context = static_cast(data); if (!context->status) { - context->volumeGroupInfos = context->objectInfo->audioSystemMngr_->GetVolumeGroups(context->networkId); + context->volumeGroupInfos = context->objectInfo->audioSystemMngr_-> + GetVolumeGroups(context->networkId); context->status = 0; } }, GetVolumeGroupInfosAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { - AudioCommonNapi::throwError(env, ERR_NUMBER301); + AudioCommonNapi::throwError(env, NAPI_ERR_SYSTEM); result = nullptr; } else { status = napi_queue_async_work(env, asyncContext->work); @@ -344,7 +345,7 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupManager(napi_env env, napi_call unique_ptr asyncContext = make_unique(); CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioVolumeManagerAsyncContext object creation failed"); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } for (size_t i = PARAM0; i < argc; i++) { napi_valuetype valueType = napi_undefined; @@ -357,7 +358,7 @@ napi_value AudioVolumeManagerNapi::GetVolumeGroupManager(napi_env env, napi_call } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -405,12 +406,12 @@ napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); if (status != napi_ok || argCount < minArgCount) { AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); } napi_valuetype eventType = napi_undefined; if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) { - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]); @@ -418,21 +419,23 @@ napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) AudioVolumeManagerNapi *volumeManagerNapi = nullptr; status = napi_unwrap(env, jsThis, reinterpret_cast(&volumeManagerNapi)); - NAPI_ASSERT(env, status == napi_ok && volumeManagerNapi != nullptr, "Failed to retrieve audio manager napi instance."); - NAPI_ASSERT(env, volumeManagerNapi->audioSystemMngr_ != nullptr, "audio system manager instance is null."); + NAPI_ASSERT(env, status == napi_ok && volumeManagerNapi != nullptr, + "Failed to retrieve audio manager napi instance."); + NAPI_ASSERT(env, volumeManagerNapi->audioSystemMngr_ != nullptr, + "audio system manager instance is null."); napi_valuetype handler = napi_undefined; if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) { AUDIO_ERR_LOG("AudioVolumeManagerNapi::On type mismatch for parameter 2"); - AudioCommonNapi::throwError(env, ERR_NUMBER_401); + AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID); return undefinedResult; } if (!callbackName.compare(VOLUME_CHANGE_CALLBACK_NAME)) { if (volumeManagerNapi->volumeKeyEventCallbackNapi_ == nullptr) { volumeManagerNapi->volumeKeyEventCallbackNapi_ = std::make_shared(env); - int32_t ret = volumeManagerNapi->audioSystemMngr_->RegisterVolumeKeyEventCallback(volumeManagerNapi->cachedClientId, - volumeManagerNapi->volumeKeyEventCallbackNapi_); + int32_t ret = volumeManagerNapi->audioSystemMngr_->RegisterVolumeKeyEventCallback( + volumeManagerNapi->cachedClientId_, volumeManagerNapi->volumeKeyEventCallbackNapi_); if (ret) { AUDIO_ERR_LOG("AudioVolumeManagerNapi:: RegisterVolumeKeyEventCallback Failed"); } else { @@ -442,9 +445,9 @@ napi_value AudioVolumeManagerNapi::On(napi_env env, napi_callback_info info) std::shared_ptr cb = std::static_pointer_cast(volumeManagerNapi->volumeKeyEventCallbackNapi_); cb->SaveCallbackReference(callbackName, args[PARAM1]); - }else { + } else { AUDIO_ERR_LOG("AudioVolumeManagerNapi::No such callback supported"); - AudioCommonNapi::throwError(env, ERR_NUMBER101); + AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM); } return undefinedResult; } 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 c56f237799..9b13c3c484 100644 --- a/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp @@ -465,9 +465,6 @@ napi_value AudioRendererNapi::Construct(napi_env env, napi_callback_info info) rendererOptions.streamInfo.encoding = sRendererOptions_->streamInfo.encoding; rendererOptions.streamInfo.format = sRendererOptions_->streamInfo.format; rendererOptions.streamInfo.channels = sRendererOptions_->streamInfo.channels; - rendererOptions.streamInfo.channelOut = sRendererOptions_->streamInfo.channelOut; - rendererOptions.streamInfo.channelIn = sRendererOptions_->streamInfo.channelIn; - rendererOptions.rendererInfo.contentType = sRendererOptions_->rendererInfo.contentType; rendererOptions.rendererInfo.streamUsage = sRendererOptions_->rendererInfo.streamUsage; rendererOptions.rendererInfo.rendererFlags = sRendererOptions_->rendererInfo.rendererFlags; @@ -514,7 +511,7 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioRendererAsyncContext object creation failed"); @@ -532,7 +529,7 @@ napi_value AudioRendererNapi::CreateAudioRenderer(napi_env env, napi_callback_in } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -932,8 +929,6 @@ void AudioRendererNapi::GetRendererAsyncCallbackComplete(napi_env env, napi_stat rendererOptions->streamInfo.encoding = asyncContext->rendererOptions.streamInfo.encoding; rendererOptions->streamInfo.format = asyncContext->rendererOptions.streamInfo.format; rendererOptions->streamInfo.channels = asyncContext->rendererOptions.streamInfo.channels; - rendererOptions->streamInfo.channelOut = asyncContext->rendererOptions.streamInfo.channelOut; - rendererOptions->streamInfo.channelIn = asyncContext->rendererOptions.streamInfo.channelIn; rendererOptions->rendererInfo.contentType = asyncContext->rendererOptions.rendererInfo.contentType; rendererOptions->rendererInfo.streamUsage = asyncContext->rendererOptions.rendererInfo.streamUsage; rendererOptions->rendererInfo.rendererFlags = asyncContext->rendererOptions.rendererInfo.rendererFlags; @@ -989,8 +984,6 @@ void AudioRendererNapi::AudioStreamInfoAsyncCallbackComplete(napi_env env, napi_ (void)napi_create_object(env, &valueParam); SetValueInt32(env, "samplingRate", static_cast(asyncContext->samplingRate), valueParam); SetValueInt32(env, "channels", static_cast(asyncContext->channelCount), valueParam); - SetValueInt32(env, "channelOut", static_cast(asyncContext->audioChannelOut), valueParam); - SetValueInt32(env, "channelIn", static_cast(asyncContext->audioChannelIn), valueParam); SetValueInt32(env, "sampleFormat", static_cast(asyncContext->sampleFormat), valueParam); SetValueInt32(env, "encodingType", static_cast(asyncContext->encodingType), valueParam); } @@ -1009,7 +1002,7 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf GET_PARAMS(env, info, ARGS_TWO); unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -1026,7 +1019,7 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1045,14 +1038,14 @@ napi_value AudioRendererNapi::SetRenderRate(napi_env env, napi_callback_info inf auto context = static_cast(data); if (context->status == SUCCESS) { AudioRendererRate audioRenderRate = static_cast(context->audioRendererRate); - int32_t AUDIO_CLIENT_INVALID_PARAMS_ERR = -2; + int32_t audioClientInvalidParamsErr = -2; context->intValue = context->objectInfo->audioRenderer_->SetRenderRate(audioRenderRate); if (context->intValue == SUCCESS) { context->status = SUCCESS; - } else if (context->intValue == AUDIO_CLIENT_INVALID_PARAMS_ERR) { - context->status = ERR_NUMBER104; + } else if (context->intValue == audioClientInvalidParamsErr) { + context->status = NAPI_ERR_UNSUPPORTED; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } } }, @@ -1157,7 +1150,7 @@ napi_value AudioRendererNapi::Start(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Start(); - context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; + context->status = context->isTrue ? SUCCESS : NAPI_ERR_SYSTEM; }, StartAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1184,7 +1177,7 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) GET_PARAMS(env, info, ARGS_TWO); unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -1201,7 +1194,7 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1219,7 +1212,7 @@ napi_value AudioRendererNapi::Write(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); if (context->status == SUCCESS) { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; size_t bufferLen = context->bufferLen; auto buffer = std::make_unique(bufferLen); if (buffer == nullptr) { @@ -1308,7 +1301,7 @@ napi_value AudioRendererNapi::GetAudioTime(napi_env env, napi_callback_info info context->time = timestamp.time.tv_nsec + timestamp.time.tv_sec * secToNanosecond; context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, GetInt64ValueAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1361,7 +1354,7 @@ napi_value AudioRendererNapi::Drain(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Drain(); - context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; + context->status = context->isTrue ? SUCCESS : NAPI_ERR_SYSTEM; }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1421,7 +1414,7 @@ napi_value AudioRendererNapi::Pause(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Pause(); - context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; + context->status = context->isTrue ? SUCCESS : NAPI_ERR_SYSTEM; }, PauseAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1474,7 +1467,7 @@ napi_value AudioRendererNapi::Stop(napi_env env, napi_callback_info info) [](napi_env env, void *data) { auto context = static_cast(data); context->isTrue = context->objectInfo->audioRenderer_->Stop(); - context->status = context->isTrue ? SUCCESS : ERR_NUMBER301; + context->status = context->isTrue ? SUCCESS : NAPI_ERR_SYSTEM; }, StopAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); if (status != napi_ok) { @@ -1529,7 +1522,7 @@ napi_value AudioRendererNapi::Release(napi_env env, napi_callback_info info) if (context->isTrue) { context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -1640,9 +1633,9 @@ napi_value AudioRendererNapi::GetAudioStreamId(napi_env env, napi_callback_info int32_t streamIdStatus; streamIdStatus = context->objectInfo->audioRenderer_->GetAudioStreamId(audioStreamId); if (streamIdStatus == ERR_ILLEGAL_STATE) { - context->status = ERR_NUMBER103; + context->status = NAPI_ERR_ILLEGAL_STATE; } else if (streamIdStatus == ERR_INVALID_INDEX) { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } else { context->status = SUCCESS; } @@ -1674,7 +1667,7 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -1689,7 +1682,7 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) asyncContext->volType = asyncContext->objectInfo->audioMngr_-> GetStreamType(rendererInfo.contentType, rendererInfo.streamUsage); } else { - asyncContext->status = ERR_NUMBER301; + asyncContext->status = NAPI_ERR_SYSTEM; } napi_get_value_int32(env, argv[i], &asyncContext->volLevel); } else if (i == PARAM1) { @@ -1698,7 +1691,7 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } @@ -1717,10 +1710,10 @@ napi_value AudioRendererNapi::SetVolume(napi_env env, napi_callback_info info) auto context = static_cast(data); if (context->status == SUCCESS) { if (!AudioCommonNapi::IsLegalInputArgumentVolLevel(context->volLevel)) { - context->status = ERR_NUMBER101; + context->status = NAPI_ERR_INVALID_PARAM; } else { context->status = context->objectInfo->audioMngr_-> - SetVolume(GetNativeAudioVolumeType(context->volType),context->volLevel); + SetVolume(GetNativeAudioVolumeType(context->volType), context->volLevel); } } }, @@ -1838,8 +1831,6 @@ napi_value AudioRendererNapi::GetStreamInfo(napi_env env, napi_callback_info inf context->sampleFormat = static_cast(streamInfo.format); context->samplingRate = streamInfo.samplingRate; context->channelCount = streamInfo.channels; - context->audioChannelOut = streamInfo.channelOut; - context->audioChannelIn = streamInfo.channelIn; context->encodingType = streamInfo.encoding; } }, @@ -1896,22 +1887,22 @@ napi_value AudioRendererNapi::RegisterPeriodPositionCallback(napi_env env, napi_ if (frameCount > 0) { if (rendererNapi->periodPositionCBNapi_ == nullptr) { rendererNapi->periodPositionCBNapi_ = std::make_shared(env); - THROW_ERROR_ASSERT(env, rendererNapi->periodPositionCBNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->periodPositionCBNapi_ != nullptr, NAPI_ERR_NO_MEMORY); int32_t ret = rendererNapi->audioRenderer_->SetRendererPeriodPositionCallback(frameCount, rendererNapi->periodPositionCBNapi_); - THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, ret == SUCCESS, NAPI_ERR_SYSTEM); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->periodPositionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_DEBUG_LOG("AudioRendererNapi: periodReach already subscribed."); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_ILLEGAL_STATE); } } else { AUDIO_ERR_LOG("AudioRendererNapi: frameCount value not supported!!"); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_INPUT_INVALID); } napi_value result = nullptr; @@ -1927,17 +1918,17 @@ napi_value AudioRendererNapi::RegisterPositionCallback(napi_env env, napi_value* if (markPosition > 0) { rendererNapi->positionCBNapi_ = std::make_shared(env); - THROW_ERROR_ASSERT(env, rendererNapi->positionCBNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->positionCBNapi_ != nullptr, NAPI_ERR_NO_MEMORY); int32_t ret = rendererNapi->audioRenderer_->SetRendererPositionCallback(markPosition, rendererNapi->positionCBNapi_); - THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, ret == SUCCESS, NAPI_ERR_SYSTEM); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->positionCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM2]); } else { AUDIO_ERR_LOG("AudioRendererNapi: Mark Position value not supported!!"); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_INPUT_INVALID); } napi_value result = nullptr; @@ -1948,7 +1939,7 @@ napi_value AudioRendererNapi::RegisterPositionCallback(napi_env env, napi_value* napi_value AudioRendererNapi::RegisterRendererCallback(napi_env env, napi_value* argv, const std::string& cbName, AudioRendererNapi *rendererNapi) { - THROW_ERROR_ASSERT(env, rendererNapi->callbackNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->callbackNapi_ != nullptr, NAPI_ERR_NO_MEMORY); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->callbackNapi_); @@ -1965,15 +1956,15 @@ napi_value AudioRendererNapi::RegisterDataRequestCallback(napi_env env, napi_val if (rendererNapi->dataRequestCBNapi_ == nullptr) { rendererNapi->dataRequestCBNapi_ = std::make_shared(env, rendererNapi); rendererNapi->audioRenderer_->SetRenderMode(RENDER_MODE_CALLBACK); - THROW_ERROR_ASSERT(env, rendererNapi->dataRequestCBNapi_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->dataRequestCBNapi_ != nullptr, NAPI_ERR_NO_MEMORY); int32_t ret = rendererNapi->audioRenderer_->SetRendererWriteCallback(rendererNapi->dataRequestCBNapi_); - THROW_ERROR_ASSERT(env, ret == SUCCESS, ERR_NUMBER301); + THROW_ERROR_ASSERT(env, ret == SUCCESS, NAPI_ERR_SYSTEM); std::shared_ptr cb = std::static_pointer_cast(rendererNapi->dataRequestCBNapi_); cb->SaveCallbackReference(cbName, argv[PARAM1]); } else { AUDIO_DEBUG_LOG("AudioRendererNapi:dataRequest already subscribed."); - THROW_ERROR_ASSERT(env, false, ERR_NUMBER103); + THROW_ERROR_ASSERT(env, false, NAPI_ERR_ILLEGAL_STATE); } napi_value result = nullptr; napi_get_undefined(env, &result); @@ -1985,10 +1976,10 @@ napi_value AudioRendererNapi::RegisterCallback(napi_env env, napi_value jsThis, { AudioRendererNapi *rendererNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&rendererNapi)); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, rendererNapi != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, rendererNapi != nullptr, NAPI_ERR_NO_MEMORY); - THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, NAPI_ERR_NO_MEMORY); napi_value result = nullptr; napi_get_undefined(env, &result); @@ -2005,7 +1996,7 @@ napi_value AudioRendererNapi::RegisterCallback(napi_env env, napi_value jsThis, result = RegisterDataRequestCallback(env, argv, cbName, rendererNapi); } else { bool unknownCallback = true; - THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER_101); + THROW_ERROR_ASSERT(env, !unknownCallback, NAPI_ERROR_INVALID_PARAM); } return result; @@ -2019,12 +2010,12 @@ napi_value AudioRendererNapi::On(napi_env env, napi_callback_info info) napi_value argv[requireArgc + 1] = {nullptr, nullptr, nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, argc >= requireArgc, NAPI_ERR_INPUT_INVALID); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INPUT_INVALID); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioRendererNapi: On callbackName: %{public}s", callbackName.c_str()); @@ -2032,16 +2023,16 @@ napi_value AudioRendererNapi::On(napi_env env, napi_callback_info info) napi_valuetype handler = napi_undefined; if (argc == requireArgc) { napi_typeof(env, argv[1], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); } else { napi_valuetype paramArg1 = napi_undefined; napi_typeof(env, argv[1], ¶mArg1); napi_valuetype expectedValType = napi_number; // Default. Reset it with 'callbackName' if check, if required. - THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, paramArg1 == expectedValType, NAPI_ERR_INPUT_INVALID); const int32_t arg2 = 2; napi_typeof(env, argv[arg2], &handler); - THROW_ERROR_ASSERT(env, handler == napi_function, ERR_NUMBER_401); + THROW_ERROR_ASSERT(env, handler == napi_function, NAPI_ERR_INPUT_INVALID); } return RegisterCallback(env, jsThis, argv, callbackName); @@ -2051,9 +2042,9 @@ napi_value AudioRendererNapi::UnregisterCallback(napi_env env, napi_value jsThis { AudioRendererNapi *rendererNapi = nullptr; napi_status status = napi_unwrap(env, jsThis, reinterpret_cast(&rendererNapi)); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, rendererNapi != nullptr, ERR_NUMBER102); - THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, ERR_NUMBER102); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, rendererNapi != nullptr, NAPI_ERR_NO_MEMORY); + THROW_ERROR_ASSERT(env, rendererNapi->audioRenderer_ != nullptr, NAPI_ERR_NO_MEMORY); if (!cbName.compare(MARK_REACH_CALLBACK_NAME)) { rendererNapi->audioRenderer_->UnsetRendererPositionCallback(); @@ -2063,7 +2054,7 @@ napi_value AudioRendererNapi::UnregisterCallback(napi_env env, napi_value jsThis rendererNapi->periodPositionCBNapi_ = nullptr; } else { bool unknownCallback = true; - THROW_ERROR_ASSERT(env, !unknownCallback, ERR_NUMBER104); + THROW_ERROR_ASSERT(env, !unknownCallback, NAPI_ERR_UNSUPPORTED); } napi_value result = nullptr; @@ -2079,12 +2070,12 @@ napi_value AudioRendererNapi::Off(napi_env env, napi_callback_info info) napi_value argv[requireArgc] = {nullptr}; napi_value jsThis = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr); - THROW_ERROR_ASSERT(env, status == napi_ok, ERR_NUMBER301); - THROW_ERROR_ASSERT(env, argc >= requireArgc, ERR_NUMBER101); + THROW_ERROR_ASSERT(env, status == napi_ok, NAPI_ERR_SYSTEM); + THROW_ERROR_ASSERT(env, argc >= requireArgc, NAPI_ERR_INVALID_PARAM); napi_valuetype eventType = napi_undefined; napi_typeof(env, argv[0], &eventType); - THROW_ERROR_ASSERT(env, eventType == napi_string, ERR_NUMBER101); + THROW_ERROR_ASSERT(env, eventType == napi_string, NAPI_ERR_INVALID_PARAM); std::string callbackName = AudioCommonNapi::GetStringArgument(env, argv[0]); AUDIO_DEBUG_LOG("AudioRendererNapi: Off callbackName: %{public}s", callbackName.c_str()); @@ -2144,16 +2135,6 @@ bool AudioRendererNapi::ParseStreamInfo(napi_env env, napi_value root, AudioStre streamInfo->channels = static_cast(intValue); } - if (napi_get_named_property(env, root, "channelOut", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - streamInfo->channelOut = static_cast(intValue); - } - - if (napi_get_named_property(env, root, "channelIn", &tempValue) == napi_ok) { - napi_get_value_int32(env, tempValue, &intValue); - streamInfo->channelIn = static_cast(intValue); - } - if (napi_get_named_property(env, root, "sampleFormat", &tempValue) == napi_ok) { napi_get_value_int32(env, tempValue, &intValue); streamInfo->format = static_cast(intValue); @@ -2202,7 +2183,7 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioRendererAsyncContext object creation failed"); @@ -2220,7 +2201,7 @@ napi_value AudioRendererNapi::SetInterruptMode(napi_env env, napi_callback_info } break; } else { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } } diff --git a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp index 7ceaa86f91..86981b64c9 100644 --- a/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp +++ b/frameworks/js/napi/toneplayer/src/toneplayer_napi.cpp @@ -161,7 +161,7 @@ napi_value TonePlayerNapi::CreateTonePlayerWrapper(napi_env env, unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "TonePlayerAsyncContext object creation failed"); @@ -268,7 +268,7 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_NUMBER101; + context->status = NAPI_ERR_INVALID_PARAM; HiLog::Error(LABEL, "CreateTonePlayer fail, invalid param!"); }, GetTonePlayerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -276,6 +276,8 @@ napi_value TonePlayerNapi::CreateTonePlayer(napi_env env, napi_callback_info inf status = napi_create_async_work( env, nullptr, resource, [](napi_env env, void *data) { + auto context = static_cast(data); + context->status = SUCCESS; }, GetTonePlayerAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); } @@ -369,7 +371,7 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) unique_ptr asyncContext = make_unique(); if (argc < ARGS_ONE) { - asyncContext->status = ERR_NUMBER101; + asyncContext->status = NAPI_ERR_INVALID_PARAM; } status = napi_unwrap(env, thisVar, reinterpret_cast(&asyncContext->objectInfo)); @@ -409,7 +411,7 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) env, nullptr, resource, [](napi_env env, void *data) { auto context = static_cast(data); - context->status = ERR_NUMBER101; + context->status = NAPI_ERR_INVALID_PARAM; HiLog::Error(LABEL, "The Load parameter is invalid"); }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -424,7 +426,7 @@ napi_value TonePlayerNapi::Load(napi_env env, napi_callback_info info) if (context->intValue) { context->status = SUCCESS; } else { - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } } }, @@ -482,7 +484,7 @@ napi_value TonePlayerNapi::Start(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Start call failed, wrong timing!"); - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -538,7 +540,7 @@ napi_value TonePlayerNapi::Stop(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Stop call failed, wrong timing"); - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); @@ -594,7 +596,7 @@ napi_value TonePlayerNapi::Release(napi_env env, napi_callback_info info) context->status = SUCCESS; } else { HiLog::Error(LABEL, "Release call failed, wrong timing"); - context->status = ERR_NUMBER301; + context->status = NAPI_ERR_SYSTEM; } }, VoidAsyncCallbackComplete, static_cast(asyncContext.get()), &asyncContext->work); diff --git a/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h b/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h index 3c53cf6cdd..9cb2b3b366 100644 --- a/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h +++ b/interfaces/inner_api/native/audiocapturer/include/audio_capturer.h @@ -293,7 +293,6 @@ public: */ virtual int32_t GetAudioStreamId(uint32_t &sessionID) const = 0; - /* @brief Obtains the number of frames required in the current condition, in bytes per sample. * * @param frameCount Indicates the pointer in which framecount will be written diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index 1feb8310fb..526fae5c50 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -346,33 +346,6 @@ enum AudioChannel { CHANNEL_8 = 8 }; -/** - * Enumerates the audio renderer channel mask. - * @since 9 - * @syscap SystemCapability.Multimedia.Audio.Core - */ -enum AudioOutputChannelMask { - CHANNEL_OUT_FRONT_LEFT = 0x1 << 0, - CHANNEL_OUT_FRONT_RIGHT = 0x1 << 1, - CHANNEL_OUT_FRONT_CENTER = 0x1 << 2, - CHANNEL_OUT_LOW_FREQUENCY = 0x1 << 3, - CHANNEL_OUT_SIDE_LEFT = 0x1 << 4, - CHANNEL_OUT_SIDE_RIGHT = 0x1 << 5, - CHANNEL_OUT_BACK_LEFT = 0x1 << 6, - CHANNEL_OUT_BACK_RIGHT = 0x1 << 7 -}; - -/** - * Enumerates the audio capturer channel mask. - * @since 9 - * @syscap SystemCapability.Multimedia.Audio.Core - */ -enum AudioInputChannelMask { - CHANNEL_IN_LEFT = 0x1 << 0, - CHANNEL_IN_RIGHT = 0x1 << 1, - CHANNEL_IN_FRONT = 0x1 << 2, - CHANNEL_IN_BACK = 0x1 << 3 -}; /** * Enumerates the audio interrupt request type. @@ -582,8 +555,6 @@ struct AudioStreamInfo { AudioEncodingType encoding; AudioSampleFormat format; AudioChannel channels; - AudioOutputChannelMask channelOut; - AudioInputChannelMask channelIn; }; struct AudioRendererInfo { 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 d35a0ddb4d..9f1ac790ea 100644 --- a/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h +++ b/interfaces/kits/js/audio_capturer/include/audio_capturer_napi.h @@ -61,8 +61,6 @@ private: AudioSampleFormat audioSampleFormat; AudioSamplingRate samplingRate; AudioChannel audioChannel; - AudioOutputChannelMask audioChannelOut; - AudioInputChannelMask audioChannelIn; AudioEncodingType audioEncoding; ContentType contentType; StreamUsage usage; 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 29cb476f8d..277408b83b 100644 --- a/interfaces/kits/js/audio_manager/include/audio_manager_napi.h +++ b/interfaces/kits/js/audio_manager/include/audio_manager_napi.h @@ -126,13 +126,11 @@ private: static napi_ref connectTypeRef_; static napi_ref audioErrors_; static napi_ref communicationDeviceType_; - static napi_ref audioOutputChannelMask_; - static napi_ref audioInputChannelMask_; static napi_ref interruptRequestType_; static napi_ref interruptRequestResultType_; AudioSystemManager *audioMngr_; - int32_t cachedClientId = -1; + int32_t cachedClientId_ = -1; std::shared_ptr deviceChangeCallbackNapi_ = nullptr; std::shared_ptr interruptCallbackNapi_ = nullptr; std::shared_ptr ringerModecallbackNapi_ = nullptr; @@ -191,22 +189,7 @@ static const std::map audioErrorsMap = static const std::map communicationDeviceTypeMap = { {"SPEAKER", COMMUNICATION_SPEAKER} }; -static const std::map audioOutputChannelMaskMap = { - {"CHANNEL_OUT_FRONT_LEFT", CHANNEL_OUT_FRONT_LEFT}, - {"CHANNEL_OUT_FRONT_RIGHT", CHANNEL_OUT_FRONT_RIGHT}, - {"CHANNEL_OUT_FRONT_CENTER", CHANNEL_OUT_FRONT_CENTER}, - {"CHANNEL_OUT_LOW_FREQUENCY", CHANNEL_OUT_LOW_FREQUENCY}, - {"CHANNEL_OUT_SIDE_LEFT", CHANNEL_OUT_SIDE_LEFT}, - {"CHANNEL_OUT_SIDE_RIGHT", CHANNEL_OUT_SIDE_RIGHT}, - {"CHANNEL_OUT_BACK_LEFT", CHANNEL_OUT_BACK_LEFT}, - {"CHANNEL_OUT_BACK_RIGHT", CHANNEL_OUT_BACK_RIGHT}, -}; -static const std::map audioInputChannelMaskMap = { - {"CHANNEL_IN_LEFT", CHANNEL_IN_LEFT}, - {"CHANNEL_IN_RIGHT", CHANNEL_IN_RIGHT}, - {"CHANNEL_IN_FRONT", CHANNEL_IN_FRONT}, - {"CHANNEL_IN_BACK", CHANNEL_IN_BACK}, -}; + static const std::map interruptRequestTypeMap = { {"INTERRUPT_REQUEST_TYPE_DEFAULT", INTERRUPT_REQUEST_TYPE_DEFAULT}, }; 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 244b441bd6..70e8072baa 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 @@ -57,7 +57,7 @@ private: static napi_value IsMicrophoneMute(napi_env env, napi_callback_info info); static napi_value On(napi_env env, napi_callback_info info); std::shared_ptr audioGroupMngr_ = nullptr; - int32_t cachedClientId = -1; + int32_t cachedClientId_ = -1; std::shared_ptr ringerModecallbackNapi_ = nullptr; std::shared_ptr micStateChangeCallbackNapi_ = nullptr; 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 817aa54761..fa3c18661f 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 @@ -47,7 +47,7 @@ private: static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); AudioSystemManager *audioSystemMngr_; - int32_t cachedClientId = -1; + int32_t cachedClientId_ = -1; std::shared_ptr volumeKeyEventCallbackNapi_ = nullptr; napi_env env_; 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 97785949e3..7f8da94c49 100644 --- a/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h +++ b/interfaces/kits/js/audio_renderer/include/audio_renderer_napi.h @@ -74,8 +74,6 @@ private: AudioSampleFormat sampleFormat; AudioSamplingRate samplingRate; AudioChannel channelCount; - AudioOutputChannelMask audioChannelOut; - AudioInputChannelMask audioChannelIn; AudioEncodingType encodingType; ContentType contentType; StreamUsage usage; -- Gitee