1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_common_napi.h"
17 #include "audio_log.h"
18 #include "audio_info.h"
19 #include "audio_manager_napi.h"
20
21 namespace OHOS {
22 namespace AudioStandard {
GetStringArgument(napi_env env,napi_value value)23 std::string AudioCommonNapi::GetStringArgument(napi_env env, napi_value value)
24 {
25 std::string strValue = "";
26 size_t bufLength = 0;
27 napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &bufLength);
28 if (status == napi_ok && bufLength > 0 && bufLength < PATH_MAX) {
29 char *buffer = (char *)malloc((bufLength + 1) * sizeof(char));
30 CHECK_AND_RETURN_RET_LOG(buffer != nullptr, strValue, "no memory");
31 status = napi_get_value_string_utf8(env, value, buffer, bufLength + 1, &bufLength);
32 if (status == napi_ok) {
33 AUDIO_DEBUG_LOG("argument = %{public}s", buffer);
34 strValue = buffer;
35 }
36 free(buffer);
37 buffer = nullptr;
38 }
39 return strValue;
40 }
41
getMessageByCode(int32_t & code)42 std::string AudioCommonNapi::getMessageByCode(int32_t &code)
43 {
44 std::string err_message;
45 switch (code) {
46 case NAPI_ERR_INVALID_PARAM:
47 err_message = NAPI_ERR_INVALID_PARAM_INFO;
48 break;
49 case NAPI_ERR_NO_MEMORY:
50 err_message = NAPI_ERR_NO_MEMORY_INFO;
51 break;
52 case NAPI_ERR_ILLEGAL_STATE:
53 err_message = NAPI_ERR_ILLEGAL_STATE_INFO;
54 break;
55 case NAPI_ERR_UNSUPPORTED:
56 case ERR_NOT_SUPPORTED:
57 err_message = NAPI_ERR_UNSUPPORTED_INFO;
58 code = NAPI_ERR_UNSUPPORTED;
59 break;
60 case NAPI_ERR_TIMEOUT:
61 err_message = NAPI_ERR_TIMEOUT_INFO;
62 break;
63 case NAPI_ERR_STREAM_LIMIT:
64 err_message = NAPI_ERR_STREAM_LIMIT_INFO;
65 break;
66 case NAPI_ERR_SYSTEM:
67 err_message = NAPI_ERR_SYSTEM_INFO;
68 break;
69 case NAPI_ERR_INPUT_INVALID:
70 err_message = NAPI_ERR_INPUT_INVALID_INFO;
71 break;
72 case NAPI_ERR_PERMISSION_DENIED:
73 case ERR_PERMISSION_DENIED:
74 err_message = NAPI_ERROR_PERMISSION_DENIED_INFO;
75 code = NAPI_ERR_PERMISSION_DENIED;
76 break;
77 default:
78 err_message = NAPI_ERR_SYSTEM_INFO;
79 code = NAPI_ERR_SYSTEM;
80 break;
81 }
82 return err_message;
83 }
84
throwError(napi_env env,int32_t code)85 void AudioCommonNapi::throwError(napi_env env, int32_t code)
86 {
87 std::string messageValue = AudioCommonNapi::getMessageByCode(code);
88 napi_throw_error(env, (std::to_string(code)).c_str(), messageValue.c_str());
89 }
90
IsLegalInputArgumentVolType(int32_t inputType)91 bool AudioCommonNapi::IsLegalInputArgumentVolType(int32_t inputType)
92 {
93 bool result = false;
94 switch (inputType) {
95 case AudioManagerNapi::RINGTONE:
96 case AudioManagerNapi::MEDIA:
97 case AudioManagerNapi::VOICE_CALL:
98 case AudioManagerNapi::VOICE_ASSISTANT:
99 case AudioManagerNapi::ALARM:
100 case AudioManagerNapi::ACCESSIBILITY:
101 case AudioManagerNapi::ULTRASONIC:
102 case AudioManagerNapi::ALL:
103 result = true;
104 break;
105 default:
106 result = false;
107 break;
108 }
109 return result;
110 }
111
IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)112 bool AudioCommonNapi::IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)
113 {
114 bool result = false;
115 switch (deviceFlag) {
116 case DeviceFlag::NONE_DEVICES_FLAG:
117 case DeviceFlag::OUTPUT_DEVICES_FLAG:
118 case DeviceFlag::INPUT_DEVICES_FLAG:
119 case DeviceFlag::ALL_DEVICES_FLAG:
120 case DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG:
121 case DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG:
122 case DeviceFlag::ALL_DISTRIBUTED_DEVICES_FLAG:
123 case DeviceFlag::ALL_L_D_DEVICES_FLAG:
124 result = true;
125 break;
126 default:
127 result = false;
128 break;
129 }
130 return result;
131 }
132
IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)133 bool AudioCommonNapi::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)
134 {
135 bool result = false;
136 switch (activeDeviceFlag) {
137 case ActiveDeviceType::SPEAKER:
138 case ActiveDeviceType::BLUETOOTH_SCO:
139 result = true;
140 break;
141 default:
142 result = false;
143 break;
144 }
145 return result;
146 }
147
IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)148 bool AudioCommonNapi::IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)
149 {
150 bool result = false;
151 switch (communicationDeviceType) {
152 case CommunicationDeviceType::COMMUNICATION_SPEAKER:
153 result = true;
154 break;
155 default:
156 result = false;
157 break;
158 }
159 return result;
160 }
161
IsLegalInputArgumentRingMode(int32_t ringerMode)162 bool AudioCommonNapi::IsLegalInputArgumentRingMode(int32_t ringerMode)
163 {
164 bool result = false;
165 switch (ringerMode) {
166 case AudioRingerMode::RINGER_MODE_SILENT:
167 case AudioRingerMode::RINGER_MODE_VIBRATE:
168 case AudioRingerMode::RINGER_MODE_NORMAL:
169 result = true;
170 break;
171 default:
172 result = false;
173 break;
174 }
175 return result;
176 }
177
IsSameCallback(napi_env env,napi_value callback,napi_ref refCallback)178 bool AudioCommonNapi::IsSameCallback(napi_env env, napi_value callback, napi_ref refCallback)
179 {
180 bool isEquals = false;
181 napi_value copyValue = nullptr;
182
183 napi_get_reference_value(env, refCallback, ©Value);
184 if (napi_strict_equals(env, copyValue, callback, &isEquals) != napi_ok) {
185 AUDIO_ERR_LOG("IsSameCallback: get napi_strict_equals failed");
186 return false;
187 }
188
189 return isEquals;
190 }
191
IsLegalInputArgumentStreamUsage(int32_t streamUsage)192 bool AudioCommonNapi::IsLegalInputArgumentStreamUsage(int32_t streamUsage)
193 {
194 bool result = false;
195 switch (streamUsage) {
196 case STREAM_USAGE_UNKNOWN:
197 case STREAM_USAGE_MEDIA:
198 case STREAM_USAGE_VOICE_COMMUNICATION:
199 case STREAM_USAGE_VOICE_ASSISTANT:
200 case STREAM_USAGE_ALARM:
201 case STREAM_USAGE_VOICE_MESSAGE:
202 case STREAM_USAGE_NOTIFICATION_RINGTONE:
203 case STREAM_USAGE_NOTIFICATION:
204 case STREAM_USAGE_ACCESSIBILITY:
205 case STREAM_USAGE_SYSTEM:
206 case STREAM_USAGE_MOVIE:
207 case STREAM_USAGE_GAME:
208 case STREAM_USAGE_AUDIOBOOK:
209 case STREAM_USAGE_NAVIGATION:
210 case STREAM_USAGE_DTMF:
211 case STREAM_USAGE_ENFORCED_TONE:
212 case STREAM_USAGE_ULTRASONIC:
213 result = true;
214 break;
215 default:
216 result = false;
217 break;
218 }
219 return result;
220 }
221
IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)222 bool AudioCommonNapi::IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)
223 {
224 bool result = false;
225 switch (audioEffectMode) {
226 case AudioEffectMode::EFFECT_NONE:
227 case AudioEffectMode::EFFECT_DEFAULT:
228 result = true;
229 break;
230 default:
231 result = false;
232 break;
233 }
234 return result;
235 }
236
IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)237 bool AudioCommonNapi::IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)
238 {
239 bool result = false;
240 switch (adjustType) {
241 case VolumeAdjustType::VOLUME_UP:
242 case VolumeAdjustType::VOLUME_DOWN:
243 result = true;
244 break;
245 default:
246 result = false;
247 break;
248 }
249 return result;
250 }
251
IsLegalInputArgumentDeviceType(int32_t deviceType)252 bool AudioCommonNapi::IsLegalInputArgumentDeviceType(int32_t deviceType)
253 {
254 bool result = false;
255 switch (deviceType) {
256 case DeviceType::DEVICE_TYPE_EARPIECE:
257 case DeviceType::DEVICE_TYPE_SPEAKER:
258 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
259 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
260 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
261 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
262 case DeviceType::DEVICE_TYPE_MIC:
263 case DeviceType::DEVICE_TYPE_USB_HEADSET:
264 case DeviceType::DEVICE_TYPE_FILE_SINK:
265 case DeviceType::DEVICE_TYPE_FILE_SOURCE:
266 result = true;
267 break;
268 default:
269 result = false;
270 break;
271 }
272 return result;
273 }
274
IsLegalInputArgumentInterruptMode(int32_t interruptMode)275 bool AudioCommonNapi::IsLegalInputArgumentInterruptMode(int32_t interruptMode)
276 {
277 bool result = false;
278 switch (interruptMode) {
279 case InterruptMode::SHARE_MODE:
280 case InterruptMode::INDEPENDENT_MODE:
281 result = true;
282 break;
283 default:
284 result = false;
285 break;
286 }
287 return result;
288 }
289 } // namespace AudioStandard
290 } // namespace OHOS
291