io.laminext.videojs.api.Player.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of videojs_sjs1_3 Show documentation
Show all versions of videojs_sjs1_3 Show documentation
Laminar utilities and components
package io.laminext.videojs.api
import io.laminext.videojs.api.components.ControlBar
import org.scalajs.dom.raw.TimeRanges
import org.scalajs.dom.Element
import org.scalajs.dom.MediaError
import scala.scalajs.js
import scala.scalajs.js.|
//@js.native
//@JSName("Player")
//object Player extends js.Object {
// /**
// * Player object constructor
// * @param tag The original video tag used for configuring options
// * @param options Object of option names and values
// * @param ready Ready callback function
// */
// def apply(tag: Element, options: js.Object = ???, ready: js.Function = ???): Player = js.native
//
// /**
// * Gets tag settings
// * @param tag The player tag
// * @return An array of sources and track objects
// */
// def getTagSettings(tag: Element): js.Object = js.native
//}
/**
* @see [[http://docs.videojs.com/docs/api/player.html]]
*/
//noinspection AccessorLikeMethodIsEmptyParen
@js.native
trait Player extends Component {
/**
* Add a remote text track
* @param options Options for remote text track
*/
def addRemoteTextTrack(options: scalajs.js.Object): Unit = scalajs.js.native
/**
* Add a text track In addition to the W3C settings we allow adding additional info through options. http://www.w3.org/html/wg/drafts/html/master/embedded-content-0.html#dom-media-addtexttrack
* @param kind Captions, subtitles, chapters, descriptions, or metadata
* @param label Optional label
* @param language Optional language
*/
def addTextTrack(kind: String, label: String = ???, language: String = ???): Unit = scalajs.js.native
/**
* Get/Set the aspect ratio
* @param ratio Aspect ratio for player
*/
def aspectRatio(ratio: String = ???): String = scalajs.js.native
/**
* Get or set the autoplay attribute.
* @param value Boolean to determine if video should autoplay
*/
def autoplay(value: Boolean = ???): Boolean = scalajs.js.native
/**
* Get a TimeRange object with the times of the video that have been downloaded
* If you just want the percent of the video that's been downloaded, use bufferedPercent.
* @return TimeRange object
*/
def buffered(): TimeRanges = js.native
/**
* Get the percent (as a decimal) of the video that's been downloaded.
* 0 means none, 1 means all. (This method isn't in the HTML5 spec, but it's very convenient)
* @return The end of the last buffered time range
* @example {{{
* var howMuchIsDownloaded = myPlayer.bufferedPercent();
* }}}
*/
def bufferedPercent(): Double = js.native
/**
* Check whether the player can play a given mimetype
* @param `type` The mimetype to check
*/
def canPlayType(`type`: String): Boolean = js.native
/**
* Get or set whether or not the controls are showing.
* @param bool Set controls to showing or not
* @return Controls are showing
*/
def controls(bool: Boolean = ???): Boolean = js.native
/**
* Create the component's DOM element
*/
def createEl(): Element = js.native
/**
* Returns the fully qualified URL of the current source value e.g. `http://mysite.com/video.mp4`
* Can be used in conjuction with currentType to assist in rebuilding the current source object.
*/
def currentSrc(): String = js.native
/**
* Get the current time (in seconds)
* @return The time in seconds, when not setting
* @example {{{
* var whereYouAt = myPlayer.currentTime();
* }}}
*/
def currentTime(): Double = js.native
/**
* Set the current time (in seconds)
* @param seconds The time to seek to
* @return Self, when the current time is set
* @example {{{
* myPlayer.currentTime(120); // 2 minutes into the video
* }}}
*/
def currentTime(seconds: Int | String = ???): this.type = js.native
/**
* Get the current source type e.g. video/mp4.
* This can allow you rebuild the current source object so that you could load the same source and tech later.
* @return
*/
def currentType(): String = js.native
/**
* Get/set dimension for player
* @param dimension Either width or height
* @param value Value for dimension
* @return Height when getting
*/
def dimension(dimension: String, value: Int = ???): Int = js.native
/**
* Get the length in time of the video in seconds
* @param seconds Duration when setting
* @return The duration of the video in seconds when getting
* @note The video must have started loading before the duration can be known, and in the case of Flash, may not be known until the video starts playing.
*/
def duration(seconds: Int = ???): Int = js.native
/**
* Returns whether or not the player is in the "ended" state.
* @return True if the player is in the ended state, false if not.
*/
def ended(): Boolean = js.native
/**
* When fullscreen isn't supported we can stretch the video container to as wide as the browser will let us.
*/
def enterFullWindow(): Unit = js.native
/**
* Set the current MediaError
* @param err A MediaError or a String/Number to be turned into a MediaError
* @return Player
*/
def error(err: MediaError | String | Int): this.type = js.native
/**
* Get the current MediaError
* @return MediaError or `null`
*/
def error(): MediaError = js.native
/**
* Return the video to its normal size after having been in full screen mode
*/
def exitFullscreen(): Unit = js.native
/**
* Exit full window
*/
def exitFullWindow(): Unit = js.native
/**
* Add/remove the vjs-fluid class
* @param bool Value of true adds the class, value of false removes the class
*/
def fluid(bool: Boolean): Unit = js.native
/**
* Check for call to either exit full window or full screen on ESC key
* @param event Event to check for key press
*/
def fullWindowOnEscKey(event: String): Unit = js.native
/**
* Get object for cached values.
*/
def getCache(): js.Object = js.native
/**
* Check if the player is in fullscreen mode
* @note As of the latest HTML5 spec, isFullscreen is no longer an official property and instead document.fullscreenElement is used. But isFullscreen is still a valuable property for internal player workings.
*/
def isFullscreen(): Boolean = js.native
/**
* Tell the player it's in fullscreen
* @param isFS Update the player's fullscreen state
* @return Self
*/
def isFullscreen(isFS: Boolean): this.type = js.native
/**
* The player's language code
* @return The locale string when getting
*/
def language(): String = js.native
/**
* The player's language code
* @param code The locale string
* @return Self when setting
* @note The language should be set in the player options if you want the
* the controls to be built with a specific language. Changing the lanugage
* later will not update controls text.
*/
def language(code: String): this.type = js.native
/**
* Get the player's language dictionary
* Merge every time, because a newly added plugin might call videojs.addLanguage() at any time
* Languages specified directly in the player options have precedence
* @return Array of languages
*/
def languages(): js.Array[String] = js.native
/**
* Begin loading the src data.
* @return Returns the player
*/
def load(): this.type = js.native
/**
* Get the loop attribute on the video element.
* @return The loop attribute value when getting
*/
def loop(): Boolean = js.native
/**
* Set the loop attribute on the video element.
* @param value Boolean to determine if video should loop
* @return Returns the player when setting
*/
def loop(value: Boolean): this.type = js.native
/**
* Get the current muted state
*/
def muted(): Boolean = js.native
/**
* Turn mute on or off
* @param value True to mute, false to unmute
* @return Returns the player when setting
*/
def muted(value: Boolean): this.type = js.native
/**
* Returns the current state of network activity for the element, from the codes in the list below.
*
* - NETWORK_EMPTY (numeric value 0) The element has not yet been initialised. All attributes are in their initial states.
* - NETWORK_IDLE (numeric value 1) The element's resource selection algorithm is active and has selected a resource, but it is not actually using the network at this time.
* - NETWORK_LOADING (numeric value 2) The user agent is actively trying to download data.
* - NETWORK_NO_SOURCE (numeric value 3) The element's resource selection algorithm is active, but it has not yet found a resource to use.
*
*/
def networkState(): Int = js.native
/**
* Pause the video playback
*/
def pause(): this.type = js.native
/**
* Check if the player is paused
*/
def paused(): Boolean = js.native
/**
* Start media playback
*/
def play(): this.type = js.native
/**
* Sets the current playback rate. A playback rate of 1.0 represents normal speed and 0.5 would indicate half-speed playback, for instance.
* @param rate New playback rate to set.
*/
def playbackRate(rate: Double): this.type = js.native
/**
* Gets the current playback rate. A playback rate of 1.0 represents normal speed and 0.5 would indicate half-speed playback, for instance.
*/
def playbackRate(): Double = js.native
/**
* Set the poster image source url
* @param src Poster image source URL
*/
def poster(src: String): this.type = js.native
/**
* Get the poster image source url
* @return Poster image source URL
*/
def poster(): String = js.native
/**
* Set the preload attribute
* @param value Boolean to determine if preload should be used
*/
def preload(value: Boolean): this.type = js.native
/**
* Get the preload attribute
*/
def preload(): Boolean = js.native
/**
* Returns a value that expresses the current state of the element with respect to rendering the current playback position, from the codes in the list below.
*
* - HAVE_NOTHING (numeric value 0) No information regarding the media resource is available.
* - HAVE_METADATA (numeric value 1) Enough of the resource has been obtained that the duration of the resource is available.
* - HAVE_CURRENT_DATA (numeric value 2) Data for the immediate current playback position is available.
* - HAVE_FUTURE_DATA (numeric value 3) Data for the immediate current playback position is available, as well as enough data for the user agent to advance the current playback position in the direction of playback.
* - HAVE_ENOUGH_DATA (numeric value 4) The user agent estimates that enough data is available for playback to proceed uninterrupted.
*
*/
def readyState(): Int = js.native
/**
* Calculates how much time is left.
*/
def remainingTime(): Int = js.native
/**
* Get an array of remote html track elements
*/
def remoteTextTrackEls(): js.Array[Element] = js.native
/**
* Get an array of remote text tracks
* @return
*/
def remoteTextTracks(): js.Array[String] = js.native
/**
* Remove a remote text track
* @param track Remote text track to remove
*/
def removeRemoteTextTrack(track: js.Object): Unit = js.native
/**
* Report user activity
* @param event Event object
*/
def reportUserActivity(event: js.Object): Unit = js.native
/**
* Increase the size of the video to full screen
* In some browsers, full screen is not supported natively, so it enters "full window mode", where the video fills the browser window.
* In browsers and devices that support native full screen, sometimes the browser's default controls will be shown, and not the Video.js custom skin.
* This includes most mobile devices (iOS, Android) and older versions of Safari.
*/
def requestFullscreen(): Unit = js.native
/**
* Reset the player. Loads the first tech in the techOrder, and calls `reset` on the `tech`.
*/
def reset(): this.type = js.native
/**
* @param isScrubbing True/false the user is scrubbing
*/
def scrubbing(isScrubbing: Boolean): this.type = js.native
/**
* Returns whether or not the user is "scrubbing".
* Scrubbing is when the user has clicked the progress bar handle and is dragging it along the progress bar.
*/
def scrubbing(): Boolean = js.native
/**
* Returns the TimeRanges of the media that are currently available for seeking to.
*/
def seekable(): TimeRanges = js.native
/**
* Returns whether or not the player is in the "seeking" state.
*/
def seeking(): Boolean = js.native
/**
* Select source based on tech-order or source-order
* Uses source-order selection if `options.sourceOrder` is truthy. Otherwise,
* defaults to tech-order selection
* @param sources The sources for a media asset
* @return Object of source and tech order, otherwise false
*/
def selectSource(sources: js.Array[VideoSource]): js.Object | Boolean = js.native
/**
* The source function updates the video source.
* There are three types of variables you can pass as the argument.
*
* - URL String: A URL to the the video file. Use this method if you are sure the current playback technology (HTML5/Flash) can support the source you provide. Currently only MP4 files can be used in both HTML5 and Flash.
* - Source Object (or element): A javascript object containing information about the source file. Use this method if you want the player to determine if it can support the file using the type information.
* - Array of Source Objects: To provide multiple versions of the source so that it can be played using HTML5 across browsers you can use an array of source objects. Video.js will detect which version is supported and load that file.
*
* @param source The source URL, object, or array of sources
* @return The player when setting
*/
def src(source: String | js.Array[VideoSource] | VideoSource): this.type = js.native
/**
* @return The current video source when getting
*/
def src(): String = js.native
/**
* Check to see if fullscreen is supported
*/
def supportsFullScreen(): Boolean = js.native
/**
* Return a reference to the current tech. It will only return a reference to the tech if given an object with the IWillNotUseThisInPlugins property on it. This is try and prevent misuse of techs by plugins.
* @return The Tech
*/
def tech(safety: js.Object): js.Object = js.native
/**
* Get an array of associated text tracks. captions, subtitles, chapters, descriptions
* @see [[http://www.w3.org/html/wg/drafts/html/master/embedded-content-0.html#dom-media-texttracks]]
* @return Array of track objects
*/
def textTracks(): js.Array[js.Object] = js.native
/**
* Converts track info to JSON
* @return JSON object of options
*/
def toJSON(): js.Object = js.native
/**
* Update styles of the player element (height, width and aspect ratio)
*/
def updateStyleEl_(): Unit = js.native
/**
* Set if user is active
* @param bool Value when setting
*/
def userActive(bool: Boolean): this.type = js.native
/**
* Get if user is active
* @return Value if user is active user when getting
*/
def userActive(): Boolean = js.native
/**
* Get video height
*/
def videoHeight(): Int = js.native
/**
* Get video width
*/
def videoWidth(): Int = js.native
/**
* Set the current volume of the media
* 0 is off (muted), 1.0 is all the way up, 0.5 is half way.
* @param percentAsDecimal The new volume as a decimal percent
*/
def volume(percentAsDecimal: Double): this.type = js.native
/**
* Get the current volume of the media
* 0 is off (muted), 1.0 is all the way up, 0.5 is half way.
*/
def volume(): Double = js.native
// Components
val posterImage: Component = js.native
val textTrackDisplay: Component = js.native
val loadingSpinner: Component = js.native
val bigPlayButton: Component = js.native
val controlBar: ControlBar = js.native
}
object IWillNotUseThisInPlugins extends js.Object {
val IWillNotUseThisInPlugins = true
}
@js.native
trait HlsTechHxrBeforeRequestOptions extends js.Object {
var uri: String = js.native
var headers: js.UndefOr[js.Object] = js.native
}
@js.native
trait HlsTechHxr extends js.Object {
var beforeRequest: js.Function1[HlsTechHxrBeforeRequestOptions, Unit] = js.native
}
@js.native
trait HlsTech extends js.Object {
val xhr: HlsTechHxr
}
@js.native
trait TechWithHls extends js.Object {
val hls: HlsTech = js.native
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy