rui/mediaPlayer.go

package rui

import (
	"fmt"
	"math"
	"strconv"
	"strings"
)

const (
	// Controls is the constant for the "autoplay" controls tag.
	// If the "controls" bool property is "true", the browser will offer controls to allow the user
	// to control audio/video playback, including volume, seeking, and pause/resume playback.
	// Its default value is false.
	Controls = "controls"
	// Loop is the constant for the "loop" property tag.
	// If the "loop" bool property is "true", the audio/video player will automatically seek back
	// to the start upon reaching the end of the audio/video.
	// Its default value is false.
	Loop = "loop"
	// Muted is the constant for the "muted" property tag.
	// The "muted" bool property indicates whether the audio/video will be initially silenced.
	// Its default value is false.
	Muted = "muted"
	// Preload is the constant for the "preload" property tag.
	// The "preload" int property is intended to provide a hint to the browser about what
	// the author thinks will lead to the best user experience. It may have one of the following values:
	// PreloadNone (0), PreloadMetadata (1), and PreloadAuto (2)
	// The default value is different for each browser.
	Preload = "preload"

	// AbortEvent is the constant for the "abort-event" property tag.
	// The "abort-event" event fired when the resource was not fully loaded, but not as the result of an error.
	AbortEvent = "abort-event"
	// CanPlayEvent is the constant for the "can-play-event" property tag.
	// The "can-play-event" event occurs when the browser can play the media, but estimates that not enough data has been
	// loaded to play the media up to its end without having to stop for further buffering of content.
	CanPlayEvent = "can-play-event"
	// CanPlayThroughEvent is the constant for the "can-play-through-event" property tag.
	// The "can-play-through-event" event occurs when the browser estimates it can play the media up
	// to its end without stopping for content buffering.
	CanPlayThroughEvent = "can-play-through-event"
	// CompleteEvent is the constant for the "complete-event" property tag.
	// The "complete-event" event occurs when the rendering of an OfflineAudioContext is terminated.
	CompleteEvent = "complete-event"
	// DurationChangedEvent is the constant for the "duration-changed-event" property tag.
	// The "duration-changed-event" event occurs when the duration attribute has been updated.
	DurationChangedEvent = "duration-changed-event"
	// EmptiedEvent is the constant for the "emptied-event" property tag.
	// The "emptied-event" event occurs when the media has become empty; for example, this event is sent if the media has already been loaded
	// (or partially loaded), and the HTMLMediaElement.load method is called to reload it.
	EmptiedEvent = "emptied-event"
	// EndedEvent is the constant for the "ended-event" property tag.
	// The "ended-event" event occurs when the playback has stopped because the end of the media was reached.
	EndedEvent = "ended-event"
	// LoadedDataEvent is the constant for the "loaded-data-event" property tag.
	// The "loaded-data-event" event occurs when the first frame of the media has finished loading.
	LoadedDataEvent = "loaded-data-event"
	// LoadedMetadataEvent is the constant for the "loaded-metadata-event" property tag.
	// The "loaded-metadata-event" event occurs when the metadata has been loaded.
	LoadedMetadataEvent = "loaded-metadata-event"
	// LoadStartEvent is the constant for the "load-start-event" property tag.
	// The "load-start-event" event is fired when the browser has started to load a resource.
	LoadStartEvent = "load-start-event"
	// PauseEvent is the constant for the "pause-event" property tag.
	// The "pause-event" event occurs when the playback has been paused.
	PauseEvent = "pause-event"
	// PlayEvent is the constant for the "play-event" property tag.
	// The "play-event" event occurs when the playback has begun.
	PlayEvent = "play-event"
	// PlayingEvent is the constant for the "playing-event" property tag.
	// The "playing-event" event occurs when the playback is ready to start after having been paused or delayed due to lack of data.
	PlayingEvent = "playing-event"
	// ProgressEvent is the constant for the "progress-event" property tag.
	// The "progress-event" event is fired periodically as the browser loads a resource.
	ProgressEvent = "progress-event"
	// RateChangeEvent is the constant for the "rate-change-event" property tag.
	// The "rate-change-event" event occurs when the playback rate has changed.
	RateChangedEvent = "rate-changed-event"
	// SeekedEvent is the constant for the "seeked-event" property tag.
	// The "seeked-event" event occurs when a seek operation completed.
	SeekedEvent = "seeked-event"
	// SeekingEvent is the constant for the "seeking-event" property tag.
	// The "seeking-event" event occurs when a seek operation began.
	SeekingEvent = "seeking-event"
	// StalledEvent is the constant for the "stalled-event" property tag.
	// The "stalled-event" event occurs when the user agent is trying to fetch media data, but data is unexpectedly not forthcoming.
	StalledEvent = "stalled-event"
	// SuspendEvent is the constant for the "suspend-event" property tag.
	// The "suspend-event" event occurs when the media data loading has been suspended.
	SuspendEvent = "suspend-event"
	// TimeUpdateEvent is the constant for the "time-update-event" property tag.
	// The "time-update-event" event occurs when the time indicated by the currentTime attribute has been updated.
	TimeUpdateEvent = "time-update-event"
	// VolumeChangedEvent is the constant for the "volume-change-event" property tag.
	// The "volume-change-event" event occurs when the volume has changed.
	VolumeChangedEvent = "volume-changed-event"
	// WaitingEvent is the constant for the "waiting-event" property tag.
	// The "waiting-event" event occurs when the playback has stopped because of a temporary lack of data
	WaitingEvent = "waiting-event"
	// PlayerErrorEvent is the constant for the "player-error-event" property tag.
	// The "player-error-event" event is fired when the resource could not be loaded due to an error
	// (for example, a network connectivity problem).
	PlayerErrorEvent = "player-error-event"

	// PreloadNone - value of the view "preload" property: indicates that the audio/video should not be preloaded.
	PreloadNone = 0
	// PreloadMetadata - value of the view "preload" property: indicates that only audio/video metadata (e.g. length) is fetched.
	PreloadMetadata = 1
	// PreloadAuto - value of the view "preload" property: indicates that the whole audio file can be downloaded,
	// even if the user is not expected to use it.
	PreloadAuto = 2

	// PlayerErrorUnknown - MediaPlayer error code: An unknown error.
	PlayerErrorUnknown = 0
	// PlayerErrorAborted - MediaPlayer error code: The fetching of the associated resource was aborted by the user's request.
	PlayerErrorAborted = 1
	// PlayerErrorNetwork - MediaPlayer error code: Some kind of network error occurred which prevented the media
	// from being successfully fetched, despite having previously been available.
	PlayerErrorNetwork = 2
	// PlayerErrorDecode - MediaPlayer error code: Despite having previously been determined to be usable,
	// an error occurred while trying to decode the media resource, resulting in an error.
	PlayerErrorDecode = 3
	// PlayerErrorSourceNotSupported - MediaPlayer error code: The associated resource or media provider object has been found to be unsuitable.
	PlayerErrorSourceNotSupported = 4
)

type MediaPlayer interface {
	View
	// Play attempts to begin playback of the media.
	Play()
	// Pause will pause playback of the media, if the media is already in a paused state this method will have no effect.
	Pause()
	// SetCurrentTime sets the current playback time in seconds.
	SetCurrentTime(seconds float64)
	// CurrentTime returns the current playback time in seconds.
	CurrentTime() float64
	// Duration returns the value indicating the total duration of the media in seconds.
	// If no media data is available, the returned value is NaN.
	Duration() float64
	// SetPlaybackRate sets the rate at which the media is being played back. This is used to implement user controls
	// for fast forward, slow motion, and so forth. The normal playback rate is multiplied by this value to obtain
	// the current rate, so a value of 1.0 indicates normal speed.
	SetPlaybackRate(rate float64)
	// PlaybackRate returns the rate at which the media is being played back.
	PlaybackRate() float64
	// SetVolume sets the audio volume, from 0.0 (silent) to 1.0 (loudest).
	SetVolume(volume float64)
	// Volume returns the audio volume, from 0.0 (silent) to 1.0 (loudest).
	Volume() float64
	// IsEnded function tells whether the media element is ended.
	IsEnded() bool
	// IsPaused function tells whether the media element is paused.
	IsPaused() bool
}

type mediaPlayerData struct {
	viewData
}

type MediaSource struct {
	Url      string
	MimeType string
}

func (player *mediaPlayerData) init(session Session) {
	player.viewData.init(session)
	player.tag = "MediaPlayer"
}

func (player *mediaPlayerData) String() string {
	return getViewString(player)
}

func (player *mediaPlayerData) Focusable() bool {
	return true
}

func (player *mediaPlayerData) Remove(tag string) {
	player.remove(strings.ToLower(tag))
}

func (player *mediaPlayerData) remove(tag string) {
	player.viewData.remove(tag)
	player.propertyChanged(tag)
}

func (player *mediaPlayerData) Set(tag string, value any) bool {
	return player.set(strings.ToLower(tag), value)
}

func (player *mediaPlayerData) set(tag string, value any) bool {
	if value == nil {
		player.remove(tag)
		return true
	}

	switch tag {
	case Controls, Loop, Muted, Preload:
		if player.viewData.set(tag, value) {
			player.propertyChanged(tag)
			return true
		}

	case AbortEvent, CanPlayEvent, CanPlayThroughEvent, CompleteEvent, EmptiedEvent, LoadStartEvent,
		EndedEvent, LoadedDataEvent, LoadedMetadataEvent, PauseEvent, PlayEvent, PlayingEvent,
		ProgressEvent, SeekedEvent, SeekingEvent, StalledEvent, SuspendEvent, WaitingEvent:
		if listeners, ok := valueToNoParamListeners[MediaPlayer](value); ok {
			if listeners == nil {
				delete(player.properties, tag)
			} else {
				player.properties[tag] = listeners
			}
			player.propertyChanged(tag)
			player.propertyChangedEvent(tag)
			return true
		}
		notCompatibleType(tag, value)

	case DurationChangedEvent, RateChangedEvent, TimeUpdateEvent, VolumeChangedEvent:
		if listeners, ok := valueToEventListeners[MediaPlayer, float64](value); ok {
			if listeners == nil {
				delete(player.properties, tag)
			} else {
				player.properties[tag] = listeners
			}
			player.propertyChanged(tag)
			player.propertyChangedEvent(tag)
			return true
		}
		notCompatibleType(tag, value)

	case PlayerErrorEvent:
		if listeners, ok := valueToPlayerErrorListeners(value); ok {
			if listeners == nil {
				delete(player.properties, tag)
			} else {
				player.properties[tag] = listeners
			}
			player.propertyChanged(tag)
			player.propertyChangedEvent(tag)
			return true
		}
		notCompatibleType(tag, value)

	case Source:
		if player.setSource(value) {
			player.propertyChanged(tag)
			player.propertyChangedEvent(tag)
			return true
		}

	default:
		return player.viewData.set(tag, value)
	}

	return false
}

func (player *mediaPlayerData) setSource(value any) bool {
	switch value := value.(type) {
	case string:
		src := MediaSource{Url: value, MimeType: ""}
		player.properties[Source] = []MediaSource{src}

	case MediaSource:
		player.properties[Source] = []MediaSource{value}

	case []MediaSource:
		player.properties[Source] = value

	case DataObject:
		url, ok := value.PropertyValue("src")
		if !ok || url == "" {
			invalidPropertyValue(Source, value)
			return false
		}

		mimeType, _ := value.PropertyValue("mime-type")
		src := MediaSource{Url: url, MimeType: mimeType}
		player.properties[Source] = []MediaSource{src}

	case []DataValue:
		src := []MediaSource{}
		for _, val := range value {
			if val.IsObject() {
				obj := val.Object()
				if url, ok := obj.PropertyValue("src"); ok && url != "" {
					mimeType, _ := obj.PropertyValue("mime-type")
					src = append(src, MediaSource{Url: url, MimeType: mimeType})
				} else {
					invalidPropertyValue(Source, value)
					return false
				}
			} else {
				src = append(src, MediaSource{Url: val.Value(), MimeType: ""})
			}
		}

		if len(src) == 0 {
			invalidPropertyValue(Source, value)
			return false
		}
		player.properties[Source] = src

	default:
		notCompatibleType(Source, value)
		return false
	}

	return true
}

func valueToPlayerErrorListeners(value any) ([]func(MediaPlayer, int, string), bool) {
	if value == nil {
		return nil, true
	}

	switch value := value.(type) {
	case func(MediaPlayer, int, string):
		return []func(MediaPlayer, int, string){value}, true

	case func(int, string):
		fn := func(_ MediaPlayer, code int, message string) {
			value(code, message)
		}
		return []func(MediaPlayer, int, string){fn}, true

	case func(MediaPlayer):
		fn := func(player MediaPlayer, _ int, _ string) {
			value(player)
		}
		return []func(MediaPlayer, int, string){fn}, true

	case func():
		fn := func(MediaPlayer, int, string) {
			value()
		}
		return []func(MediaPlayer, int, string){fn}, true

	case []func(MediaPlayer, int, string):
		if len(value) == 0 {
			return nil, true
		}
		for _, fn := range value {
			if fn == nil {
				return nil, false
			}
		}
		return value, true

	case []func(int, string):
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(MediaPlayer, int, string), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(_ MediaPlayer, code int, message string) {
				v(code, message)
			}
		}
		return listeners, true

	case []func(MediaPlayer):
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(MediaPlayer, int, string), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(player MediaPlayer, _ int, _ string) {
				v(player)
			}
		}
		return listeners, true

	case []func():
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(MediaPlayer, int, string), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(MediaPlayer, int, string) {
				v()
			}
		}
		return listeners, true

	case []any:
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(MediaPlayer, int, string), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			switch v := v.(type) {
			case func(MediaPlayer, int, string):
				listeners[i] = v

			case func(int, string):
				listeners[i] = func(_ MediaPlayer, code int, message string) {
					v(code, message)
				}

			case func(MediaPlayer):
				listeners[i] = func(player MediaPlayer, _ int, _ string) {
					v(player)
				}

			case func():
				listeners[i] = func(MediaPlayer, int, string) {
					v()
				}

			default:
				return nil, false
			}
		}
		return listeners, true
	}

	return nil, false
}

func playerEvents() []struct{ tag, cssTag string } {
	return []struct{ tag, cssTag string }{
		{AbortEvent, "onabort"},
		{CanPlayEvent, "oncanplay"},
		{CanPlayThroughEvent, "oncanplaythrough"},
		{CompleteEvent, "oncomplete"},
		{EmptiedEvent, "onemptied"},
		{EndedEvent, "ended"},
		{LoadedDataEvent, "onloadeddata"},
		{LoadedMetadataEvent, "onloadedmetadata"},
		{LoadStartEvent, "onloadstart"},
		{PauseEvent, "onpause"},
		{PlayEvent, "onplay"},
		{PlayingEvent, "onplaying"},
		{ProgressEvent, "onprogress"},
		{SeekedEvent, "onseeked"},
		{SeekingEvent, "onseeking"},
		{StalledEvent, "onstalled"},
		{SuspendEvent, "onsuspend"},
		{WaitingEvent, "onwaiting"},
	}
}

func (player *mediaPlayerData) propertyChanged(tag string) {
	if player.created {
		switch tag {
		case Controls, Loop:
			value, _ := boolProperty(player, tag, player.session)
			if value {
				player.session.updateProperty(player.htmlID(), tag, value)
			} else {
				player.session.removeProperty(player.htmlID(), tag)
			}

		case Muted:
			value, _ := boolProperty(player, tag, player.session)
			player.session.callFunc("setMediaMuted", player.htmlID(), value)

		case Preload:
			value, _ := enumProperty(player, tag, player.session, 0)
			values := enumProperties[Preload].values
			player.session.updateProperty(player.htmlID(), tag, values[value])

		case AbortEvent, CanPlayEvent, CanPlayThroughEvent, CompleteEvent, EmptiedEvent,
			EndedEvent, LoadedDataEvent, LoadedMetadataEvent, PauseEvent, PlayEvent, PlayingEvent, ProgressEvent,
			LoadStartEvent, SeekedEvent, SeekingEvent, StalledEvent, SuspendEvent, WaitingEvent:

			for _, event := range playerEvents() {
				if event.tag == tag {
					if value := player.getRaw(event.tag); value != nil {
						switch value := value.(type) {
						case []func(MediaPlayer):
							if len(value) > 0 {
								fn := fmt.Sprintf(`playerEvent(this, "%s")`, event.tag)
								player.session.updateProperty(player.htmlID(), event.cssTag, fn)
								return
							}
						}
					}
					player.session.updateProperty(player.htmlID(), tag, "")
					break
				}

			}
		case TimeUpdateEvent:
			if value := player.getRaw(tag); value != nil {
				player.session.updateProperty(player.htmlID(), "ontimeupdate", "playerTimeUpdatedEvent(this)")
			} else {
				player.session.updateProperty(player.htmlID(), "ontimeupdate", "")
			}

		case VolumeChangedEvent:
			if value := player.getRaw(tag); value != nil {
				player.session.updateProperty(player.htmlID(), "onvolumechange", "playerVolumeChangedEvent(this)")
			} else {
				player.session.updateProperty(player.htmlID(), "onvolumechange", "")
			}

		case DurationChangedEvent:
			if value := player.getRaw(tag); value != nil {
				player.session.updateProperty(player.htmlID(), "ondurationchange", "playerDurationChangedEvent(this)")
			} else {
				player.session.updateProperty(player.htmlID(), "ondurationchange", "")
			}

		case RateChangedEvent:
			if value := player.getRaw(tag); value != nil {
				player.session.updateProperty(player.htmlID(), "onratechange", "playerRateChangedEvent(this)")
			} else {
				player.session.updateProperty(player.htmlID(), "onratechange", "")
			}

		case PlayerErrorEvent:
			if value := player.getRaw(tag); value != nil {
				player.session.updateProperty(player.htmlID(), "onerror", "playerErrorEvent(this)")
			} else {
				player.session.updateProperty(player.htmlID(), "onerror", "")
			}

		case Source:
			updateInnerHTML(player.htmlID(), player.session)
		}
	}
}

func (player *mediaPlayerData) htmlSubviews(self View, buffer *strings.Builder) {
	if value := player.getRaw(Source); value != nil {
		if sources, ok := value.([]MediaSource); ok && len(sources) > 0 {
			session := player.session
			for _, src := range sources {
				if url, ok := session.resolveConstants(src.Url); ok && url != "" {
					buffer.WriteString(`<source src="`)
					buffer.WriteString(url)
					buffer.WriteRune('"')
					if mime, ok := session.resolveConstants(src.MimeType); ok && mime != "" {
						buffer.WriteString(` type="`)
						buffer.WriteString(mime)
						buffer.WriteRune('"')
					}
					buffer.WriteRune('>')
				}
			}
		}
	}
}

func (player *mediaPlayerData) htmlProperties(self View, buffer *strings.Builder) {
	player.viewData.htmlProperties(self, buffer)
	for _, tag := range []string{Controls, Loop, Muted, Preload} {
		if value, _ := boolProperty(player, tag, player.session); value {
			buffer.WriteRune(' ')
			buffer.WriteString(tag)
		}
	}

	if value, ok := enumProperty(player, Preload, player.session, 0); ok {
		values := enumProperties[Preload].values
		buffer.WriteString(` preload="`)
		buffer.WriteString(values[value])
		buffer.WriteRune('"')
	}

	for _, event := range playerEvents() {
		if value := player.getRaw(event.tag); value != nil {
			switch value := value.(type) {
			case []func(MediaPlayer):
				if len(value) > 0 {
					buffer.WriteString(` `)
					buffer.WriteString(event.cssTag)
					buffer.WriteString(`="playerEvent(this, '`)
					buffer.WriteString(event.tag)
					buffer.WriteString(`')"`)
				}
			}
		}
	}

	if value := player.getRaw(TimeUpdateEvent); value != nil {
		buffer.WriteString(` ontimeupdate="playerTimeUpdatedEvent(this)"`)
	}

	if value := player.getRaw(VolumeChangedEvent); value != nil {
		buffer.WriteString(` onvolumechange="playerVolumeChangedEvent(this)"`)
	}

	if value := player.getRaw(DurationChangedEvent); value != nil {
		buffer.WriteString(` ondurationchange="playerDurationChangedEvent(this)"`)
	}

	if value := player.getRaw(RateChangedEvent); value != nil {
		buffer.WriteString(` onratechange="playerRateChangedEvent(this)"`)
	}

	if value := player.getRaw(PlayerErrorEvent); value != nil {
		buffer.WriteString(` onerror="playerErrorEvent(this)"`)
	}
}

func (player *mediaPlayerData) handleCommand(self View, command string, data DataObject) bool {
	switch command {
	case AbortEvent, CanPlayEvent, CanPlayThroughEvent, CompleteEvent, LoadStartEvent,
		EmptiedEvent, EndedEvent, LoadedDataEvent, LoadedMetadataEvent, PauseEvent, PlayEvent,
		PlayingEvent, ProgressEvent, SeekedEvent, SeekingEvent, StalledEvent, SuspendEvent,
		WaitingEvent:

		if value := player.getRaw(command); value != nil {
			if listeners, ok := value.([]func(MediaPlayer)); ok {
				for _, listener := range listeners {
					listener(player)
				}
			}
		}

	case TimeUpdateEvent, DurationChangedEvent, RateChangedEvent, VolumeChangedEvent:
		if value := player.getRaw(command); value != nil {
			if listeners, ok := value.([]func(MediaPlayer, float64)); ok {
				time := dataFloatProperty(data, "value")
				for _, listener := range listeners {
					listener(player, time)
				}
			}
		}

	case PlayerErrorEvent:
		if value := player.getRaw(command); value != nil {
			if listeners, ok := value.([]func(MediaPlayer, int, string)); ok {
				code, _ := dataIntProperty(data, "code")
				message, _ := data.PropertyValue("message")
				for _, listener := range listeners {
					listener(player, code, message)
				}
			}
		}
	}

	return player.viewData.handleCommand(self, command, data)
}

func (player *mediaPlayerData) Play() {
	player.session.callFunc("mediaPlay", player.htmlID())
}

func (player *mediaPlayerData) Pause() {
	player.session.callFunc("mediaPause", player.htmlID())
}

func (player *mediaPlayerData) SetCurrentTime(seconds float64) {
	player.session.callFunc("mediaSetSetCurrentTime", player.htmlID(), seconds)
}

func (player *mediaPlayerData) getFloatPlayerProperty(tag string) (float64, bool) {
	value := player.session.htmlPropertyValue(player.htmlID(), tag)
	if value != "" {
		result, err := strconv.ParseFloat(value, 32)
		if err == nil {
			return result, true
		}
		ErrorLog(err.Error())
	}

	return 0, false
}

func (player *mediaPlayerData) CurrentTime() float64 {
	if result, ok := player.getFloatPlayerProperty("currentTime"); ok {
		return result
	}
	return 0
}

func (player *mediaPlayerData) Duration() float64 {
	if result, ok := player.getFloatPlayerProperty("duration"); ok {
		return result
	}
	return 0
}

func (player *mediaPlayerData) SetPlaybackRate(rate float64) {
	player.session.callFunc("mediaSetPlaybackRate", player.htmlID(), rate)
}

func (player *mediaPlayerData) PlaybackRate() float64 {
	if result, ok := player.getFloatPlayerProperty("playbackRate"); ok {
		return result
	}
	return 1
}

func (player *mediaPlayerData) SetVolume(volume float64) {
	if volume >= 0 && volume <= 1 {
		player.session.callFunc("mediaSetVolume", player.htmlID(), volume)
	}
}

func (player *mediaPlayerData) Volume() float64 {
	if result, ok := player.getFloatPlayerProperty("volume"); ok {
		return result
	}
	return 1
}

func (player *mediaPlayerData) getBoolPlayerProperty(tag string) (bool, bool) {
	switch value := player.session.htmlPropertyValue(player.htmlID(), tag); strings.ToLower(value) {
	case "0", "false", "off":
		return false, true

	case "1", "true", "on":
		return false, true
	}

	return false, false
}

func (player *mediaPlayerData) IsEnded() bool {
	if result, ok := player.getBoolPlayerProperty("ended"); ok {
		return result
	}
	return false
}

func (player *mediaPlayerData) IsPaused() bool {
	if result, ok := player.getBoolPlayerProperty("paused"); ok {
		return result
	}
	return false
}

// MediaPlayerPlay attempts to begin playback of the media.
func MediaPlayerPlay(view View, playerID string) {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		player.Play()
	} else {
		ErrorLog(`The found View is not MediaPlayer`)
	}
}

// MediaPlayerPause will pause playback of the media, if the media is already in a paused state this method will have no effect.
func MediaPlayerPause(view View, playerID string) {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		player.Pause()
	} else {
		ErrorLog(`The found View is not MediaPlayer`)
	}
}

// SetMediaPlayerCurrentTime sets the current playback time in seconds.
func SetMediaPlayerCurrentTime(view View, playerID string, seconds float64) {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		player.SetCurrentTime(seconds)
	} else {
		ErrorLog(`The found View is not MediaPlayer`)
	}
}

// MediaPlayerCurrentTime returns the current playback time in seconds.
func MediaPlayerCurrentTime(view View, playerID string) float64 {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.CurrentTime()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return 0
}

// MediaPlayerDuration returns the value indicating the total duration of the media in seconds.
// If no media data is available, the returned value is NaN.
func MediaPlayerDuration(view View, playerID string) float64 {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.Duration()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return math.NaN()
}

// SetVolume sets the audio volume, from 0.0 (silent) to 1.0 (loudest).
func SetMediaPlayerVolume(view View, playerID string, volume float64) {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		player.SetVolume(volume)
	} else {
		ErrorLog(`The found View is not MediaPlayer`)
	}
}

// Volume returns the audio volume, from 0.0 (silent) to 1.0 (loudest).
func MediaPlayerVolume(view View, playerID string) float64 {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.Volume()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return 1
}

// SetMediaPlayerPlaybackRate sets the rate at which the media is being played back. This is used to implement user controls
// for fast forward, slow motion, and so forth. The normal playback rate is multiplied by this value to obtain
// the current rate, so a value of 1.0 indicates normal speed.
func SetMediaPlayerPlaybackRate(view View, playerID string, rate float64) {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		player.SetPlaybackRate(rate)
	} else {
		ErrorLog(`The found View is not MediaPlayer`)
	}
}

// MediaPlayerPlaybackRate returns the rate at which the media is being played back.
func MediaPlayerPlaybackRate(view View, playerID string) float64 {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.PlaybackRate()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return 1
}

// IsMediaPlayerEnded function tells whether the media element is ended.
func IsMediaPlayerEnded(view View, playerID string) bool {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.IsEnded()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return false
}

// IsMediaPlayerPaused function tells whether the media element is paused.
func IsMediaPlayerPaused(view View, playerID string) bool {
	if playerID != "" {
		view = ViewByID(view, playerID)
	}

	if player, ok := view.(MediaPlayer); ok {
		return player.IsPaused()
	}

	ErrorLog(`The found View is not MediaPlayer`)
	return false
}