Player Events
CONFIGURED
The CONFIGURED event is fired when all of the async tasks on setConfig has completed.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "CONFIGURED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CONFIGURED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CONFIGURED,
    data: nil
)
{
    name: config.name,
    type: "CONFIGURED",
    data: invalid
}
CAN_PLAY
The CAN_PLAY event is fired when the user agent can start playing the media. Everytime buffering ends and player is able to play, this event is fired.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "CAN_PLAY",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CAN_PLAY,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CAN_PLAY,
    data: nil
)
{
    name: config.name,
    type: "CAN_PLAY",
    data: invalid
}
DURATION_CHANGE
The DURATION_CHANGE event is fired when the duration attribute has been updated.
| Value | Description | 
|---|---|
duration Float | Number representing the duration of the video. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "DURATION_CHANGE",
    data: {
        duration: 123
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.DURATION_CHANGE,
    data = LuraEventData.DurationChanged(duration = 123.0)
)
LuraEventBundle(
    name: config.name,
    type: .DURATION_CHANGE,
    data: DurationChanged(duration: 123)
)
{
    name: config.name,
    type: "DURATION_CHANGE",
    data: {
        duration: 123
    }
}
ENDED
The ENDED event is fired when playback or streaming has stopped because the end of the media was reached or because no further data is available.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "ENDED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.ENDED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .ENDED,
    data: nil
)
{
    name: config.name,
    type: "ENDED",
    data: invalid
}
LOADED_MEDIA_INFO
The LOADED_MEDIA_INFO event is fired when the metadata has been loaded.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "LOADED_MEDIA_INFO",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.LOADED_MEDIA_INFO,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .LOADED_MEDIA_INFO,
    data: nil
)
{
    name: config.name,
    type: "LOADED_MEDIA_INFO",
    data: invalid
}
PAUSED
The PAUSED event is fired when the paused property is changed from false to true
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "PAUSED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PAUSED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PAUSED,
    data: nil
)
{
    name: config.name,
    type: "PAUSED",
    data: invalid
}
PLAYING
The PLAYING event is fired when the paused property is changed from true to false.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "PLAYING",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYING,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PLAYING,
    data: nil
)
{
    name: config.name,
    type: "PLAYING",
    data: invalid
}
BUFFER_CHANGED
The BUFFER_CHANGED event is fired periodically as the LuraPlayer loads a resource.
| Value | Description | 
|---|---|
start Float | Number representing the start of the buffer in seconds. | 
end Float | Number representing the end of the buffer in seconds. | 
- Javascript
 - Kotlin
 
{
    name: config.name,
    type: "BUFFER_CHANGED",
    data: {
        start: 0.0,
        end: 40.0
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.BUFFER_CHANGED,
    data = LuraEventData.BufferChanged(
        start = 0.0,
        end = 40.0
    )
)
BUFFERING_STARTED
The BUFFERING_STARTED event is fired when the LuraPlayer stopped playing temporarily due to lack of buffer.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "BUFFERING_STARTED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.BUFFERING_STARTED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .BUFFERING_STARTED,
    data: nil
)
{
    name: config.name,
    type: "BUFFERING_STARTED",
    data: invalid
}
BUFFERING_ENDED
The BUFFERING_ENDED event is fired when the LuraPlayer starts playing after stopping temporarily due to lack of buffer.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "BUFFERING_ENDED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.BUFFERING_ENDED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .BUFFERING_ENDED,
    data: nil
)
{
    name: config.name,
    type: "BUFFERING_ENDED",
    data: invalid
}
RATE_CHANGE
The RATE_CHANGE event is fired when the playback rate has changed.
| Value | Description | 
|---|---|
playbackRate Float | Number representing the playback rate of the video compared to the original speed of the video. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "RATE_CHANGE",
    data: {
        playbackRate: 1.0
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.RATE_CHANGE,
    data = LuraEventData.RateChanged(playbackRate = 1.0F)
)
LuraEventBundle(
    name: config.name,
    type: .RATE_CHANGE,
    data: RateChanged(playbackRate: 1.0)
)
{
    name: config.name,
    type: "RATE_CHANGE",
    data: {
        playbackRate: 1.0
    }
}
SEEKING
The SEEKING event is fired when a seek operation starts, meaning the Boolean seeking attribute has changed to true and the media is seeking a new position.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "SEEKING",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.SEEKING,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .SEEKING,
    data: nil
)
{
    name: config.name,
    type: "SEEKING",
    data: invalid
}
SEEKED
The SEEKED event is fired when a seek operation finishes, meaning the Boolean seeking attribute has changed to false and the media is seeked to a new position.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "SEEKED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.SEEKED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .SEEKED,
    data: nil
)
{
    name: config.name,
    type: "SEEKED",
    data: invalid
}
VOLUME_CHANGED
The VOLUME_CHANGED event is fired when the volume has changed.
| Value | Description | 
|---|---|
volume Float | Number representing the volume percentage of the video in between 0.0 and 1.0. | 
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "VOLUME_CHANGED",
    data: {
        volume: 1.0
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.VOLUME_CHANGED,
    data = LuraEventData.VolumeChanged(volume = 1.0F)
)
LuraEventBundle(
    name: config.name,
    type: .VOLUME_CHANGED,
    data: VolumeChanged(volume: 1.0)
)
MUTE_CHANGED
The MUTE_CHANGED event is fired when the muted attribute has changed.
| Value | Description | 
|---|---|
muted Boolean | Boolean value representing whether the video is muted or not. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "MUTE_CHANGED",
    data: {
        muted: true
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.MUTE_CHANGED,
    data = LuraEventData.MuteChanged(muted = false)
)
LuraEventBundle(
    name: config.name,
    type: .MUTE_CHANGED,
    data: MuteChanged(muted: true)
)
{
    name: config.name,
    type: "MUTE_CHANGED",
    data: {
        muted: true
    }
}
TIME_UPDATED
The TIME_UPDATED event is fired when the time indicated by the currentTime attribute has been updated.
| Value | Description | 
|---|---|
contentTime Double | Number representing current time without ads. | 
type "ad" | "content" | "slate" | Type of the currently playing video. | 
ad Object | null | Not null if the type is ad, contains ad information | 
ad.id String | Ad break id. | 
ad.totalAds Integer | Total number of ads in the ad break. | 
ad.adPosition Integer | Number representing which ad is playing in the ad break. | 
ad.breakDuration Double | Number representing duration of the ad break. | 
ad.adDuration Double | Number representing duration of the current ad. | 
ad.timeInAd Double | Number representing the current time in the ad. | 
ad.timeInBreak Double | Number representing the current time in the ad break. | 
ad.isClickable Boolean | Is Ad has ClickThrough url. | 
annotations Object[] | Active annotations in the time frame | 
annotations.start Double | Active annotation start time | 
annotations.end Double | Active annotation end time | 
annotations.type String | Type of the active annotataion. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "TIME_UPDATED",
    data: {
        contentTime: 15,
        type: "ad",
        ad: {
            id: "ad-break-id",
            totalAds: 3,
            adPosition: 2,
            breakDuration: 90,
            adDuration: 30,
            timeInAd: 15,
            timeInBreak: 45,
            isClickable: false
        },
        annotations: [
          {
            start: 0.0,
            end: 25.0,
            type: "intro"
          }
        ]
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.TIME_UPDATED,
    data = LuraEventData.TimeUpdate(
        contentTime = 5.0,
        ad = LuraEventData.TimeUpdate.Ad(
            id = "",
            totalAds = 2,
            adPosition = 1,
            breakDuration = 300.0,
            adDuration = 30.0,
            timeInAd = 3.0,
            timeInBreak = 43.0,
            skipOffset = 5.0,
            isClickable = false
        ),
        annotations = lisOf<LuraAnnotation>(
            LuraAnnotation(
              start = 0.0,
              end = 0.0
              type = "intro"
            )
        )
    )
)
LuraEventBundle(
    name: config.name,
    type: .TIME_UPDATED,
    data: TimeUpdate(
        contentTime: 15,
        type: "ad",
        ad: TimeUpdate.Ad(
            id: "ad-break-id",
            totalAds: 3,
            adPosition: 2,
            breakDuration: 90,
            adDuration: 30,
            timeInAd: 15,
            timeInBreak: 45,
            isClickable: false
        ),
        annotations: [
            Annotation(
                start: 0.0,
                end: 25.0,
                type: "intro"
            )
        ]
    )
)
{
    name: config.name,
    type: "TIME_UPDATED",
    data: {
        contentTime: 15,
        type: "ad",
        ad: {
            id: "ad-break-id",
            totalAds: 3,
            adPosition: 2,
            breakDuration: 90,
            adDuration: 30,
            timeInAd: 15,
            timeInBreak: 45,
            skipOffset: 5,
            isClickable: false
        },
        "annotations":[
          {
            "end":10,
            "start":0,
            "type":"intro"
          },
        ]
    }
}
TRICK_PLAY_DATA_EVENT
The TRICK_PLAY_DATA_EVENT event is fired as a response to the trick play data requested for a specific time.
| Value | Description | 
|---|---|
time Float | Number indicating the time of the trick play image. | 
width Float | Number indicating the width of the trick play image. | 
imageData String | Base64 encoded string that can be set to img src to display. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "TRICK_PLAY_DATA_EVENT",
    data: {
        time: 15.0,
        width: 640,
        imageData: "..."
    }
}
LuraEvent(
    name = "config.name",
    type = LuraEventType.TRICK_PLAY_DATA_EVENT,
    data = LuraEventData.TrickPlayDataEvent(
        timeMs = 100L,
        width = 640,
        imageData = "..."
    )
)
LuraEventBundle(
    name: config.name,
    type: .TRICK_PLAY_DATA_EVENT,
    data: TrickPlayData(
        time: 15.0,
        width: 640,
        imageData: "..."
    )
)
{
    name: config.name,
    type: "TRICK_PLAY_DATA_EVENT",
    data: {
        time: 15,
        imagedata: "memory://..."
    }
}
TRACK_CHANGED
The TRACK_CHANGED event is fired when the audio, video or caption track has changed.
| Value | Description | 
|---|---|
trackType "caption" | "video" | "audio" | Type of the track that is changed. | 
track lura.unified.VideoTrack | lura.unified.AudioTrack | lura.unified.CaptionTrack | Track that have changed. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "TRACK_CHANGED",
    data: {
        trackType: "caption",
        track: {
            language: "en",
            label: "English",
            active: true
        }
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.TRACK_CHANGED,
    data = LuraEventData.TrackChanged(
        track = LuraTrack.Text(
            groupIndex = 1,
            index = 1,
            id ="",
            language = "en",
            isSelected = true
        )
    )
)
LuraEventBundle(
    name: config.name,
    type: .TRACK_CHANGED,
    data: TrackChanged(
        trackType: "caption",
        track: CaptionTrack(
            active: true,
            language: "en",
            label: "English"
        )
    )
)
{
    name: config.name,
    type: "TRACK_CHANGED",
    data: {
        trackType: "caption",
        track: {
            __id: "webvtt/2",
            language: "en",
            label: "English",
            active: true
        }
    }
}
TRACKS_UPDATED
The TRACKS_UPDATED event is fired when the audio, video or caption tracks has been updated.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "TRACKS_UPDATED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.TRACKS_UPDATED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .TRACKS_UPDATED,
    data: nil
)
{
    name: config.name,
    type: "TRACKS_UPDATED",
    data: null
}
SHOW_CAPTION
The SHOW_CAPTION event is fired for displaying captions in a custom UI implementation.
| Value | Description | 
|---|---|
text String | Caption Text that should be displayed | 
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "SHOW_CAPTION",
    data: {
      text: "Lorem ipsum dolor sit amet."
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.SHOW_CAPTION,
    data = LuraEventData.ShowCaption(
      text = "Lorem ipsum dolor sit amet."
    )
)
LuraEventBundle(
    name: config.name,
    type: .SHOW_CAPTION,
    data: ShowCaption(
        text: "Lorem ipsum dolor sit amet."
    )
)
CAPTION_DISPLAY_CHANGED
The CAPTION_DISPLAY_CHANGED event is fired when a caption track is activated or deactivated.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "CAPTION_DISPLAY_CHANGED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CAPTION_DISPLAY_CHANGED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CAPTION_DISPLAY_CHANGED,
    data: nil
)
{
    name: config.name,
    type: "CAPTION_DISPLAY_CHANGED",
    data: null
}
EVENT_METADATA_UPDATED
The EVENT_METADATA_UPDATED event is fired when the metadata is updated. (e.g. Live event boundaries)
| Value | Description | 
|---|---|
title String | Title of the event (initially configured title if there are no scheduled events). | 
description String | Description of the event (initially configured description if there are no scheduled events). | 
startTime Float | Start time of the event | 
endTime Float | End time of the event | 
customMetadata Object<[key: string]: string> | Custom metadata of the event | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "EVENT_METADATA_UPDATED",
    data: {
        metadata: {
            title: "Lorem Ipsum",
            description: "description",
            startTime: 158,
            endTime: 258,
            customMetadata: {
                [key: string]: string
            }
        }
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.EVENT_METADATA_UPDATED,
    data = LuraEventData.VideoMetadata(
        metadata = LuraVideoMetadata()
    )
)
LuraEventBundle(
    name: config.name,
    type: .EVENT_METADATA_UPDATED,
    data: VideoMetadata(
        metadata: VideoMetadata.LuraVideoMetadata(
            title: "Lorem Ipsum",
            description: "description",
            startTime: 158,
            endTime: 258,
            customMetadata: [String : Any]
        )
    )
)
{
    name: config.name,
    type: "EVENT_METADATA_UPDATED",
    data: {
        metadata: {
            title: "Lorem Ipsum",
            description: "description",
            startTime: 158,
            endTime: 258,
            eventId : "123",
        }
    }
}
REPLAY
Event fired when the video replays
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "REPLAY",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.REPLAY,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .REPLAY,
    data: nil
)
{
    name: config.name,
    type: "REPLAY",
    data: invalid
}
ERROR
Event fired when the LuraPlayer encounters an error that leads to playback failure.
| Value | Description | 
|---|---|
errorCode String | String representing why the error is fired. | 
message String | String representing possible information about the error. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "ERROR",
    data: {
        errorCode: "NETWORK_ERROR",
        message: "Failed to fetch"
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.ERROR,
    data = LuraEventData.Error(
        exception = LuraException(
            type = LuraExceptionType.ConfiguringError,
            message = "",
            cause = Exception()
        )
    )
)
LuraEventBundle(
    name: config.name,
    type: .ERROR,
    data: ErrorData(
        errorCode: "NETWORK_ERROR",
        message: "Failed to fetch"
    )
)
{
    name: config.name,
    type: "ERROR",
    data: {
        message: "Failed to fetch"
    }
}
WARNING
Event fired when the LuraPlayer encounters an error which doesn't affect playback and is not critical (e.g. ad request fails due to ad blockers).
| Value | Description | 
|---|---|
errorCode String | String representing why the error is fired. | 
message String | String representing possible information about the error. | 
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "WARNING",
    data: {
        errorCode: "NETWORK_ERROR",
        message: "Failed to fetch"
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.WARNING,
    data = LuraEventData.Warning(
        exception = LuraException(
            type = LuraExceptionType.ConfiguringError,
            message = "",
            cause = Exception()
        )
    )
)
LuraEventBundle(
    name: config.name,
    type: .WARNING,
    data: Warning(
        errorCode: "NETWORK_ERROR",
        message: "Failed to fetch"
    )
)
{
    name: config.name,
    type: "WARNING",
    data: {
        message: "Failed to fetch"
    }
}
TIMED_METADATA
Triggers after metadata associated with the stream is found
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "TIMED_METADATA",
    data: {
        [key: string]: string
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.TIMED_METADATA,
    data = LuraEventData.TimedMetadata(
        data = JsonObject(mapOf())
    )
)
LuraEventBundle(
    name: config.name,
    type: .TIMED_METADATA,
    data: TimedMetadata(
        data: [String : String]()
    )
)
{
    name: config.name,
    type: "TIMED_METADATA",
    data: {
        time: 12,
        metadata: {
          [key: string]: string
        }
    }
}
DASH_TIMED_METADATA
Fired when a media timeline region is added
- Javascript
 - Kotlin
 
{
    name: config.name,
    type: "DASH_TIMED_METADATA",
    data: {
        event: string,
        detail: {
            schemeIdUri: string,
            eventElement: Element,
            startTime: number
        }
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.DASH_TIMED_METADATA,
    data = LuraEventData.DashTimedMetadata(
        data = JsonObject(mapOf())
    )
)
CUSTOM_DATA_CHANGED
Fired when the custom data is changed by setCustomData method.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "CUSTOM_DATA_CHANGED",
    data: {
      key: string,
      value?: any
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CUSTOM_DATA_CHANGED,
    data = LuraEventData.CustomDataChanged(
      key: String,
      value: Any?
    )
)
LuraEventBundle(
    name: config.name,
    type: .CUSTOM_DATA_CHANGED,
    data: CustomDataChanged(
        key: String,
        value: String?
    )
)
{
    name: config.name,
    type: "CUSTOM_DATA_CHANGED",
    data: {
        key: "key",
        value: any
    }
}
INTERSTITIALS
Event fired when the player has retrieved a new ad information.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "INTERSTITIALS",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.INTERSTITIALS,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .INTERSTITIALS,
    data: nil
)
{
    name: config.name,
    type: "INTERSTITIALS",
    data: invalid
}
AD_IMPRESSION
Event fired when an ad is displayed in the video player
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_IMPRESSION",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_IMPRESSION,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_IMPRESSION,
    data: nil
)
{
    name: config.name,
    type: "AD_IMPRESSION",
    data: invalid
}
AD_BREAK_STARTED
Event fired when an ad break begins to play in the video player
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
Check out lura.unified.AdBreak
{
    name: config.name,
    type: "AD_BREAK_STARTED",
    data: lura.unified.AdBreak
}
Check out LuraAdBreak
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_BREAK_STARTED,
    data = LuraAdBreak
)
Check out LuraAdBreak
LuraEventBundle(
    name: config.name,
    type: .AD_BREAK_STARTED,
    data: LuraAdBreak
)
{
    name: config.name,
    type: "AD_BREAK_STARTED",
    data: invalid
}
AD_STARTED
Event fired when an individual ad begins to play in the video player
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
Check out lura.unified.Ad
{
    name: config.name,
    type: "AD_STARTED",
    data: lura.unified.Ad
}
Check out LuraAd
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_STARTED,
    data = LuraAd
)
Check out LuraMediaAd
LuraEventBundle(
    name: config.name,
    type: .AD_STARTED,
    data: LuraAd
)
{
    name: config.name,
    type: "AD_STARTED",
    data: invalid
}
AD_FIRST_QUARTILE
Event fired when an ad has reached the first quarter of its duration
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_FIRST_QUARTILE",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_FIRST_QUARTILE,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_FIRST_QUARTILE,
    data: nil
)
{
    name: config.name,
    type: "AD_FIRST_QUARTILE",
    data: invalid
}
AD_MIDPOINT
Event fired when an ad has reached its midpoint
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_MIDPOINT",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_MIDPOINT,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_MIDPOINT,
    data: nil
)
{
    name: config.name,
    type: "AD_MIDPOINT",
    data: invalid
}
AD_THIRD_QUARTILE
Event fired when an ad has reached the third quarter of its duration
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_THIRD_QUARTILE",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_THIRD_QUARTILE,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_THIRD_QUARTILE,
    data: nil
)
{
    name: config.name,
    type: "AD_THIRD_QUARTILE",
    data: invalid
}
AD_COMPLETED
Event fired when an individual ad has completed playing in the video player
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_COMPLETED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_COMPLETED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_COMPLETED,
    data: nil
)
{
    name: config.name,
    type: "AD_COMPLETED",
    data: invalid
}
AD_BREAK_COMPLETED
Event fired when an ad break is completed
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_BREAK_COMPLETED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_BREAK_COMPLETED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_BREAK_COMPLETED,
    data: nil
)
{
    name: config.name,
    type: "AD_BREAK_COMPLETED",
    data: invalid
}
AD_CLICKED
Event fired when the user clicks on an ad in the video player
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "AD_CLICKED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_CLICKED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_CLICKED,
    data: nil
)
AD_SKIPPED
Event fired when an ad is skipped by the user
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "AD_SKIPPED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.AD_SKIPPED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .AD_SKIPPED,
    data: nil
)
{
    name: config.name,
    type: "AD_SKIPPED",
    data: invalid
}
CASTING_REQUESTED
Event fired when casting is requested in the video player
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "CASTING_REQUESTED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CASTING_REQUESTED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CASTING_REQUESTED,
    data: nil
)
CASTING_STARTED
Event fired when casting is started in the video player
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "CASTING_STARTED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CASTING_STARTED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CASTING_STARTED,
    data: nil
)
CASTING_ENDED
Event fired when casting is ended in the video player
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "CASTING_ENDED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CASTING_ENDED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CASTING_ENDED,
    data: nil
)
CAST_AVAILABILITY_CHANGED
Event fired when cast availability is changed in the video player.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "CAST_AVAILABILITY_CHANGED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.CAST_AVAILABILITY_CHANGED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .CAST_AVAILABILITY_CHANGED,
    data: nil
)
LIVE_AVAILABILITY_WINDOW_FOUND
Event fired when the availability window of the live stream is found or changed.
- Javascript
 - Kotlin
 - Swift
 - Brightscript
 
{
    name: config.name,
    type: "LIVE_AVAILABILITY_WINDOW_FOUND",
    data: {
      id: "123",
      start: 1720007466.0,
      end: 1720008466.0,
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.LIVE_AVAILABILITY_WINDOW_FOUND,
    data = LuraEventData.AvailabilityWindow(
        id: "123",
        start: 1720007466.0,
        end: 1720008466.0,
    )
)
LuraEventBundle(
    name: config.name,
    type: .LIVE_AVAILABILITY_WINDOW_FOUND,
    data: AvailabilityWindow(
        id: "123",
        start: 1720007466.0,
        end: 1720008466.0,
    )
)
{
    name: config.name,
    type: "LIVE_AVAILABILITY_WINDOW_FOUND",
    data: {
        id: "123",
        start: 1720007466.0,
        end: 1720008466.0,
    }
}
SCREEN_STATE_CHANGED
Event fired when the screen state changed.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "SCREEN_STATE_CHANGED",
    data: {
      state: "WINDOWED",
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.SCREEN_STATE_CHANGED,
    data = LuraEventData.ScreenState(
        state = LuraScreenState.WINDOWED
    )
)
LuraEventBundle(
    name: config.name,
    type: .SCREEN_STATE_CHANGED,
    data: ScreenState(
        state: .WINDOWED
    )
)
PLAYLIST_ITEM_LOADED
Fired when a playlist item is loaded.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_ITEM_LOADED",
    data: {
      item: lura.unified.Configuration,
      index: number
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_ITEM_LOADED,
    data = LuraEventData.PlaylistData(
      item = LuraConfiguration,
      index = Int
    )
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_ITEM_LOADED,
    data: PlaylistData(
      item = LuraPlayerConfiguration,
      index = Int
    )
)
PLAYLIST_ITEM_CHANGED
Fired when a playlist item is modified, added or removed.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_ITEM_CHANGED",
    data: {
      item: lura.unified.Configuration,
      index: number
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_ITEM_CHANGED,
    data = LuraEventData.PlaylistData(
      item = LuraConfiguration,
      index = Int
    )
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_ITEM_CHANGED,
    data: PlaylistData(
      item = LuraPlayerConfiguration,
      index = Int
    )
)
PLAYLIST_COMPLETED
Fired when the playlist has no more configuration left to play and the repeat mode is set to false.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_COMPLETED",
    data: {
      item: lura.unified.Configuration,
      index: number
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_COMPLETED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_COMPLETED,
    data: nil
)
PLAYLIST_CONFIG_CHANGE_NEEDED
Fired when a configuration change is needed. This will be fired when the token is about to expire.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_CONFIG_CHANGE_NEEDED",
    data: {
      item: lura.unified.Configuration,
      index: number
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_CONFIG_CHANGE_NEEDED,
    data = LuraEventData.PlaylistData(
      item = LuraConfiguration,
      index = Int
    )
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_CONFIG_CHANGE_NEEDED,
    data: PlaylistData(
      item = LuraPlayerConfiguration,
      index = Int
    )
)
PLAYLIST_INITIALIZED
Fired when the playlist is initialized with a new setConfig method call.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_INITIALIZED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_INITIALIZED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_INITIALIZED,
    data: nil
)
PLAYLIST_DISCARDED
Fired when the playlist has been discarded with a new setConfig method call.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_DISCARDED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_DISCARDED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_DISCARDED,
    data: nil
)
PLAYLIST_AUTO_SWITCH_COUNTER
Fired when the auto switch mechanism is active and counter started.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_AUTO_SWITCH_COUNTER",
    data: {
      item: lura.unified.Configuration,
      index: number,
      remaining: number,
    }
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_AUTO_SWITCH_COUNTER,
    data = LuraEventData.PlaylistData(
      item = LuraConfiguration,
      index = Int,
      remaining = Int
    )
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_AUTO_SWITCH_COUNTER,
    data: PlaylistData(
      item = LuraPlayerConfiguration,
      index = Int,
      remaining = Int
    )
)
PLAYLIST_AUTO_SWITCH_ABORTED
Fired when the auto switch mechanism is aborted by abortPlaylistAutoSwitch method.
- Javascript
 - Kotlin
 - Swift
 
{
    name: config.name,
    type: "PLAYLIST_AUTO_SWITCH_ABORTED",
    data: null
}
LuraEvent(
    name = config.name,
    type = LuraEventType.PLAYLIST_AUTO_SWITCH_ABORTED,
    data = null
)
LuraEventBundle(
    name: config.name,
    type: .PLAYLIST_AUTO_SWITCH_ABORTED,
    data: nil
)