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 "native_media_player_impl.h"
17 
18 #include "napi_common_macros.h"
19 #include "napi_native_media_player.h"
20 #include "napi_parse_utils.h"
21 #include "nweb_log.h"
22 
23 namespace OHOS::NWeb {
24 
NWebNativeMediaPlayerBridgeImpl(int32_t nwebId,napi_env env,napi_value value)25 NWebNativeMediaPlayerBridgeImpl::NWebNativeMediaPlayerBridgeImpl(int32_t nwebId, napi_env env, napi_value value)
26     : nwebId_(nwebId), env_(env), value_(value)
27 {}
28 
UpdateRect(double x,double y,double width,double height)29 void NWebNativeMediaPlayerBridgeImpl::UpdateRect(double x, double y, double width, double height)
30 {
31     WVLOG_D("begin to update rect,nweb id is %{public}d", nwebId_);
32 
33     napi_value callback = nullptr;
34     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "updateRect", callback);
35 
36     napi_value argv[INTEGER_FOUR] = { nullptr };
37     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, x, &argv[INTEGER_ZERO]));
38     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, y, &argv[INTEGER_ONE]));
39     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, width, &argv[INTEGER_TWO]));
40     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, height, &argv[INTEGER_THREE]));
41 
42     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_FOUR, argv, nullptr));
43 }
44 
Play()45 void NWebNativeMediaPlayerBridgeImpl::Play()
46 {
47     WVLOG_D("begin to play,nweb id is %{public}d", nwebId_);
48 
49     napi_value callback = nullptr;
50     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "play", callback);
51 
52     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
53 }
54 
Pause()55 void NWebNativeMediaPlayerBridgeImpl::Pause()
56 {
57     WVLOG_D("begin to pause,nweb id is %{public}d", nwebId_);
58 
59     napi_value callback = nullptr;
60     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "pause", callback);
61 
62     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
63 }
64 
Seek(double time)65 void NWebNativeMediaPlayerBridgeImpl::Seek(double time)
66 {
67     WVLOG_D("begin to seek,nweb id is %{public}d,time is %{public}f", nwebId_, time);
68 
69     napi_value callback = nullptr;
70     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "seek", callback);
71 
72     napi_value argv[INTEGER_ONE] = { nullptr };
73     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, time, &argv[INTEGER_ZERO]));
74 
75     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ONE, argv, nullptr));
76 }
77 
SetVolume(double volume)78 void NWebNativeMediaPlayerBridgeImpl::SetVolume(double volume)
79 {
80     WVLOG_D("begin to set volume,nweb id is %{public}d,volume is %{public}f", nwebId_, volume);
81 
82     napi_value callback = nullptr;
83     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "setVolume", callback);
84 
85     napi_value argv[INTEGER_ONE] = { nullptr };
86     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, volume, &argv[INTEGER_ZERO]));
87 
88     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ONE, argv, nullptr));
89 }
90 
SetMuted(bool isMuted)91 void NWebNativeMediaPlayerBridgeImpl::SetMuted(bool isMuted)
92 {
93     WVLOG_D("begin to set muted,nweb id is %{public}d,muted flag is %{public}d", nwebId_, isMuted);
94 
95     napi_value callback = nullptr;
96     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "setMuted", callback);
97 
98     napi_value argv[INTEGER_ONE] = { nullptr };
99     NAPI_CALL_RETURN_VOID(env_, napi_get_boolean(env_, isMuted, &argv[INTEGER_ZERO]));
100 
101     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ONE, argv, nullptr));
102 }
103 
SetPlaybackRate(double playbackRate)104 void NWebNativeMediaPlayerBridgeImpl::SetPlaybackRate(double playbackRate)
105 {
106     WVLOG_D("begin to set playback rate,nweb id is %{public}d,playback rate is %{public}f", nwebId_, playbackRate);
107 
108     napi_value callback = nullptr;
109     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "setPlaybackRate", callback);
110 
111     napi_value argv[INTEGER_ONE] = { nullptr };
112     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, playbackRate, &argv[INTEGER_ZERO]));
113 
114     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ONE, argv, nullptr));
115 }
116 
Release()117 void NWebNativeMediaPlayerBridgeImpl::Release()
118 {
119     WVLOG_D("begin to release,nweb id is %{public}d", nwebId_);
120 
121     napi_value callback = nullptr;
122     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "release", callback);
123 
124     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
125 }
126 
EnterFullScreen()127 void NWebNativeMediaPlayerBridgeImpl::EnterFullScreen()
128 {
129     WVLOG_D("begin to enter full screen,nweb id is %{public}d", nwebId_);
130 
131     napi_value callback = nullptr;
132     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "enterFullscreen", callback);
133 
134     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
135 }
136 
ExitFullScreen()137 void NWebNativeMediaPlayerBridgeImpl::ExitFullScreen()
138 {
139     WVLOG_D("begin to exit full screen,nweb id is %{public}d", nwebId_);
140 
141     napi_value callback = nullptr;
142     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "exitFullscreen", callback);
143 
144     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
145 }
146 
ResumeMediaPlayer()147 void NWebNativeMediaPlayerBridgeImpl::ResumeMediaPlayer()
148 {
149     WVLOG_D("begin to resume media player,nweb id is %{public}d", nwebId_);
150 
151     napi_value callback = nullptr;
152     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "resumePlayer", callback);
153 
154     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ZERO, nullptr, nullptr));
155 }
156 
SuspendMediaPlayer(SuspendType type)157 void NWebNativeMediaPlayerBridgeImpl::SuspendMediaPlayer(SuspendType type)
158 {
159     WVLOG_D("begin to suspend media player,nweb id is %{public}d", nwebId_);
160 
161     napi_value callback = nullptr;
162     NAPI_GET_CALLBACK_RETURN_VOID(env_, value_, "suspendPlayer", callback);
163 
164     napi_value argv[INTEGER_ONE] = { nullptr };
165     NAPI_CALL_RETURN_VOID(env_, napi_create_int32(env_, static_cast<int>(type), &argv[INTEGER_ZERO]));
166 
167     NAPI_CALL_RETURN_VOID(env_, napi_call_function(env_, value_, callback, INTEGER_ONE, argv, nullptr));
168 }
169 
NapiNativeMediaPlayerHandlerImpl(int32_t nwebId,std::shared_ptr<NWebNativeMediaPlayerHandler> handler)170 NapiNativeMediaPlayerHandlerImpl::NapiNativeMediaPlayerHandlerImpl(
171     int32_t nwebId, std::shared_ptr<NWebNativeMediaPlayerHandler> handler)
172     : nwebId_(nwebId), handler_(handler)
173 {}
174 
HandleStatusChanged(PlaybackStatus status)175 void NapiNativeMediaPlayerHandlerImpl::HandleStatusChanged(PlaybackStatus status)
176 {
177     WVLOG_D("begin to handle status changed,nweb id is %{public}d", nwebId_);
178 
179     if (handler_) {
180         handler_->HandleStatusChanged(status);
181     }
182 }
183 
HandleVolumeChanged(double volume)184 void NapiNativeMediaPlayerHandlerImpl::HandleVolumeChanged(double volume)
185 {
186     WVLOG_D("begin to handle volume changed,nweb id is %{public}d", nwebId_);
187 
188     if (handler_) {
189         handler_->HandleVolumeChanged(volume);
190     }
191 }
192 
HandleMutedChanged(bool isMuted)193 void NapiNativeMediaPlayerHandlerImpl::HandleMutedChanged(bool isMuted)
194 {
195     WVLOG_D("begin to handle muted changed,nweb id is %{public}d", nwebId_);
196 
197     if (handler_) {
198         handler_->HandleMutedChanged(isMuted);
199     }
200 }
201 
HandlePlaybackRateChanged(double playbackRate)202 void NapiNativeMediaPlayerHandlerImpl::HandlePlaybackRateChanged(double playbackRate)
203 {
204     WVLOG_D("begin to handle playback rate changed,nweb id is %{public}d", nwebId_);
205 
206     if (handler_) {
207         handler_->HandlePlaybackRateChanged(playbackRate);
208     }
209 }
210 
HandleDurationChanged(double duration)211 void NapiNativeMediaPlayerHandlerImpl::HandleDurationChanged(double duration)
212 {
213     WVLOG_D("begin to handle duration changed,nweb id is %{public}d", nwebId_);
214 
215     if (handler_) {
216         handler_->HandleDurationChanged(duration);
217     }
218 }
219 
HandleTimeUpdate(double playTime)220 void NapiNativeMediaPlayerHandlerImpl::HandleTimeUpdate(double playTime)
221 {
222     if (handler_) {
223         handler_->HandleTimeUpdate(playTime);
224     }
225 }
226 
HandleBufferedEndTimeChanged(double bufferedEndTime)227 void NapiNativeMediaPlayerHandlerImpl::HandleBufferedEndTimeChanged(double bufferedEndTime)
228 {
229     WVLOG_D("begin to handle buffered end time changed,nweb id is %{public}d", nwebId_);
230 
231     if (handler_) {
232         handler_->HandleBufferedEndTimeChanged(bufferedEndTime);
233     }
234 }
235 
HandleEnded()236 void NapiNativeMediaPlayerHandlerImpl::HandleEnded()
237 {
238     WVLOG_D("begin to handle end,nweb id is %{public}d", nwebId_);
239 
240     if (handler_) {
241         handler_->HandleEnded();
242     }
243 }
244 
HandleNetworkStateChanged(NetworkState state)245 void NapiNativeMediaPlayerHandlerImpl::HandleNetworkStateChanged(NetworkState state)
246 {
247     WVLOG_D("begin to handle network state changed,nweb id is %{public}d", nwebId_);
248 
249     if (handler_) {
250         handler_->HandleNetworkStateChanged(state);
251     }
252 }
253 
HandleReadyStateChanged(ReadyState state)254 void NapiNativeMediaPlayerHandlerImpl::HandleReadyStateChanged(ReadyState state)
255 {
256     WVLOG_D("begin to handle ready state changed,nweb id is %{public}d", nwebId_);
257 
258     if (handler_) {
259         handler_->HandleReadyStateChanged(state);
260     }
261 }
262 
HandleFullScreenChanged(bool isFullScreen)263 void NapiNativeMediaPlayerHandlerImpl::HandleFullScreenChanged(bool isFullScreen)
264 {
265     WVLOG_D("begin to handle full screen changed,nweb id is %{public}d", nwebId_);
266 
267     if (handler_) {
268         handler_->HandleFullScreenChanged(isFullScreen);
269     }
270 }
271 
HandleSeeking()272 void NapiNativeMediaPlayerHandlerImpl::HandleSeeking()
273 {
274     WVLOG_D("begin to handle seeking,nweb id is %{public}d", nwebId_);
275 
276     if (handler_) {
277         handler_->HandleSeeking();
278     }
279 }
280 
HandleSeekFinished()281 void NapiNativeMediaPlayerHandlerImpl::HandleSeekFinished()
282 {
283     WVLOG_D("begin to handle seek finished,nweb id is %{public}d", nwebId_);
284 
285     if (handler_) {
286         handler_->HandleSeekFinished();
287     }
288 }
289 
HandleError(MediaError error,const std::string & message)290 void NapiNativeMediaPlayerHandlerImpl::HandleError(MediaError error, const std::string& message)
291 {
292     WVLOG_D("begin to handle error,nweb id is %{public}d", nwebId_);
293 
294     if (handler_) {
295         handler_->HandleError(error, message);
296     }
297 }
298 
HandleVideoSizeChanged(double width,double height)299 void NapiNativeMediaPlayerHandlerImpl::HandleVideoSizeChanged(double width, double height)
300 {
301     WVLOG_D("begin to handle video size changed,nweb id is %{public}d", nwebId_);
302 
303     if (handler_) {
304         handler_->HandleVideoSizeChanged(width, height);
305     }
306 }
307 
NWebCreateNativeMediaPlayerCallbackImpl(int32_t nwebId,napi_env env,napi_ref callback)308 NWebCreateNativeMediaPlayerCallbackImpl::NWebCreateNativeMediaPlayerCallbackImpl(
309     int32_t nwebId, napi_env env, napi_ref callback)
310     : nwebId_(nwebId), env_(env), callback_(callback)
311 {}
312 
~NWebCreateNativeMediaPlayerCallbackImpl()313 NWebCreateNativeMediaPlayerCallbackImpl::~NWebCreateNativeMediaPlayerCallbackImpl()
314 {
315     napi_delete_reference(env_, callback_);
316 }
317 
OnCreate(std::shared_ptr<NWebNativeMediaPlayerHandler> handler,std::shared_ptr<NWebMediaInfo> mediaInfo)318 std::shared_ptr<NWebNativeMediaPlayerBridge> NWebCreateNativeMediaPlayerCallbackImpl::OnCreate(
319     std::shared_ptr<NWebNativeMediaPlayerHandler> handler, std::shared_ptr<NWebMediaInfo> mediaInfo)
320 {
321     WVLOG_D("begin to create native media player,nweb id is %{public}d", nwebId_);
322 
323     if (!callback_) {
324         WVLOG_E("callback is null,nweb id is %{public}d", nwebId_);
325         return nullptr;
326     }
327 
328     if (!handler || !mediaInfo) {
329         WVLOG_E("param is null,nweb id is %{public}d", nwebId_);
330         return nullptr;
331     }
332 
333     napi_value callback = nullptr;
334     napi_get_reference_value(env_, callback_, &callback);
335     if (callback == nullptr) {
336         WVLOG_E("failed to get callback func,nweb id is %{public}d", nwebId_);
337         return nullptr;
338     }
339 
340     napi_value argv[INTEGER_TWO] = { nullptr };
341     ConstructHandler(&argv[INTEGER_ZERO], handler);
342     ConstructMediaInfo(&argv[INTEGER_ONE], mediaInfo);
343 
344     napi_value result = nullptr;
345     NAPI_CALL(env_, napi_call_function(env_, nullptr, callback, INTEGER_TWO, argv, &result));
346 
347     napi_valuetype valueType = napi_undefined;
348     napi_typeof(env_, result, &valueType);
349     if (valueType != napi_object) {
350         WVLOG_E("result type is invalid,nweb id is %{public}d", nwebId_);
351         return nullptr;
352     }
353 
354     return std::make_shared<NWebNativeMediaPlayerBridgeImpl>(nwebId_, env_, result);
355 }
356 
ConstructRect(napi_value * value,std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)357 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructRect(
358     napi_value* value, std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)
359 {
360     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
361 
362     napi_value x = nullptr;
363     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, surfaceInfo->GetX(), &x));
364     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "x", x));
365 
366     napi_value y = nullptr;
367     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, surfaceInfo->GetY(), &y));
368     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "y", y));
369 
370     napi_value width = nullptr;
371     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, surfaceInfo->GetWidth(), &width));
372     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "width", width));
373 
374     napi_value height = nullptr;
375     NAPI_CALL_RETURN_VOID(env_, napi_create_double(env_, surfaceInfo->GetHeight(), &height));
376     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "height", height));
377 }
378 
ConstructHandler(napi_value * value,std::shared_ptr<NWebNativeMediaPlayerHandler> handler)379 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructHandler(
380     napi_value* value, std::shared_ptr<NWebNativeMediaPlayerHandler> handler)
381 {
382     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
383 
384     napi_wrap(
385         env_, *value, new NapiNativeMediaPlayerHandlerImpl(nwebId_, handler),
386         [](napi_env /*env*/, void* data, void* /*hint*/) {
387             NapiNativeMediaPlayerHandlerImpl* handler = (NapiNativeMediaPlayerHandlerImpl*)data;
388             delete handler;
389         },
390         nullptr, nullptr);
391     NAPI_CALL_RETURN_VOID(env_, NapiNativeMediaPlayerHandler::DefineProperties(env_, value));
392 }
393 
ConstructControls(napi_value * value,const std::vector<std::string> & controls)394 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructControls(
395     napi_value* value, const std::vector<std::string>& controls)
396 {
397     NAPI_CALL_RETURN_VOID(env_, napi_create_array_with_length(env_, controls.size(), value));
398 
399     for (unsigned int i = 0; i < controls.size(); i++) {
400         napi_value control = nullptr;
401         NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(
402             env_, controls[i].c_str(), controls[i].length(), &control));
403         NAPI_CALL_RETURN_VOID(env_, napi_set_element(env_, *value, i, control));
404     }
405 }
406 
ConstructHeaders(napi_value * value,const std::map<std::string,std::string> & headers)407 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructHeaders(
408     napi_value* value, const std::map<std::string, std::string>& headers)
409 {
410     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
411 
412     for (const auto& header : headers) {
413         napi_value argv = nullptr;
414         NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(
415             env_, header.second.c_str(), header.second.length(), &argv));
416         NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, header.first.c_str(), argv));
417     }
418 }
419 
ConstructAttributes(napi_value * value,const std::map<std::string,std::string> & attributes)420 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructAttributes(
421     napi_value* value, const std::map<std::string, std::string>& attributes)
422 {
423     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
424 
425     for (const auto& attribute : attributes) {
426         napi_value argv = nullptr;
427         NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(
428             env_, attribute.second.c_str(), attribute.second.length(), &argv));
429         NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, attribute.first.c_str(), argv));
430     }
431 }
432 
ConstructMediaInfo(napi_value * value,std::shared_ptr<NWebMediaInfo> mediaInfo)433 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructMediaInfo(
434     napi_value* value, std::shared_ptr<NWebMediaInfo> mediaInfo)
435 {
436     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
437 
438     napi_value embedId = nullptr;
439     std::string id = mediaInfo->GetEmbedId();
440     NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(env_, id.c_str(), id.length(), &embedId));
441     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "embedID", embedId));
442 
443     napi_value mediaType = nullptr;
444     NAPI_CALL_RETURN_VOID(env_, napi_create_int32(env_, static_cast<int>(mediaInfo->GetMediaType()), &mediaType));
445     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "mediaType", mediaType));
446 
447     napi_value mediaSrcList = nullptr;
448     ConstructSourceInfos(&mediaSrcList, mediaInfo->GetSourceInfos());
449     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "mediaSrcList", mediaSrcList));
450 
451     napi_value surfaceInfo = nullptr;
452     ConstructSurfaceInfo(&surfaceInfo, mediaInfo->GetSurfaceInfo());
453     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "surfaceInfo", surfaceInfo));
454 
455     napi_value isControlsShown = nullptr;
456     NAPI_CALL_RETURN_VOID(env_, napi_get_boolean(env_, mediaInfo->GetIsControlsShown(), &isControlsShown));
457     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "controlsShown", isControlsShown));
458 
459     napi_value controlList = nullptr;
460     ConstructControls(&controlList, mediaInfo->GetControls());
461     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "controlList", controlList));
462 
463     napi_value headers = nullptr;
464     ConstructHeaders(&headers, mediaInfo->GetHeaders());
465     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "headers", headers));
466 
467     napi_value attributes = nullptr;
468     ConstructAttributes(&attributes, mediaInfo->GetAttributes());
469     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "attributes", attributes));
470 
471     napi_value isMuted = nullptr;
472     NAPI_CALL_RETURN_VOID(env_, napi_get_boolean(env_, mediaInfo->GetIsMuted(), &isMuted));
473     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "muted", isMuted));
474 
475     napi_value posterUrl = nullptr;
476     std::string url = mediaInfo->GetPosterUrl();
477     NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(env_, url.c_str(), url.length(), &posterUrl));
478     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "posterUrl", posterUrl));
479 
480     napi_value preload = nullptr;
481     NAPI_CALL_RETURN_VOID(env_, napi_create_int32(env_, static_cast<int>(mediaInfo->GetPreload()), &preload));
482     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "preload", preload));
483 }
484 
ConstructSourceInfos(napi_value * value,const std::vector<std::shared_ptr<NWebMediaSourceInfo>> & sourceInfos)485 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructSourceInfos(
486     napi_value* value, const std::vector<std::shared_ptr<NWebMediaSourceInfo>>& sourceInfos)
487 {
488     NAPI_CALL_RETURN_VOID(env_, napi_create_array_with_length(env_, sourceInfos.size(), value));
489 
490     for (unsigned int i = 0; i < sourceInfos.size(); i++) {
491         if (!sourceInfos[i]) {
492             continue;
493         }
494 
495         napi_value sourceInfo = nullptr;
496         NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, &sourceInfo));
497 
498         napi_value type = nullptr;
499         NAPI_CALL_RETURN_VOID(env_, napi_create_int32(env_, static_cast<int>(sourceInfos[i]->GetType()), &type));
500         NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, sourceInfo, "type", type));
501 
502         napi_value source = nullptr;
503         std::string mediaSource = sourceInfos[i]->GetSource();
504         NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(env_, mediaSource.c_str(), mediaSource.length(), &source));
505         NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, sourceInfo, "source", source));
506 
507         napi_value format = nullptr;
508         std::string mediaFormat = sourceInfos[i]->GetFormat();
509         NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(env_, mediaFormat.c_str(), mediaFormat.length(), &format));
510         NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, sourceInfo, "format", format));
511 
512         NAPI_CALL_RETURN_VOID(env_, napi_set_element(env_, *value, i, sourceInfo));
513     }
514 }
515 
ConstructSurfaceInfo(napi_value * value,std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)516 void NWebCreateNativeMediaPlayerCallbackImpl::ConstructSurfaceInfo(
517     napi_value* value, std::shared_ptr<NWebNativeMediaPlayerSurfaceInfo> surfaceInfo)
518 {
519     NAPI_CALL_RETURN_VOID(env_, napi_create_object(env_, value));
520 
521     if (!surfaceInfo) {
522         return;
523     }
524 
525     napi_value surfaceId = nullptr;
526     std::string id = surfaceInfo->GetId();
527     NAPI_CALL_RETURN_VOID(env_, napi_create_string_utf8(env_, id.c_str(), id.length(), &surfaceId));
528     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "id", surfaceId));
529 
530     napi_value rect = nullptr;
531     ConstructRect(&rect, surfaceInfo);
532     NAPI_CALL_RETURN_VOID(env_, napi_set_named_property(env_, *value, "rect", rect));
533 }
534 
535 } // namespace OHOS::NWeb
536