* Fetches a window of items using the specified item id as reference; called by the receiver MediaManager when it needs more queue items; often as a request from senders. If only one of nextCount and prevCount is non-zero; fetchItems should only return items after or before the reference item; if both nextCount and prevCount are non-zero; a window of items including the reference item should be returned.
* Fetches a window of items using the specified item id as reference; called by the receiver MediaManager when it needs more queue items;
* often as a request from senders. If only one of nextCount and prevCount is non-zero; fetchItems should only return items after or before
* the reference item; if both nextCount and prevCount are non-zero; a window of items including the reference item should be returned.
* Initializes the queue with the requestData. This is called when a new LOAD request comes in to the receiver. If this returns or resolves to null; our default queueing implementation will create a queue based on queueData.items or the single media in the load request data.
* Initializes the queue with the requestData. This is called when a new LOAD request comes in to the receiver.
* If this returns or resolves to null; our default queueing implementation will create a queue based on queueData.items or the single media
* A callback for informing the following items have been inserted into the receiver queue in this session. A cloud based implementation can optionally choose to update its queue based on the new information.
* A callback for informing the following items have been inserted into the receiver queue in this session.
* A cloud based implementation can optionally choose to update its queue based on the new information.
* A callback for informing the following items have been removed from the receiver queue in this session. A cloud based implementation can optionally choose to update its queue based on the new information.
* A callback for informing the following items have been removed from the receiver queue in this session.
* A cloud based implementation can optionally choose to update its queue based on the new information.
* Get the preferred playback rate. (Can be used on shutdown event to save latest preferred playback rate to a persistent storage; so it can be used in next session in the cast options).
* Get the preferred playback rate. (Can be used on shutdown event to save latest preferred playback rate to a persistent storage;
* so it can be used in next session in the cast options).
* Sets the IDLE reason. This allows applications that want to force the IDLE state to indicate the reason that made the player going to IDLE state (a custom error; for example). The idle reason will be sent in the next status message. NOTE: Most applications do not need to set this value; it is only needed if they want to make the player go to IDLE in special circumstances and the default idleReason does not reflect their intended behavior.
* Sets the IDLE reason. This allows applications that want to force the IDLE state to indicate the reason that made the player going to IDLE state
* (a custom error; for example). The idle reason will be sent in the next status message. NOTE: Most applications do not need to set this value;
* it is only needed if they want to make the player go to IDLE in special circumstances and the default idleReason does not reflect their intended
* Sets a handler to return or modify PlaybackConfig; for a specific load request. The handler paramaters are the load request data and default playback config for the receiver (provided in the context options). The handler should returns a modified playback config; or null to prevent the media from playing. The return value can be a promise to allow waiting for data from the server.
* Sets a handler to return or modify PlaybackConfig; for a specific load request. The handler paramaters are the load request data
* and default playback config for the receiver (provided in the context options). The handler should returns a modified playback config;
* or null to prevent the media from playing. The return value can be a promise to allow waiting for data from the server.
* Sets a handler to return the media url for a load request. This handler can be used to avoid having the media content url published as part of the media status. By default the media contentId is used as the content url.
* Sets a handler to return the media url for a load request. This handler can be used to avoid having the media content url published as part
* of the media status. By default the media contentId is used as the content url.
*/
setMediaUrlResolver(
resolver:(loadRequestData: LoadRequestData)=>void
):void;
/**
* Provide an interceptor of incoming and outgoing messages. The interceptor can update the request data; and return updated data; a promise of updated data if need to get more data from the server; or null if the request should not be handled. Note that if load message interceptor is provided; and no interceptor is provided for preload - the load interceptor will be called for preload messages.
* Provide an interceptor of incoming and outgoing messages.
* The interceptor can update the request data; and return updated data; a promise of
* updated data if need to get more data from the server; or null if the request should not be handled.
* Note that if load message interceptor is provided; and no interceptor is provided for preload -
* the load interceptor will be called for preload messages.
* Set the preferred playback rate for follow up load or media items. The preferred playback rate will be updated automatically to the latest playback rate that was provided by a load request or explicit set of playback rate.
* Set the preferred playback rate for follow up load or media items. The preferred playback rate will be updated automatically to the latest
* playback rate that was provided by a load request or explicit set of playback rate.
* Set the preferred text track language. The preferred text track language will be updated automatically to the latest enabled language by a load request or explicit change to text tracks. (Should be called only in idle state; and Will only apply to next loaded media).
* Set the preferred text track language. The preferred text track language will be updated automatically to the latest enabled language
* by a load request or explicit change to text tracks. (Should be called only in idle state; and Will only apply to next loaded media).
* Specifies a VAST document to be used as the ads response instead of making a request via an ad tag url. This can be useful for debugging and other situations where a VAST response is already available.
* Specifies a VAST document to be used as the ads response instead of making a
* request via an ad tag url.
* This can be useful for debugging and other situations where a VAST response is
* It can be the url of the track or any other identifier that allows the receiver to find the content (when the track is not inband or included in the manifest). For example it can be the url of a vtt file.
* It can be the url of the track or any other identifier that allows the receiver
* to find the content (when the track is not inband or included in the manifest).
* For example it can be the url of a vtt file.
*/
trackContentId?: string;
/**
* It represents the MIME type of the track content. For example if the track is a vtt file it will be ‘text/vtt’. This field is needed for out of band tracks; so it is usually provided if a trackContentId has also been provided. It is not mandatory if the receiver has a way to identify the content from the trackContentId; but recommended. The track content type; if provided; must be consistent with the track type.
* It represents the MIME type of the track content. For example if the track
* is a vtt file it will be ‘text/vtt’. This field is needed for out of band tracks;
* so it is usually provided if a trackContentId has also been provided.
* It is not mandatory if the receiver has a way to identify the content from
* the trackContentId; but recommended.
* The track content type; if provided; must be consistent with the track type.
* New playback rate relative to current playback rate. New rate will be the result of multiplying the current rate with the value. For example a value of 1.1 will increase rate by 10%. (Only used if the playbackRate value is not provided).
* New playback rate relative to current playback rate.
* New rate will be the result of multiplying the current rate with the value.
* For example a value of 1.1 will increase rate by 10%.
* (Only used if the playbackRate value is not provided).
* Application-specific data for this request. It enables the sender and receiver to easily extend the media protocol without having to use a new namespace with custom messages.
* Application-specific data for this request.
* It enables the sender and receiver to easily extend the media protocol
* without having to use a new namespace with custom messages.
* ID of the current media Item after the deletion (if not provided; the currentItem value will be the same as before the deletion; if it does not exist because it has been deleted; the currentItem will point to the next logical item in the list).
* ID of the current media Item after the deletion
* (if not provided; the currentItem value will be the same as before the deletion;
* if it does not exist because it has been deleted; the currentItem will point to
* the next logical item in the list).
*/
currentItemId?: number;
/**
* Seconds since the beginning of content to start playback of the current item. If provided; this value will take precedence over the startTime value provided at the QueueItem level but only the first time the item is played. This is to cover the common case where the user jumps to the middle of an item so the currentTime does not apply to the item permanently like the QueueItem startTime does. It avoids having to reset the startTime dynamically (that may not be possible if the phone has gone to sleep).
* Seconds since the beginning of content to start playback of the current item.
* If provided; this value will take precedence over the startTime value provided
* at the QueueItem level but only the first time the item is played.
* This is to cover the common case where the user jumps to the middle of an
* item so the currentTime does not apply to the item permanently like the
* QueueItem startTime does. It avoids having to reset the startTime dynamically
* (that may not be possible if the phone has gone to sleep).
*/
currentTime?: number;
/**
* List of queue items to be updated. No reordering will happen; the items will retain the existing order.
* List of queue items to be updated. No reordering will happen; the items will
* retain the existing order.
*/
items?: QueueItem[];
/**
* Skip/Go back number of items with respect to the position of currentItem (it can be negative). If it is out of boundaries; the currentItem will be the next logical item in the queue wrapping around the boundaries. The new currentItem position will follow the rules of the queue repeat behavior.
* Skip/Go back number of items with respect to the position of currentItem
* (it can be negative). If it is out of boundaries; the currentItem will be the
* next logical item in the queue wrapping around the boundaries.
* The new currentItem position will follow the rules of the queue repeat behavior.
* ID of the current media Item after the deletion (if not provided; the currentItem value will be the same as before the deletion; if it does not exist because it has been deleted; the currentItem will point to the next logical item in the list).
* ID of the current media Item after the deletion (if not provided;
* the currentItem value will be the same as before the deletion;
* if it does not exist because it has been deleted;
* the currentItem will point to the next logical item in the list).
*/
currentItemId?: number;
/**
* Seconds since the beginning of content to start playback of the current item. If provided; this value will take precedence over the startTime value provided at the QueueItem level but only the first time the item is played. This is to cover the common case where the user jumps to the middle of an item so the currentTime does not apply to the item permanently like the QueueItem startTime does. It avoids having to reset the startTime dynamically (that may not be possible if the phone has gone to sleep).
* Seconds since the beginning of content to start playback of the current item.
* If provided; this value will take precedence over the startTime value provided
* at the QueueItem level but only the first time the item is played.
* This is to cover the common case where the user jumps to the middle of an
* item so the currentTime does not apply to the item permanently like
* the QueueItem startTime does. It avoids having to reset the startTime dynamically
* (that may not be possible if the phone has gone to sleep).
*/
currentTime?: number;
/**
* ID of the item that will be located immediately after the reordered list. If the ID is not found or it is not provided; the reordered list will be appended at the end of the existing list.
* ID of the item that will be located immediately after the reordered list.
* If the ID is not found or it is not provided;
* the reordered list will be appended at the end of the existing list.
*/
insertBefore?: number;
/**
* IDs of the items to be reordered; in the new order. Items not provided will keep their existing order. The provided list will be inserted at the position determined by insertBefore. For example:
If insertBefore is not specified Existing queue: “A”;”D”;”G”;”H”;”B”;”E” itemIds: “D”;”H”;”B” New Order: “A”;”G”;”E”;“D”;”H”;”B”
If insertBefore is “A” Existing queue: “A”;”D”;”G”;”H”;”B” itemIds: “D”;”H”;”B” New Order: “D”;”H”;”B”;“A”;”G”;”E”
If insertBefore is “G” Existing queue: “A”;”D”;”G”;”H”;”B” itemIds: “D”;”H”;”B” New Order: “A”;“D”;”H”;”B”;”G”;”E”
*/
* IDs of the items to be reordered; in the new order.
* Items not provided will keep their existing order.
* The provided list will be inserted at the position determined by insertBefore.
* For example:
* If insertBefore is not specified Existing queue: “A”;”D”;”G”;”H”;”B”;”E” itemIds:
* “D”;”H”;”B” New Order: “A”;”G”;”E”;“D”;”H”;”B”
* If insertBefore is “A” Existing queue: “A”;”D”;”G”;”H”;”B” itemIds:
* “D”;”H”;”B” New Order: “D”;”H”;”B”;“A”;”G”;”E”
* If insertBefore is “G” Existing queue: “A”;”D”;”G”;”H”;”B” itemIds:
* ID of the current media Item after the deletion (if not provided; the currentItem value will be the same as before the deletion; if it does not exist because it has been deleted; the currentItem will point to the next logical item in the list).
* ID of the current media Item after the deletion
* (if not provided; the currentItem value will be the same as before the deletion;
* if it does not exist because it has been deleted;
* the currentItem will point to the next logical item in the list).
*/
currentItemId?: number;
/**
* Seconds since the beginning of content to start playback of the current item. If provided; this value will take precedence over the startTime value provided at the QueueItem level but only the first time the item is played. This is to cover the common case where the user jumps to the middle of an item so the currentTime does not apply to the item permanently like the QueueItem startTime does. It avoids having to reset the startTime dynamically (that may not be possible if the phone has gone to sleep).
* Seconds since the beginning of content to start playback of the current item.
* If provided; this value will take precedence over the startTime value provided
* at the QueueItem level but only the first time the item is played.
* This is to cover the common case where the user jumps to the middle of an
* item so the currentTime does not apply to the item permanently like the
* QueueItem startTime does. It avoids having to reset the startTime dynamically
* (that may not be possible if the phone has gone to sleep).
* Seconds (since the beginning of content) to start playback of the first item to be played. If provided; this value will take precedence over the startTime value provided at the QueueItem level but only the first time the item is played. This is to cover the common case where the user casts the item that was playing locally so the currentTime does not apply to the item permanently like the QueueItem startTime does. It avoids having to reset the startTime dynamically (that may not be possible if the phone has gone to sleep).
* Seconds (since the beginning of content) to start playback of the first item to
* be played. If provided; this value will take precedence over the
* startTime value provided at the QueueItem level but only the first
* time the item is played. This is to cover the common case where the user
* casts the item that was playing locally so the currentTime does not apply
* to the item permanently like the QueueItem startTime does.
* It avoids having to reset the startTime dynamically
* (that may not be possible if the phone has gone to sleep).
* The index of the item in the items array that must be the first currentItem (the item that will be played first). Note this is the index of the array (starts at 0) and not the itemId (as it is not known until the queue is created). If repeatMode is REPEAT_OFF playback will end when the last item in the array is played (elements before the startIndex will not be played). This may be useful for continuation scenarios where the user was already using the sender app and in the middle decides to cast. In this way the sender app does not need to map between the local and remote queue positions or saves one extra QUEUE_UPDATE request.
* The index of the item in the items array that must be the first currentItem
* (the item that will be played first). Note this is the index of the array
* (starts at 0) and not the itemId (as it is not known until the queue is created).
* If repeatMode is REPEAT_OFF playback will end when the last item in the array is
* played (elements before the startIndex will not be played).
* This may be useful for continuation scenarios where the user was already
* using the sender app and in the middle decides to cast.
* In this way the sender app does not need to map between the local and remote queue
* positions or saves one extra QUEUE_UPDATE request.
*/
startIndex?: number;
}
/**
* Queue item information. Application developers may need to create a QueueItem to insert a queue element using InsertQueueItems. In this case they should not provide an itemId (as the actual itemId will be assigned when the item is inserted in the queue). This prevents ID collisions with items added from a sender app.
* Queue item information. Application developers may need to create a QueueItem to
* insert a queue element using InsertQueueItems. In this case they should not
* provide an itemId (as the actual itemId will be assigned when the item is inserted
* in the queue). This prevents ID collisions with items added from a sender app.
*/
classQueueItem{
constructor(opt_itemId?: number);
/**
* Array of Track trackIds that are active. If the array is not provided; the default tracks will be active.
* Array of Track trackIds that are active. If the array is not provided;
* the default tracks will be active.
*/
activeTrackIds?: number[];
/**
* If the autoplay parameter is not specified or is true; the media player will begin playing the element in the queue when the item becomes the currentItem.
* If the autoplay parameter is not specified or is true; the media player
* will begin playing the element in the queue when the item becomes the currentItem.
* Unique identifier of the item in the queue. The attribute is optional because for LOAD or INSERT should not be provided (as it will be assigned by the receiver when an item is first created/inserted).
* Unique identifier of the item in the queue.
* The attribute is optional because for LOAD or INSERT should not be provided
* (as it will be assigned by the receiver when an item is first created/inserted).
* Playback duration of the item; if it is larger than the actual duration - startTime it will be ignored (default behavior). It can be negative; in such case the duration will be the actual asset duration minus the duration provided. It can be used for photo slideshows to control the duration the item should be presented or for live events to control the duration that the program should be played. It may be useful for autoplay scenarios to avoid displaying all the credits after an episode has ended.
* Playback duration of the item; if it is larger than the actual duration -
* startTime it will be ignored (default behavior).
* It can be negative; in such case the duration will be the actual asset
* duration minus the duration provided.
* It can be used for photo slideshows to control the duration the item should
* be presented or for live events to control the duration that the program
* should be played. It may be useful for autoplay scenarios to avoid displaying all
* the credits after an episode has ended.
*/
playbackDuration?: number;
/**
* This parameter is a hint for the receiver to preload this media item before it is played. It allows for a smooth transition between items played from the queue. The time is expressed in seconds; relative to the beginning of this item playback (usually the end of the previous item playback). Only positive values are valid. For example; if the value is 10 seconds; this item will be preloaded 10 seconds before the previous item has finished. The receiver will try to honor this value but will not guarantee it; for example if the value is larger than the previous item duration the receiver may just preload this item shortly after the previous item has started playing (there will never be two items being preloaded in parallel). Also; if an item is inserted in the queue just after the currentItem and the time to preload is higher than the time left on the currentItem; the preload will just happen as soon as possible.
* This parameter is a hint for the receiver to preload this media
* item before it is played. It allows for a smooth transition between items
* played from the queue. The time is expressed in seconds; relative to
* the beginning of this item playback (usually the end of the previous item playback).
* Only positive values are valid. For example; if the value is 10 seconds; this item
* will be preloaded 10 seconds before the previous item has finished.
* The receiver will try to honor this value but will not guarantee it;
* for example if the value is larger than the previous item duration the
* receiver may just preload this item shortly after the previous item has started playing
* (there will never be two items being preloaded in parallel).
* Also; if an item is inserted in the queue just after the currentItem and the time to preload is higher than the
* time left on the currentItem; the preload will just happen as soon as possible.
*/
preloadTime?: number;
/**
* Seconds since beginning of content. If the content is live content; and startTime is not specified; the stream will start at the live position.
* Seconds since beginning of content. If the content is live content;
* and startTime is not specified; the stream will start at the live position.
* ID of the current media Item after the insertion (if not provided; the currentItem value will be the same as before the insertion).
* ID of the current media Item after the insertion (if not provided;
* the currentItem value will be the same as before the insertion).
*/
currentItemId?: number;
/**
* Index (relative to the items array; starting with 0) of the new current media Item. For inserted items we use the index (similar to startIndex in QUEUE_LOAD) and not currentItemId; because the itemId is unknown until the items are inserted. If not provided; the currentItem value will be the same as before the insertion (unless currentItemId is provided). This param allows to make atomic the common use case of insert and play an item.
* Index (relative to the items array; starting with 0) of the new current media Item.
* For inserted items we use the index (similar to startIndex in QUEUE_LOAD) and not
* currentItemId; because the itemId is unknown until the items are inserted.
* If not provided; the currentItem value will be the same as before the insertion
* (unless currentItemId is provided). This param allows to make atomic the common use
* case of insert and play an item.
*/
currentItemIndex?: number;
/**
* Seconds since the beginning of content to start playback of the current item. If provided; this value will take precedence over the startTime value provided at the QueueItem level but only the first time the item is played. This is to cover the common case where the user jumps to the middle of an item so the currentTime does not apply to the item permanently like the QueueItem startTime does. It avoids having to reset the startTime dynamically (that may not be possible if the phone has gone to sleep).
* Seconds since the beginning of content to start playback of the current item.
* If provided; this value will take precedence over the startTime value provided
* at the QueueItem level but only the first time the item is played.
* This is to cover the common case where the user jumps to the middle of an
* item so the currentTime does not apply to the item permanently like the
* QueueItem startTime does. It avoids having to reset the startTime dynamically
* (that may not be possible if the phone has gone to sleep).
*/
currentTime?: number;
/**
* ID of the item that will be located immediately after the inserted list. If the ID is not found or it is not provided; the list will be appended at the end of the existing list.
* ID of the item that will be located immediately after the inserted list.
* If the ID is not found or it is not provided; the list will be appended at
* the end of the existing list.
*/
insertBefore?: number;
/**
* List of queue items. The itemId field of the items should be empty. It is sorted (first element will be played first).
* List of queue items. The itemId field of the items should be empty.
* It is sorted (first element will be played first).
* Array of trackIds that are active. If the array is not provided; the default tracks will be active.
* Array of trackIds that are active. If the array is not provided;
* the default tracks will be active.
*/
activeTrackIds: number[];
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified;the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin playing
* the content when it is loaded. Even if autoplay is not specified;the media player
* implementation may choose to begin playback immediately.
* Optional credentials type. The type 'cloud' is a reserved type used by load requests that were originated by voice assistant commands.
* Optional credentials type. The type 'cloud' is a reserved type used by load
* requests that were originated by voice assistant commands.
*/
credentialsType?: string;
/**
* Seconds since beginning of content. If the content is live content; and currentTime is not specified; the stream will start at the live position.
* Seconds since beginning of content. If the content is live content;
* and currentTime is not specified; the stream will start at the live position.
*/
currentTime?: number;
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified; the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin playing
* the content when it is loaded. Even if autoplay is not specified; the media
* player implementation may choose to begin playback immediately.
* Application-specific data for this request. It enables the sender and receiver to easily extend the media protocol without having to use a new namespace with custom messages.
* Application-specific data for this request.
* It enables the sender and receiver to easily extend the media protocol
* without having to use a new namespace with custom messages.
* Array of trackIds that are active. If the array is not provided; the default tracks will be active.
* Array of trackIds that are active. If the array is not provided;
* the default tracks will be active.
*/
activeTrackIds: number[];
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified;the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin playing
* the content when it is loaded. Even if autoplay is not specified;the media player
* implementation may choose to begin playback immediately.
* Optional credentials type. The type 'cloud' is a reserved type used by load requests that were originated by voice assistant commands.
* Optional credentials type. The type 'cloud' is a reserved type used by load
* requests that were originated by voice assistant commands.
*/
credentialsType?: string;
/**
* Seconds since beginning of content. If the content is live content; and currentTime is not specified; the stream will start at the live position.
* Seconds since beginning of content. If the content is live content; and
* currentTime is not specified; the stream will start at the live position.
*/
currentTime?: number;
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified; the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin playing
* the content when it is loaded. Even if autoplay is not specified;
* the media player implementation may choose to begin playback immediately.
* Application-specific data for this request. It enables the sender and receiver to easily extend the media protocol without having to use a new namespace with custom messages.
* Application-specific data for this request.
* It enables the sender and receiver to easily extend the media protocol
* without having to use a new namespace with custom messages.
* ID of the next Item; only available if it has been preloaded. Media items can be preloaded and cached temporarily in memory; so when they are loaded later on; the process is faster (as the media does not have to be fetched from the network).
* ID of the next Item; only available if it has been preloaded.
* Media items can be preloaded and cached temporarily in memory;
* so when they are loaded later on; the process is faster
* (as the media does not have to be fetched from the network).
* Partial list of break clips that includes current break clip that receiver is playing or ones that receiver will play shortly after; instead of sending whole list of clips. This is to avoid overflow of MediaStatus message.
* Partial list of break clips that includes current break clip that receiver
* is playing or ones that receiver will play shortly after; instead of sending
* whole list of clips. This is to avoid overflow of MediaStatus message.
* Optional media url; to allow using contentId for real id. If contentUrl is provided; it will be used as media url; otherwise the contentId will be used as the media url.
* Optional media url; to allow using contentId for real id. If contentUrl
* is provided; it will be used as media url; otherwise the contentId will
* Array of trackIds that are active. If the array is not provided; the default tracks will be active.
* Array of trackIds that are active. If the array is not provided; the
* default tracks will be active.
*/
activeTrackIds: number[];
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified;the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin
* playing the content when it is loaded. Even if autoplay is not
* specified;the media player implementation may choose to begin playback
* Optional credentials type. The type 'cloud' is a reserved type used by load requests that were originated by voice assistant commands.
* Optional credentials type. The type 'cloud' is a reserved type used by
* load requests that were originated by voice assistant commands.
*/
credentialsType?: string;
/**
* Seconds since beginning of content. If the content is live content; and currentTime is not specified; the stream will start at the live position.
* Seconds since beginning of content. If the content is live content;
* and currentTime is not specified; the stream will start at the live position.
*/
currentTime?: number;
/**
* If the autoplay parameter is specified; the media player will begin playing the content when it is loaded. Even if autoplay is not specified; the media player implementation may choose to begin playback immediately.
* If the autoplay parameter is specified; the media player will begin playing
* the content when it is loaded. Even if autoplay is not specified; the media
* player implementation may choose to begin playback immediately.
* A boolean value indicates whether a live stream is ended. If it is done; the end of live seekable range should stop updating.
* A boolean value indicates whether a live stream is ended. If it is done;
* the end of live seekable range should stop updating.
*/
isLiveDone?: boolean;
/**
* A boolean value indicates whether the live seekable range is a moving window. If false; it will be either a expanding range or a fixed range meaning live has ended.
* A boolean value indicates whether the live seekable range is a moving window.
* If false; it will be either a expanding range or a fixed range meaning live
// Fired when the visibility of the application has changed (for example after a HDMI Input change or when the TV is turned off/on and the cast device is externally powered). Note that this API has the same effect as the webkitvisibilitychange event raised by your document, we provided it as CastReceiverManager API for convenience and to avoid a dependency on a webkit-prefixed event.
// Fired when the visibility of the application has changed
// (for example after a HDMI Input change or when the TV is turned
// off/on and the cast device is externally powered).
// Note that this API has the same effect as the webkitvisibilitychange event raised
// by your document, we provided it as CastReceiverManager API for convenience and
// to avoid a dependency on a webkit-prefixed event.
|"VISIBILITY_CHANGED"
// Fired when the standby state of the TV has changed. This event is related to the visibility chnaged event, as if the TV is in standby the visibility will be false, the visibility is more granular (as it also detects that the TV has selected a different channel) but it is not reliably detected in all TVs, standby can be used in those cases as most TVs implement it.
// Fired when the standby state of the TV has changed.
// This event is related to the visibility chnaged event, as if the TV is in standby
// the visibility will be false, the visibility is more granular
// (as it also detects that the TV has selected a different channel)
// but it is not reliably detected in all TVs,
// standby can be used in those cases as most TVs implement it.
* Player data binder. Bind a player data object to the player state. The player data will be updated to reflect correctly the current player state without firing any change event.
* Player data binder. Bind a player data object to the player state.
* The player data will be updated to reflect correctly the current player state without firing any change event.
* Whether the player metadata (ie: title; currentTime) should be displayed. This will be true if at least one field in the metadata should be displayed. In some cases; displayStatus will be true; but parts of the metadata should be hidden (ie: the media title while media is seeking). In these cases; additional css can be applied to hide those elements. For cases where the media is audio-only; this will almost always be true. In cases where the media is video; this will be true when: (1) the video is loading; buffering; or seeking (2) a play request was made in the last five seconds while media is already playing; (3) there is a request made to show the status in the last five seconds; or (4) the media was paused in the last five seconds.
* Whether the player metadata (ie: title; currentTime) should be displayed.
* This will be true if at least one field in the metadata should be displayed.
* In some cases; displayStatus will be true; but parts of the metadata should be hidden
* (ie: the media title while media is seeking).
* In these cases; additional css can be applied to hide those elements.
* For cases where the media is audio-only; this will almost always be true.
* In cases where the media is video; this will be true when:
* (1) the video is loading; buffering; or seeking
* (2) a play request was made in the last five seconds while media is already playing;
* (3) there is a request made to show the status in the last five seconds; or
* (4) the media was paused in the last five seconds.
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Craig Bruce