1 /*
2  * Copyright (c) 2024 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 "napi_native_media_player.h"
17 
18 #include "business_error.h"
19 #include "napi_parse_utils.h"
20 #include "native_media_player_impl.h"
21 #include "nweb_log.h"
22 #include "web_errors.h"
23 
24 namespace OHOS::NWeb {
25 
26 const double MAX_VOLUME = 1.0;
27 const double MAX_PLAYBACK_RATE = 10.0;
28 
Init(napi_env env,napi_value value)29 void NapiNativeMediaPlayerHandler::Init(napi_env env, napi_value value)
30 {
31     WVLOG_I("begin to init native media player napi properties");
32 
33     NAPI_CALL_RETURN_VOID(env, ExportEnumPreload(env, &value));
34 
35     NAPI_CALL_RETURN_VOID(env, ExportEnumMediaType(env, &value));
36 
37     NAPI_CALL_RETURN_VOID(env, ExportEnumSourceType(env, &value));
38 
39     NAPI_CALL_RETURN_VOID(env, ExportEnumMediaError(env, &value));
40 
41     NAPI_CALL_RETURN_VOID(env, ExportEnumReadyState(env, &value));
42 
43     NAPI_CALL_RETURN_VOID(env, ExportEnumSuspendType(env, &value));
44 
45     NAPI_CALL_RETURN_VOID(env, ExportEnumNetworkState(env, &value));
46 
47     NAPI_CALL_RETURN_VOID(env, ExportEnumPlaybackStatus(env, &value));
48 }
49 
DefineProperties(napi_env env,napi_value * value)50 napi_status NapiNativeMediaPlayerHandler::DefineProperties(napi_env env, napi_value* value)
51 {
52     napi_property_descriptor properties[] = {
53         DECLARE_NAPI_FUNCTION("handleStatusChanged", NapiNativeMediaPlayerHandler::HandleStatusChanged),
54         DECLARE_NAPI_FUNCTION("handleVolumeChanged", NapiNativeMediaPlayerHandler::HandleVolumeChanged),
55         DECLARE_NAPI_FUNCTION("handleMutedChanged", NapiNativeMediaPlayerHandler::HandleMutedChanged),
56         DECLARE_NAPI_FUNCTION("handlePlaybackRateChanged", NapiNativeMediaPlayerHandler::HandlePlaybackRateChanged),
57         DECLARE_NAPI_FUNCTION("handleDurationChanged", NapiNativeMediaPlayerHandler::HandleDurationChanged),
58         DECLARE_NAPI_FUNCTION("handleTimeUpdate", NapiNativeMediaPlayerHandler::HandleTimeUpdate),
59         DECLARE_NAPI_FUNCTION(
60             "handleBufferedEndTimeChanged", NapiNativeMediaPlayerHandler::HandleBufferedEndTimeChanged),
61         DECLARE_NAPI_FUNCTION("handleEnded", NapiNativeMediaPlayerHandler::HandleEnded),
62         DECLARE_NAPI_FUNCTION("handleNetworkStateChanged", NapiNativeMediaPlayerHandler::HandleNetworkStateChanged),
63         DECLARE_NAPI_FUNCTION("handleReadyStateChanged", NapiNativeMediaPlayerHandler::HandleReadyStateChanged),
64         DECLARE_NAPI_FUNCTION("handleFullscreenChanged", NapiNativeMediaPlayerHandler::HandleFullScreenChanged),
65         DECLARE_NAPI_FUNCTION("handleSeeking", NapiNativeMediaPlayerHandler::HandleSeeking),
66         DECLARE_NAPI_FUNCTION("handleSeekFinished", NapiNativeMediaPlayerHandler::HandleSeekFinished),
67         DECLARE_NAPI_FUNCTION("handleError", NapiNativeMediaPlayerHandler::HandleError),
68         DECLARE_NAPI_FUNCTION("handleVideoSizeChanged", NapiNativeMediaPlayerHandler::HandleVideoSizeChanged),
69     };
70 
71     return napi_define_properties(env, *value, sizeof(properties) / sizeof(properties[0]), properties);
72 }
73 
ExportEnumPreload(napi_env env,napi_value * value)74 napi_status NapiNativeMediaPlayerHandler::ExportEnumPreload(napi_env env, napi_value* value)
75 {
76     WVLOG_D("begin to export enum preload");
77 
78     const std::string NPI_PRELOAD_ENUM_NAME = "Preload";
79     napi_property_descriptor properties[] = {
80         DECLARE_NAPI_STATIC_PROPERTY("NONE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(Preload::NONE))),
81         DECLARE_NAPI_STATIC_PROPERTY(
82             "METADATA", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(Preload::METADATA))),
83         DECLARE_NAPI_STATIC_PROPERTY("AUTO", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(Preload::AUTO))),
84     };
85 
86     napi_value enumValue = nullptr;
87     napi_define_class(env, NPI_PRELOAD_ENUM_NAME.c_str(), NPI_PRELOAD_ENUM_NAME.length(),
88         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
89         &enumValue);
90     return napi_set_named_property(env, *value, NPI_PRELOAD_ENUM_NAME.c_str(), enumValue);
91 }
92 
ExportEnumMediaType(napi_env env,napi_value * value)93 napi_status NapiNativeMediaPlayerHandler::ExportEnumMediaType(napi_env env, napi_value* value)
94 {
95     WVLOG_D("begin to export enum media type");
96 
97     const std::string NPI_MEDIA_TYPE_ENUM_NAME = "MediaType";
98     napi_property_descriptor properties[] = {
99         DECLARE_NAPI_STATIC_PROPERTY(
100             "VIDEO", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(MediaType::VIDEO))),
101         DECLARE_NAPI_STATIC_PROPERTY(
102             "AUDIO", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(MediaType::AUDIO))),
103     };
104 
105     napi_value enumValue = nullptr;
106     napi_define_class(env, NPI_MEDIA_TYPE_ENUM_NAME.c_str(), NPI_MEDIA_TYPE_ENUM_NAME.length(),
107         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
108         &enumValue);
109     return napi_set_named_property(env, *value, NPI_MEDIA_TYPE_ENUM_NAME.c_str(), enumValue);
110 }
111 
ExportEnumSourceType(napi_env env,napi_value * value)112 napi_status NapiNativeMediaPlayerHandler::ExportEnumSourceType(napi_env env, napi_value* value)
113 {
114     WVLOG_D("begin to export enum source type");
115 
116     const std::string NPI_SOURCE_TYPE_ENUM_NAME = "SourceType";
117     napi_property_descriptor properties[] = {
118         DECLARE_NAPI_STATIC_PROPERTY("URL", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(SourceType::URL))),
119         DECLARE_NAPI_STATIC_PROPERTY("MSE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(SourceType::MSE))),
120     };
121 
122     napi_value enumValue = nullptr;
123     napi_define_class(env, NPI_SOURCE_TYPE_ENUM_NAME.c_str(), NPI_SOURCE_TYPE_ENUM_NAME.length(),
124         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
125         &enumValue);
126     return napi_set_named_property(env, *value, NPI_SOURCE_TYPE_ENUM_NAME.c_str(), enumValue);
127 }
128 
ExportEnumMediaError(napi_env env,napi_value * value)129 napi_status NapiNativeMediaPlayerHandler::ExportEnumMediaError(napi_env env, napi_value* value)
130 {
131     WVLOG_D("begin to export enum media error");
132 
133     const std::string NPI_MEDIA_ERROR_ENUM_NAME = "MediaError";
134     napi_property_descriptor properties[] = {
135         DECLARE_NAPI_STATIC_PROPERTY(
136             "NETWORK_ERROR", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(MediaError::NETWORK_ERROR))),
137         DECLARE_NAPI_STATIC_PROPERTY(
138             "FORMAT_ERROR", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(MediaError::FORMAT_ERROR))),
139         DECLARE_NAPI_STATIC_PROPERTY(
140             "DECODE_ERROR", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(MediaError::DECODE_ERROR))),
141     };
142 
143     napi_value enumValue = nullptr;
144     napi_define_class(env, NPI_MEDIA_ERROR_ENUM_NAME.c_str(), NPI_MEDIA_ERROR_ENUM_NAME.length(),
145         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
146         &enumValue);
147     return napi_set_named_property(env, *value, NPI_MEDIA_ERROR_ENUM_NAME.c_str(), enumValue);
148 }
149 
ExportEnumReadyState(napi_env env,napi_value * value)150 napi_status NapiNativeMediaPlayerHandler::ExportEnumReadyState(napi_env env, napi_value* value)
151 {
152     WVLOG_D("begin to export enum ready state");
153 
154     const std::string NPI_READY_STATE_ENUM_NAME = "ReadyState";
155     napi_property_descriptor properties[] = {
156         DECLARE_NAPI_STATIC_PROPERTY(
157             "HAVE_NOTHING", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(ReadyState::HAVE_NOTHING))),
158         DECLARE_NAPI_STATIC_PROPERTY(
159             "HAVE_METADATA", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(ReadyState::HAVE_METADATA))),
160         DECLARE_NAPI_STATIC_PROPERTY("HAVE_CURRENT_DATA",
161             NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(ReadyState::HAVE_CURRENT_DATA))),
162         DECLARE_NAPI_STATIC_PROPERTY(
163             "HAVE_FUTURE_DATA", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(ReadyState::HAVE_FUTURE_DATA))),
164         DECLARE_NAPI_STATIC_PROPERTY(
165             "HAVE_ENOUGH_DATA", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(ReadyState::HAVE_ENOUGH_DATA))),
166     };
167 
168     napi_value enumValue = nullptr;
169     napi_define_class(env, NPI_READY_STATE_ENUM_NAME.c_str(), NPI_READY_STATE_ENUM_NAME.length(),
170         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
171         &enumValue);
172     return napi_set_named_property(env, *value, NPI_READY_STATE_ENUM_NAME.c_str(), enumValue);
173 }
174 
ExportEnumSuspendType(napi_env env,napi_value * value)175 napi_status NapiNativeMediaPlayerHandler::ExportEnumSuspendType(napi_env env, napi_value* value)
176 {
177     WVLOG_D("begin to export enum suspend type");
178 
179     const std::string NPI_SUSPEND_TYPE_ENUM_NAME = "SuspendType";
180     napi_property_descriptor properties[] = {
181         DECLARE_NAPI_STATIC_PROPERTY("ENTER_BACK_FORWARD_CACHE",
182             NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(SuspendType::ENTER_BACK_FORWARD_CACHE))),
183         DECLARE_NAPI_STATIC_PROPERTY(
184             "ENTER_BACKGROUND", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(SuspendType::ENTER_BACKGROUND))),
185         DECLARE_NAPI_STATIC_PROPERTY(
186             "AUTO_CLEANUP", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(SuspendType::AUTO_CLEANUP))),
187     };
188 
189     napi_value enumValue = nullptr;
190     napi_define_class(env, NPI_SUSPEND_TYPE_ENUM_NAME.c_str(), NPI_SUSPEND_TYPE_ENUM_NAME.length(),
191         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
192         &enumValue);
193     return napi_set_named_property(env, *value, NPI_SUSPEND_TYPE_ENUM_NAME.c_str(), enumValue);
194 }
195 
ExportEnumNetworkState(napi_env env,napi_value * value)196 napi_status NapiNativeMediaPlayerHandler::ExportEnumNetworkState(napi_env env, napi_value* value)
197 {
198     WVLOG_D("begin to export enum network state");
199 
200     const std::string NPI_NETWORK_STATE_ENUM_NAME = "NetworkState";
201     napi_property_descriptor properties[] = {
202         DECLARE_NAPI_STATIC_PROPERTY(
203             "EMPTY", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(NetworkState::EMPTY))),
204         DECLARE_NAPI_STATIC_PROPERTY(
205             "IDLE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(NetworkState::IDLE))),
206         DECLARE_NAPI_STATIC_PROPERTY(
207             "LOADING", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(NetworkState::LOADING))),
208         DECLARE_NAPI_STATIC_PROPERTY(
209             "NETWORK_ERROR", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(NetworkState::NETWORK_ERROR))),
210     };
211 
212     napi_value enumValue = nullptr;
213     napi_define_class(env, NPI_NETWORK_STATE_ENUM_NAME.c_str(), NPI_NETWORK_STATE_ENUM_NAME.length(),
214         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
215         &enumValue);
216     return napi_set_named_property(env, *value, NPI_NETWORK_STATE_ENUM_NAME.c_str(), enumValue);
217 }
218 
ExportEnumPlaybackStatus(napi_env env,napi_value * value)219 napi_status NapiNativeMediaPlayerHandler::ExportEnumPlaybackStatus(napi_env env, napi_value* value)
220 {
221     WVLOG_D("begin to export enum playback status");
222 
223     const std::string NPI_PLAYBACK_STATUS_ENUM_NAME = "PlaybackStatus";
224     napi_property_descriptor properties[] = {
225         DECLARE_NAPI_STATIC_PROPERTY(
226             "PAUSED", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(PlaybackStatus::PAUSED))),
227         DECLARE_NAPI_STATIC_PROPERTY(
228             "PLAYING", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(PlaybackStatus::PLAYING))),
229     };
230 
231     napi_value enumValue = nullptr;
232     napi_define_class(env, NPI_PLAYBACK_STATUS_ENUM_NAME.c_str(), NPI_PLAYBACK_STATUS_ENUM_NAME.length(),
233         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
234         &enumValue);
235     return napi_set_named_property(env, *value, NPI_PLAYBACK_STATUS_ENUM_NAME.c_str(), enumValue);
236 }
237 
HandleStatusChanged(napi_env env,napi_callback_info info)238 napi_value NapiNativeMediaPlayerHandler::HandleStatusChanged(napi_env env, napi_callback_info info)
239 {
240     WVLOG_D("handle_status_changed is called");
241 
242     size_t argc = INTEGER_ONE;
243     napi_value value = nullptr;
244     napi_value argv[INTEGER_ONE];
245     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
246     if (argc != INTEGER_ONE) {
247         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
248         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
249         return nullptr;
250     }
251 
252     int status = -1;
253     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], status)) {
254         WVLOG_E("failed to parse status");
255         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
256         return nullptr;
257     }
258 
259     if ((status < static_cast<int>(PlaybackStatus::PAUSED)) || (status > static_cast<int>(PlaybackStatus::PLAYING))) {
260         WVLOG_E("status is invalid");
261         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::TYPE_NOT_MATCH_WITCH_VALUE);
262         return nullptr;
263     }
264 
265     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
266     napi_unwrap(env, value, (void**)&handler);
267     if (!handler) {
268         WVLOG_E("native media player handler is null");
269         return nullptr;
270     }
271 
272     handler->HandleStatusChanged(static_cast<PlaybackStatus>(status));
273     return nullptr;
274 }
275 
HandleVolumeChanged(napi_env env,napi_callback_info info)276 napi_value NapiNativeMediaPlayerHandler::HandleVolumeChanged(napi_env env, napi_callback_info info)
277 {
278     WVLOG_D("handle_volume_changed is called");
279 
280     size_t argc = INTEGER_ONE;
281     napi_value value = nullptr;
282     napi_value argv[INTEGER_ONE];
283     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
284     if (argc != INTEGER_ONE) {
285         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
286         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
287         return nullptr;
288     }
289 
290     double volume = 0.0;
291     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], volume)) {
292         WVLOG_E("failed to parse volume");
293         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
294         return nullptr;
295     }
296 
297     if ((volume < 0.0) || (volume > MAX_VOLUME)) {
298         WVLOG_E("volume is invalid");
299         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
300         return nullptr;
301     }
302 
303     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
304     napi_unwrap(env, value, (void**)&handler);
305     if (!handler) {
306         WVLOG_E("native media player handler is null");
307         return nullptr;
308     }
309 
310     handler->HandleVolumeChanged(volume);
311     return nullptr;
312 }
313 
HandleMutedChanged(napi_env env,napi_callback_info info)314 napi_value NapiNativeMediaPlayerHandler::HandleMutedChanged(napi_env env, napi_callback_info info)
315 {
316     WVLOG_D("handle_muted_changed is called");
317 
318     size_t argc = INTEGER_ONE;
319     napi_value value = nullptr;
320     napi_value argv[INTEGER_ONE];
321     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
322     if (argc != INTEGER_ONE) {
323         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
324         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
325         return nullptr;
326     }
327 
328     bool flag = false;
329     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ZERO], flag)) {
330         WVLOG_E("failed to parse flag");
331         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
332         return nullptr;
333     }
334 
335     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
336     napi_unwrap(env, value, (void**)&handler);
337     if (!handler) {
338         WVLOG_E("native media player handler is null");
339         return nullptr;
340     }
341 
342     handler->HandleMutedChanged(flag);
343     return nullptr;
344 }
345 
HandlePlaybackRateChanged(napi_env env,napi_callback_info info)346 napi_value NapiNativeMediaPlayerHandler::HandlePlaybackRateChanged(napi_env env, napi_callback_info info)
347 {
348     WVLOG_D("handle_playback_rate_changed is called");
349 
350     size_t argc = INTEGER_ONE;
351     napi_value value = nullptr;
352     napi_value argv[INTEGER_ONE];
353     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
354     if (argc != INTEGER_ONE) {
355         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
356         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
357         return nullptr;
358     }
359 
360     double rate = 0.0;
361     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], rate)) {
362         WVLOG_E("failed to parse rate");
363         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
364         return nullptr;
365     }
366 
367     if ((rate < 0.0) || (rate > MAX_PLAYBACK_RATE)) {
368         WVLOG_E("rate is invalid");
369         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
370         return nullptr;
371     }
372 
373     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
374     napi_unwrap(env, value, (void**)&handler);
375     if (!handler) {
376         WVLOG_E("native media player handler is null");
377         return nullptr;
378     }
379 
380     handler->HandlePlaybackRateChanged(rate);
381     return nullptr;
382 }
383 
HandleDurationChanged(napi_env env,napi_callback_info info)384 napi_value NapiNativeMediaPlayerHandler::HandleDurationChanged(napi_env env, napi_callback_info info)
385 {
386     WVLOG_D("handle_duration_changed is called");
387 
388     size_t argc = INTEGER_ONE;
389     napi_value value = nullptr;
390     napi_value argv[INTEGER_ONE];
391     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
392     if (argc != INTEGER_ONE) {
393         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
394         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
395         return nullptr;
396     }
397 
398     double duration = 0.0;
399     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], duration)) {
400         WVLOG_E("failed to parse duration");
401         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
402         return nullptr;
403     }
404 
405     if (duration < 0.0) {
406         WVLOG_E("duration is invalid");
407         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
408         return nullptr;
409     }
410 
411     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
412     napi_unwrap(env, value, (void**)&handler);
413     if (!handler) {
414         WVLOG_E("native media player handler is null");
415         return nullptr;
416     }
417 
418     handler->HandleDurationChanged(duration);
419     return nullptr;
420 }
421 
HandleTimeUpdate(napi_env env,napi_callback_info info)422 napi_value NapiNativeMediaPlayerHandler::HandleTimeUpdate(napi_env env, napi_callback_info info)
423 {
424     size_t argc = INTEGER_ONE;
425     napi_value value = nullptr;
426     napi_value argv[INTEGER_ONE];
427     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
428     if (argc != INTEGER_ONE) {
429         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
430         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
431         return nullptr;
432     }
433 
434     double time = 0.0;
435     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], time)) {
436         WVLOG_E("failed to parse time");
437         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
438         return nullptr;
439     }
440 
441     if (time < 0.0) {
442         WVLOG_E("time is invalid");
443         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
444         return nullptr;
445     }
446 
447     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
448     napi_unwrap(env, value, (void**)&handler);
449     if (!handler) {
450         WVLOG_E("native media player handler is null");
451         return nullptr;
452     }
453 
454     handler->HandleTimeUpdate(time);
455     return nullptr;
456 }
457 
HandleBufferedEndTimeChanged(napi_env env,napi_callback_info info)458 napi_value NapiNativeMediaPlayerHandler::HandleBufferedEndTimeChanged(napi_env env, napi_callback_info info)
459 {
460     WVLOG_D("handle_buffered_end_time_changed is called");
461 
462     size_t argc = INTEGER_ONE;
463     napi_value value = nullptr;
464     napi_value argv[INTEGER_ONE];
465     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
466     if (argc != INTEGER_ONE) {
467         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
468         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
469         return nullptr;
470     }
471 
472     double time = 0.0;
473     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], time)) {
474         WVLOG_E("failed to parse time");
475         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
476         return nullptr;
477     }
478 
479     if (time < 0.0) {
480         WVLOG_E("time is invalid");
481         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
482         return nullptr;
483     }
484 
485     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
486     napi_unwrap(env, value, (void**)&handler);
487     if (!handler) {
488         WVLOG_E("native media player handler is null");
489         return nullptr;
490     }
491 
492     handler->HandleBufferedEndTimeChanged(time);
493     return nullptr;
494 }
495 
HandleEnded(napi_env env,napi_callback_info info)496 napi_value NapiNativeMediaPlayerHandler::HandleEnded(napi_env env, napi_callback_info info)
497 {
498     WVLOG_D("handle_ended is called");
499 
500     napi_value value = nullptr;
501     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &value, nullptr));
502 
503     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
504     napi_unwrap(env, value, (void**)&handler);
505     if (!handler) {
506         WVLOG_E("native media player handler is null");
507         return nullptr;
508     }
509 
510     handler->HandleEnded();
511     return nullptr;
512 }
513 
HandleNetworkStateChanged(napi_env env,napi_callback_info info)514 napi_value NapiNativeMediaPlayerHandler::HandleNetworkStateChanged(napi_env env, napi_callback_info info)
515 {
516     WVLOG_D("handle_network_state_changed is called");
517 
518     size_t argc = INTEGER_ONE;
519     napi_value value = nullptr;
520     napi_value argv[INTEGER_ONE];
521     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
522     if (argc != INTEGER_ONE) {
523         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
524         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
525         return nullptr;
526     }
527 
528     int state = -1;
529     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], state)) {
530         WVLOG_E("failed to parse state");
531         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
532         return nullptr;
533     }
534 
535     if ((state < static_cast<int>(NetworkState::EMPTY)) || (state > static_cast<int>(NetworkState::NETWORK_ERROR))) {
536         WVLOG_E("state is invalid");
537         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::TYPE_NOT_MATCH_WITCH_VALUE);
538         return nullptr;
539     }
540 
541     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
542     napi_unwrap(env, value, (void**)&handler);
543     if (!handler) {
544         WVLOG_E("native media player handler is null");
545         return nullptr;
546     }
547 
548     handler->HandleNetworkStateChanged(static_cast<NetworkState>(state));
549     return nullptr;
550 }
551 
HandleReadyStateChanged(napi_env env,napi_callback_info info)552 napi_value NapiNativeMediaPlayerHandler::HandleReadyStateChanged(napi_env env, napi_callback_info info)
553 {
554     WVLOG_D("handle_ready_state_changed is called");
555 
556     size_t argc = INTEGER_ONE;
557     napi_value value = nullptr;
558     napi_value argv[INTEGER_ONE];
559     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
560     if (argc != INTEGER_ONE) {
561         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
562         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
563         return nullptr;
564     }
565 
566     int state = -1;
567     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], state)) {
568         WVLOG_E("failed to parse state");
569         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
570         return nullptr;
571     }
572 
573     if ((state < static_cast<int>(ReadyState::HAVE_NOTHING)) ||
574         (state > static_cast<int>(ReadyState::HAVE_ENOUGH_DATA))) {
575         WVLOG_E("state is invalid");
576         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::TYPE_NOT_MATCH_WITCH_VALUE);
577         return nullptr;
578     }
579 
580     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
581     napi_unwrap(env, value, (void**)&handler);
582     if (!handler) {
583         WVLOG_E("native media player handler is null");
584         return nullptr;
585     }
586 
587     handler->HandleReadyStateChanged(static_cast<ReadyState>(state));
588     return nullptr;
589 }
590 
HandleFullScreenChanged(napi_env env,napi_callback_info info)591 napi_value NapiNativeMediaPlayerHandler::HandleFullScreenChanged(napi_env env, napi_callback_info info)
592 {
593     WVLOG_D("handle_full_screen_changed is called");
594 
595     size_t argc = INTEGER_ONE;
596     napi_value value = nullptr;
597     napi_value argv[INTEGER_ONE];
598     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
599     if (argc != INTEGER_ONE) {
600         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
601         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
602         return nullptr;
603     }
604 
605     bool flag = false;
606     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ZERO], flag)) {
607         WVLOG_E("failed to parse flag");
608         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
609         return nullptr;
610     }
611 
612     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
613     napi_unwrap(env, value, (void**)&handler);
614     if (!handler) {
615         WVLOG_E("native media player handler is null");
616         return nullptr;
617     }
618 
619     handler->HandleFullScreenChanged(flag);
620     return nullptr;
621 }
622 
HandleSeeking(napi_env env,napi_callback_info info)623 napi_value NapiNativeMediaPlayerHandler::HandleSeeking(napi_env env, napi_callback_info info)
624 {
625     WVLOG_D("handle_seeking is called");
626 
627     napi_value value = nullptr;
628     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &value, nullptr));
629 
630     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
631     napi_unwrap(env, value, (void**)&handler);
632     if (!handler) {
633         WVLOG_E("native media player handler is null");
634         return nullptr;
635     }
636 
637     handler->HandleSeeking();
638     return nullptr;
639 }
640 
HandleSeekFinished(napi_env env,napi_callback_info info)641 napi_value NapiNativeMediaPlayerHandler::HandleSeekFinished(napi_env env, napi_callback_info info)
642 {
643     WVLOG_D("handle_seek_finished is called");
644 
645     napi_value value = nullptr;
646     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &value, nullptr));
647 
648     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
649     napi_unwrap(env, value, (void**)&handler);
650     if (!handler) {
651         WVLOG_E("native media player handler is null");
652         return nullptr;
653     }
654 
655     handler->HandleSeekFinished();
656     return nullptr;
657 }
658 
HandleError(napi_env env,napi_callback_info info)659 napi_value NapiNativeMediaPlayerHandler::HandleError(napi_env env, napi_callback_info info)
660 {
661     WVLOG_D("handle_error is called");
662 
663     size_t argc = INTEGER_TWO;
664     napi_value value = nullptr;
665     napi_value argv[INTEGER_TWO];
666     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
667     if (argc != INTEGER_TWO) {
668         WVLOG_E("arg count %{public}zu is not equal to 2", argc);
669         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
670         return nullptr;
671     }
672 
673     int error = -1;
674     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], error)) {
675         WVLOG_E("failed to parse error");
676         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
677         return nullptr;
678     }
679 
680     if ((error < static_cast<int>(MediaError::NETWORK_ERROR)) || (error > static_cast<int>(MediaError::DECODE_ERROR))) {
681         WVLOG_E("error is invalid");
682         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::TYPE_NOT_MATCH_WITCH_VALUE);
683         return nullptr;
684     }
685 
686     std::string message;
687     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], message)) {
688         WVLOG_E("failed to parse message");
689         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
690         return nullptr;
691     }
692 
693     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
694     napi_unwrap(env, value, (void**)&handler);
695     if (!handler) {
696         WVLOG_E("native media player handler is null");
697         return nullptr;
698     }
699 
700     handler->HandleError(static_cast<MediaError>(error), message);
701     return nullptr;
702 }
703 
HandleVideoSizeChanged(napi_env env,napi_callback_info info)704 napi_value NapiNativeMediaPlayerHandler::HandleVideoSizeChanged(napi_env env, napi_callback_info info)
705 {
706     WVLOG_D("handle_video_size_changed is called");
707 
708     size_t argc = INTEGER_TWO;
709     napi_value value = nullptr;
710     napi_value argv[INTEGER_TWO];
711     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
712     if (argc != INTEGER_TWO) {
713         WVLOG_E("arg count %{public}zu is not equal to 2", argc);
714         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
715         return nullptr;
716     }
717 
718     double width = 0.0;
719     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ZERO], width)) {
720         WVLOG_E("failed to parse width");
721         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
722         return nullptr;
723     }
724 
725     double height = 0.0;
726     if (!NapiParseUtils::ParseDouble(env, argv[INTEGER_ONE], height)) {
727         WVLOG_E("failed to parse height");
728         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
729         return nullptr;
730     }
731 
732     NapiNativeMediaPlayerHandlerImpl* handler = nullptr;
733     napi_unwrap(env, value, (void**)&handler);
734     if (!handler) {
735         WVLOG_E("native media player handler is null");
736         return nullptr;
737     }
738 
739     handler->HandleVideoSizeChanged(width, height);
740     return nullptr;
741 }
742 
743 } // namespace OHOS::NWeb
744