forked from mbk-lab/rui_orig
2
0
Fork 0
rui/mediaPlayer.go

1161 lines
33 KiB
Go
Raw Normal View History

2021-09-07 17:36:50 +03:00
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"
}
2022-05-22 12:54:02 +03:00
func (player *mediaPlayerData) String() string {
return getViewString(player)
}
func (player *mediaPlayerData) Focusable() bool {
return true
}
2021-09-07 17:36:50 +03:00
func (player *mediaPlayerData) Remove(tag string) {
player.remove(strings.ToLower(tag))
}
func (player *mediaPlayerData) remove(tag string) {
player.viewData.remove(tag)
player.propertyChanged(tag)
2021-09-07 17:36:50 +03:00
}
func (player *mediaPlayerData) Set(tag string, value interface{}) bool {
return player.set(strings.ToLower(tag), value)
}
func (player *mediaPlayerData) set(tag string, value interface{}) 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 := valueToPlayerListeners(value); ok {
if listeners == nil {
delete(player.properties, tag)
} else {
player.properties[tag] = listeners
}
player.propertyChanged(tag)
player.propertyChangedEvent(tag)
2021-09-07 17:36:50 +03:00
return true
}
notCompatibleType(tag, value)
case DurationChangedEvent, RateChangedEvent, TimeUpdateEvent, VolumeChangedEvent:
if listeners, ok := valueToPlayerTimeListeners(value); ok {
if listeners == nil {
delete(player.properties, tag)
} else {
player.properties[tag] = listeners
}
player.propertyChanged(tag)
player.propertyChangedEvent(tag)
2021-09-07 17:36:50 +03:00
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)
2021-09-07 17:36:50 +03:00
return true
}
notCompatibleType(tag, value)
case Source:
if player.setSource(value) {
player.propertyChanged(tag)
player.propertyChangedEvent(tag)
2021-09-07 17:36:50 +03:00
return true
}
default:
return player.viewData.set(tag, value)
2021-09-07 17:36:50 +03:00
}
2021-09-07 17:36:50 +03:00
return false
}
func (player *mediaPlayerData) setSource(value interface{}) 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 valueToPlayerListeners(value interface{}) ([]func(MediaPlayer), bool) {
if value == nil {
return nil, true
}
switch value := value.(type) {
case func(MediaPlayer):
return []func(MediaPlayer){value}, true
case func():
fn := func(MediaPlayer) {
value()
}
return []func(MediaPlayer){fn}, true
case []func(MediaPlayer):
if len(value) == 0 {
return nil, true
}
for _, fn := range value {
if fn == nil {
return nil, false
}
}
return value, true
case []func():
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer), count)
for i, v := range value {
if v == nil {
return nil, false
}
listeners[i] = func(MediaPlayer) {
v()
}
}
return listeners, true
case []interface{}:
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer), count)
for i, v := range value {
if v == nil {
return nil, false
}
switch v := v.(type) {
case func(MediaPlayer):
listeners[i] = v
case func():
listeners[i] = func(MediaPlayer) {
v()
}
default:
return nil, false
}
}
return listeners, true
}
return nil, false
}
func valueToPlayerTimeListeners(value interface{}) ([]func(MediaPlayer, float64), bool) {
if value == nil {
return nil, true
}
switch value := value.(type) {
case func(MediaPlayer, float64):
return []func(MediaPlayer, float64){value}, true
case func(float64):
2022-07-19 18:22:19 +03:00
fn := func(_ MediaPlayer, time float64) {
2021-09-07 17:36:50 +03:00
value(time)
}
return []func(MediaPlayer, float64){fn}, true
case func(MediaPlayer):
2022-07-19 18:22:19 +03:00
fn := func(player MediaPlayer, _ float64) {
2021-09-07 17:36:50 +03:00
value(player)
}
return []func(MediaPlayer, float64){fn}, true
case func():
2022-07-19 18:22:19 +03:00
fn := func(MediaPlayer, float64) {
2021-09-07 17:36:50 +03:00
value()
}
return []func(MediaPlayer, float64){fn}, true
case []func(MediaPlayer, float64):
if len(value) == 0 {
return nil, true
}
for _, fn := range value {
if fn == nil {
return nil, false
}
}
return value, true
case []func(float64):
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer, float64), count)
for i, v := range value {
if v == nil {
return nil, false
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(_ MediaPlayer, time float64) {
2021-09-07 17:36:50 +03:00
v(time)
}
}
return listeners, true
case []func(MediaPlayer):
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer, float64), count)
for i, v := range value {
if v == nil {
return nil, false
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(player MediaPlayer, _ float64) {
2021-09-07 17:36:50 +03:00
v(player)
}
}
return listeners, true
case []func():
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer, float64), count)
for i, v := range value {
if v == nil {
return nil, false
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(MediaPlayer, float64) {
2021-09-07 17:36:50 +03:00
v()
}
}
return listeners, true
case []interface{}:
count := len(value)
if count == 0 {
return nil, true
}
listeners := make([]func(MediaPlayer, float64), count)
for i, v := range value {
if v == nil {
return nil, false
}
switch v := v.(type) {
case func(MediaPlayer, float64):
listeners[i] = v
case func(float64):
2022-07-19 18:22:19 +03:00
listeners[i] = func(_ MediaPlayer, time float64) {
2021-09-07 17:36:50 +03:00
v(time)
}
case func(MediaPlayer):
2022-07-19 18:22:19 +03:00
listeners[i] = func(player MediaPlayer, _ float64) {
2021-09-07 17:36:50 +03:00
v(player)
}
case func():
2022-07-19 18:22:19 +03:00
listeners[i] = func(MediaPlayer, float64) {
2021-09-07 17:36:50 +03:00
v()
}
default:
return nil, false
}
}
return listeners, true
}
return nil, false
}
func valueToPlayerErrorListeners(value interface{}) ([]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):
2022-07-19 18:22:19 +03:00
fn := func(_ MediaPlayer, code int, message string) {
2021-09-07 17:36:50 +03:00
value(code, message)
}
return []func(MediaPlayer, int, string){fn}, true
case func(MediaPlayer):
2022-07-19 18:22:19 +03:00
fn := func(player MediaPlayer, _ int, _ string) {
2021-09-07 17:36:50 +03:00
value(player)
}
return []func(MediaPlayer, int, string){fn}, true
case func():
2022-07-19 18:22:19 +03:00
fn := func(MediaPlayer, int, string) {
2021-09-07 17:36:50 +03:00
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
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(_ MediaPlayer, code int, message string) {
2021-09-07 17:36:50 +03:00
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
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(player MediaPlayer, _ int, _ string) {
2021-09-07 17:36:50 +03:00
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
}
2022-07-19 18:22:19 +03:00
listeners[i] = func(MediaPlayer, int, string) {
2021-09-07 17:36:50 +03:00
v()
}
}
return listeners, true
case []interface{}:
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):
2022-07-19 18:22:19 +03:00
listeners[i] = func(_ MediaPlayer, code int, message string) {
2021-09-07 17:36:50 +03:00
v(code, message)
}
case func(MediaPlayer):
2022-07-19 18:22:19 +03:00
listeners[i] = func(player MediaPlayer, _ int, _ string) {
2021-09-07 17:36:50 +03:00
v(player)
}
case func():
2022-07-19 18:22:19 +03:00
listeners[i] = func(MediaPlayer, int, string) {
2021-09-07 17:36:50 +03:00
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 {
updateBoolProperty(player.htmlID(), tag, value, player.Session())
} else {
removeProperty(player.htmlID(), tag, player.Session())
}
case Muted:
value, _ := boolProperty(player, tag, player.Session())
if value {
player.Session().runScript("setMediaMuted('" + player.htmlID() + "', true)")
} else {
player.Session().runScript("setMediaMuted('" + player.htmlID() + "', false)")
}
case Preload:
value, _ := enumProperty(player, tag, player.Session(), 0)
values := enumProperties[Preload].values
updateProperty(player.htmlID(), tag, values[value], player.Session())
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)
updateProperty(player.htmlID(), event.cssTag, fn, player.Session())
return
}
2021-09-07 17:36:50 +03:00
}
}
updateProperty(player.htmlID(), tag, "", player.Session())
break
2021-09-07 17:36:50 +03:00
}
}
case TimeUpdateEvent:
if value := player.getRaw(tag); value != nil {
updateProperty(player.htmlID(), "ontimeupdate", "playerTimeUpdatedEvent(this)", player.Session())
} else {
updateProperty(player.htmlID(), "ontimeupdate", "", player.Session())
2021-09-07 17:36:50 +03:00
}
case VolumeChangedEvent:
if value := player.getRaw(tag); value != nil {
updateProperty(player.htmlID(), "onvolumechange", "playerVolumeChangedEvent(this)", player.Session())
} else {
updateProperty(player.htmlID(), "onvolumechange", "", player.Session())
}
2021-09-07 17:36:50 +03:00
case DurationChangedEvent:
if value := player.getRaw(tag); value != nil {
updateProperty(player.htmlID(), "ondurationchange", "playerDurationChangedEvent(this)", player.Session())
} else {
updateProperty(player.htmlID(), "ondurationchange", "", player.Session())
}
2021-09-07 17:36:50 +03:00
case RateChangedEvent:
if value := player.getRaw(tag); value != nil {
updateProperty(player.htmlID(), "onratechange", "playerRateChangedEvent(this)", player.Session())
} else {
updateProperty(player.htmlID(), "onratechange", "", player.Session())
}
2021-09-07 17:36:50 +03:00
case PlayerErrorEvent:
if value := player.getRaw(tag); value != nil {
updateProperty(player.htmlID(), "onerror", "playerErrorEvent(this)", player.Session())
} else {
updateProperty(player.htmlID(), "onerror", "", player.Session())
}
2021-09-07 17:36:50 +03:00
case Source:
updateInnerHTML(player.htmlID(), player.Session())
2021-09-07 17:36:50 +03:00
}
}
}
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 {
2021-11-04 14:59:25 +03:00
code, _ := dataIntProperty(data, "code")
2021-09-07 17:36:50 +03:00
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.runScript(fmt.Sprintf(`mediaPlay('%v');`, player.htmlID()))
}
func (player *mediaPlayerData) Pause() {
player.session.runScript(fmt.Sprintf(`mediaPause('%v');`, player.htmlID()))
}
func (player *mediaPlayerData) SetCurrentTime(seconds float64) {
player.session.runScript(fmt.Sprintf(`mediaSetSetCurrentTime('%v', %v);`, player.htmlID(), seconds))
}
func (player *mediaPlayerData) getFloatPlayerProperty(tag string) (float64, bool) {
script := allocStringBuilder()
defer freeStringBuilder(script)
script.WriteString(`const element = document.getElementById('`)
script.WriteString(player.htmlID())
script.WriteString(`');
if (element && element.`)
script.WriteString(tag)
script.WriteString(`) {
sendMessage('answer{answerID=' + answerID + ',`)
script.WriteString(tag)
script.WriteString(`=' + element.`)
script.WriteString(tag)
script.WriteString(` + '}');
} else {
sendMessage('answer{answerID=' + answerID + ',`)
script.WriteString(tag)
script.WriteString(`=0}');
}`)
result := player.Session().runGetterScript(script.String())
switch result.Tag() {
case "answer":
if value, ok := result.PropertyValue(tag); ok {
w, err := strconv.ParseFloat(value, 32)
if err == nil {
return w, true
}
ErrorLog(err.Error())
}
case "error":
if text, ok := result.PropertyValue("errorText"); ok {
ErrorLog(text)
} else {
ErrorLog("error")
}
default:
ErrorLog("Unknown answer: " + result.Tag())
}
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.runScript(fmt.Sprintf(`mediaSetPlaybackRate('%v', %v);`, 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.runScript(fmt.Sprintf(`mediaSetVolume('%v', %v);`, 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) {
script := allocStringBuilder()
defer freeStringBuilder(script)
script.WriteString(`const element = document.getElementById('`)
script.WriteString(player.htmlID())
script.WriteString(`');
if (element && element.`)
script.WriteString(tag)
script.WriteString(`) {
sendMessage('answer{answerID=' + answerID + ',`)
script.WriteString(tag)
script.WriteString(`=1}')
} else {
sendMessage('answer{answerID=' + answerID + ',`)
script.WriteString(tag)
script.WriteString(`=0}')
}`)
result := player.Session().runGetterScript(script.String())
switch result.Tag() {
case "answer":
if value, ok := result.PropertyValue(tag); ok {
if value == "1" {
return true, true
}
return false, true
}
case "error":
if text, ok := result.PropertyValue("errorText"); ok {
ErrorLog(text)
} else {
ErrorLog("error")
}
default:
ErrorLog("Unknown answer: " + result.Tag())
}
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
}