components_video_VideoPlayerView.bs

import "pkg:/source/roku_modules/log/LogMixin.brs"
import "pkg:/source/utils/config.bs"
import "pkg:/source/utils/misc.bs"
import "pkg:/source/utils/session.bs"

sub init()
  m.log = log.Logger("VideoPlayerView")
  ' Hide the overhang on init to prevent showing 2 clocks
  m.top.getScene().findNode("overhang").visible = false
  userSettings = m.global.session.user.settings
  m.currentItem = m.global.queueManager.callFunc("getCurrentItem")
  m.originalClosedCaptionState = invalid

  m.top.id = m.currentItem.id
  m.top.seekMode = "accurate"

  m.playbackEnum = {
    null: -10
  }

  ' Load meta data
  m.LoadMetaDataTask = CreateObject("roSGNode", "LoadVideoContentTask")
  m.LoadMetaDataTask.itemId = m.currentItem.id
  m.LoadMetaDataTask.itemType = m.currentItem.type
  m.LoadMetaDataTask.selectedAudioStreamIndex = m.currentItem.selectedAudioStreamIndex
  m.LoadMetaDataTask.observeField("content", "onVideoContentLoaded")
  m.LoadMetaDataTask.control = "RUN"

  m.chapterList = m.top.findNode("chapterList")
  m.chapterMenu = m.top.findNode("chapterMenu")
  m.chapterContent = m.top.findNode("chapterContent")
  m.osd = m.top.findNode("osd")
  m.osd.observeField("action", "onOSDAction")

  m.playbackTimer = m.top.findNode("playbackTimer")
  m.bufferCheckTimer = m.top.findNode("bufferCheckTimer")
  m.top.observeField("content", "onContentChange")
  m.top.observeField("selectedSubtitle", "onSubtitleChange")
  m.top.observeField("audioIndex", "onAudioIndexChange")

  ' Custom Caption Function
  m.top.observeField("allowCaptions", "onAllowCaptionsChange")

  m.playbackTimer.observeField("fire", "ReportPlayback")
  m.bufferPercentage = 0 ' Track whether content is being loaded
  m.playReported = false
  m.top.transcodeReasons = []
  m.bufferCheckTimer.duration = 30

  if userSettings["ui.design.hideclock"] = true
    clockNode = findNodeBySubtype(m.top, "clock")
    if isValid(clockNode[0]) then clockNode[0].parent.removeChild(clockNode[0].node)
  end if

  'Play Next Episode button
  m.nextEpisodeButton = m.top.findNode("nextEpisode")
  m.nextEpisodeButton.text = tr("Next Episode")
  m.nextEpisodeButton.setFocus(false)
  m.nextupbuttonseconds = userSettings["playback.nextupbuttonseconds"].ToInt()

  m.showNextEpisodeButtonAnimation = m.top.findNode("showNextEpisodeButton")
  m.hideNextEpisodeButtonAnimation = m.top.findNode("hideNextEpisodeButton")

  m.checkedForNextEpisode = false
  m.getNextEpisodeTask = createObject("roSGNode", "GetNextEpisodeTask")
  m.getNextEpisodeTask.observeField("nextEpisodeData", "onNextEpisodeDataLoaded")

  globalColors = m.global.constants.colors

  m.top.retrievingBar.filledBarBlendColor = globalColors.secondary

  m.top.bufferingBar.filledBarBlendColor = globalColors.secondary

  m.top.trickPlayBar.filledBarBlendColor = globalColors.secondary
  m.top.trickPlayBar.thumbBlendColor = globalColors.primary
  m.top.trickPlayBar.textColor = globalColors.text_primary
  m.top.trickPlayBar.currentTimeMarkerBlendColor = globalColors.text_primary
end sub

' handleChapterSkipAction: Handles user command to skip chapters in playing video
'
sub handleChapterSkipAction(action as string)
  if not isValidAndNotEmpty(m.chapters) then return

  currentChapter = getCurrentChapterIndex()

  if action = "chapternext"
    gotoChapter = currentChapter + 1
    ' If there is no next chapter, exit
    if gotoChapter > m.chapters.count() - 1 then return

    m.top.seek = m.chapters[gotoChapter].StartPositionTicks / 10000000#
    return
  end if

  if action = "chapterback"
    gotoChapter = currentChapter - 1
    ' If there is no previous chapter, restart current chapter
    if gotoChapter < 0 then gotoChapter = 0

    m.top.seek = m.chapters[gotoChapter].StartPositionTicks / 10000000#
    return
  end if
end sub

' handleItemSkipAction: Handles user command to skip items
'
' @param {string} action - skip action to take
sub handleItemSkipAction(action as string)
  if action = "itemnext"
    queueManager = m.global.queueManager

    ' If there is something next in the queue, play it
    if queueManager.callFunc("getPosition") < queueManager.callFunc("getCount") - 1
      m.top.control = "stop"
      session.video.Delete()
      m.global.sceneManager.callFunc("clearPreviousScene")
      queueManager.callFunc("moveForward")
      queueManager.callFunc("playQueue")
    end if

    return
  end if

  if action = "itemback"
    queueManager = m.global.queueManager

    ' If there is something previous in the queue, play it
    if queueManager.callFunc("getPosition") > 0
      m.top.control = "stop"
      session.video.Delete()
      m.global.sceneManager.callFunc("clearPreviousScene")
      queueManager.callFunc("moveBack")
      queueManager.callFunc("playQueue")
    end if

    return
  end if
end sub

' handleHideAction: Handles action to hide OSD menu
'
' @param {boolean} resume - controls whether or not to resume video playback when sub is called
'
sub handleHideAction(resume as boolean)
  m.osd.visible = false
  m.chapterList.visible = false
  m.osd.showChapterList = false
  m.chapterList.setFocus(false)
  m.osd.hasFocus = false
  m.osd.setFocus(false)
  m.top.setFocus(true)
  if resume
    m.top.control = "resume"
  end if
end sub

' handleChapterListAction: Handles action to show chapter list
'
sub handleChapterListAction()
  m.chapterList.visible = m.osd.showChapterList

  if not m.chapterList.visible then return

  m.chapterMenu.jumpToItem = getCurrentChapterIndex()

  m.osd.hasFocus = false
  m.osd.setFocus(false)
  m.chapterMenu.setFocus(true)
end sub

' getCurrentChapterIndex: Finds current chapter index
'
' @return {integer} indicating index of current chapter within chapter data or 0 if chapter lookup fails
'
function getCurrentChapterIndex() as integer
  if not isValidAndNotEmpty(m.chapters) then return 0

  ' Give a 15 second buffer to compensate for user expectation and roku video position inaccuracy
  ' Web client uses 10 seconds, but this wasn't enough for Roku in testing
  currentPosition = m.top.position + 15
  currentChapter = 0

  for i = m.chapters.count() - 1 to 0 step -1
    if currentPosition >= (m.chapters[i].StartPositionTicks / 10000000#)
      currentChapter = i
      exit for
    end if
  end for

  return currentChapter
end function

' handleVideoPlayPauseAction: Handles action to either play or pause the video content
'
sub handleVideoPlayPauseAction()
  ' If video is paused, resume it
  if m.top.state = "paused"
    handleHideAction(true)
    return
  end if

  ' Pause video
  m.top.control = "pause"
end sub

' handleShowSubtitleMenuAction: Handles action to show subtitle selection menu
'
sub handleShowSubtitleMenuAction()
  m.top.selectSubtitlePressed = true
end sub

' handleShowAudioMenuAction: Handles action to show audio selection menu
'
sub handleShowAudioMenuAction()
  m.top.selectAudioPressed = true
end sub

' handleShowVideoInfoPopupAction: Handles action to show video info popup
'
sub handleShowVideoInfoPopupAction()
  m.top.selectPlaybackInfoPressed = true
end sub

' onOSDAction: Process action events from OSD to their respective handlers
'
sub onOSDAction()
  action = LCase(m.osd.action)

  if action = "hide"
    handleHideAction(false)
    return
  end if

  if action = "play"
    handleHideAction(true)
    return
  end if

  if action = "chapterback" or action = "chapternext"
    handleChapterSkipAction(action)
    return
  end if

  if action = "chapterlist"
    handleChapterListAction()
    return
  end if

  if action = "videoplaypause"
    handleVideoPlayPauseAction()
    return
  end if

  if action = "showsubtitlemenu"
    handleShowSubtitleMenuAction()
    return
  end if

  if action = "showaudiomenu"
    handleShowAudioMenuAction()
    return
  end if

  if action = "showvideoinfopopup"
    handleShowVideoInfoPopupAction()
    return
  end if

  if action = "itemback" or action = "itemnext"
    handleItemSkipAction(action)
    return
  end if
end sub

' Only setup caption items if captions are allowed
sub onAllowCaptionsChange()
  if not m.top.allowCaptions then return

  m.captionGroup = m.top.findNode("captionGroup")
  m.captionGroup.createchildren(9, "LayoutGroup")
  m.captionTask = createObject("roSGNode", "captionTask")
  m.captionTask.observeField("currentCaption", "updateCaption")
  m.captionTask.observeField("useThis", "checkCaptionMode")
  m.top.observeField("subtitleTrack", "loadCaption")
  m.top.observeField("globalCaptionMode", "toggleCaption")

  if m.global.session.user.settings["playback.subs.custom"]
    m.top.suppressCaptions = true
    toggleCaption()
  else
    m.top.suppressCaptions = false
  end if
end sub

' Set caption url to server subtitle track
sub loadCaption()
  if m.top.suppressCaptions
    m.captionTask.url = m.top.subtitleTrack
  end if
end sub

' Toggles visibility of custom subtitles and sets captionTask's player state
sub toggleCaption()
  m.captionTask.playerState = m.top.state + m.top.globalCaptionMode
  if LCase(m.top.globalCaptionMode) = "on"
    m.captionTask.playerState = m.top.state + m.top.globalCaptionMode + "w"
    m.captionGroup.visible = true
  else
    m.captionGroup.visible = false
  end if
end sub

' Removes old subtitle lines and adds new subtitle lines
sub updateCaption()
  m.captionGroup.removeChildrenIndex(m.captionGroup.getChildCount(), 0)
  m.captionGroup.appendChildren(m.captionTask.currentCaption)
end sub

' Event handler for when selectedSubtitle changes
sub onSubtitleChange()
  switchWithoutRefresh = true

  if m.top.SelectedSubtitle <> -1
    ' If the global caption mode is off, then Roku can't display the subtitles natively and needs a video stop/start
    if LCase(m.top.globalCaptionMode) <> "on" then switchWithoutRefresh = false
  end if

  ' If previous sustitle was encoded, then we need to a video stop/start to change subtitle content
  if m.top.previousSubtitleWasEncoded then switchWithoutRefresh = false

  if switchWithoutRefresh then return

  ' Save the current video position
  m.global.queueManager.callFunc("setTopStartingPoint", int(m.top.position) * 10000000&)

  m.top.control = "stop"

  m.LoadMetaDataTask.selectedSubtitleIndex = m.top.SelectedSubtitle
  m.LoadMetaDataTask.selectedAudioStreamIndex = m.top.audioIndex
  m.LoadMetaDataTask.itemId = m.currentItem.id
  m.LoadMetaDataTask.observeField("content", "onVideoContentLoaded")
  m.LoadMetaDataTask.control = "RUN"
end sub

' Event handler for when audioIndex changes
sub onAudioIndexChange()
  ' Skip initial audio index setting
  if m.top.position = 0 then return

  ' Save the current video position
  m.global.queueManager.callFunc("setTopStartingPoint", int(m.top.position) * 10000000&)

  m.top.control = "stop"

  m.LoadMetaDataTask.selectedSubtitleIndex = m.top.SelectedSubtitle
  m.LoadMetaDataTask.selectedAudioStreamIndex = m.top.audioIndex
  m.LoadMetaDataTask.itemId = m.currentItem.id
  m.LoadMetaDataTask.observeField("content", "onVideoContentLoaded")
  m.LoadMetaDataTask.control = "RUN"
end sub

sub onPlaybackErrorDialogClosed(msg)
  sourceNode = msg.getRoSGNode()
  sourceNode.unobserveField("buttonSelected")
  sourceNode.unobserveField("wasClosed")

  m.global.sceneManager.callFunc("popScene")
end sub

sub onPlaybackErrorButtonSelected(msg)
  sourceNode = msg.getRoSGNode()
  sourceNode.close = true
end sub

sub showPlaybackErrorDialog(errorMessage as string)
  dialog = createObject("roSGNode", "Dialog")
  dialog.title = tr("Error During Playback")
  dialog.buttons = [tr("OK")]
  dialog.message = errorMessage
  dialog.observeField("buttonSelected", "onPlaybackErrorButtonSelected")
  dialog.observeField("wasClosed", "onPlaybackErrorDialogClosed")
  m.top.getScene().dialog = dialog
end sub

sub onVideoContentLoaded()
  m.LoadMetaDataTask.unobserveField("content")
  m.LoadMetaDataTask.control = "STOP"

  videoContent = m.LoadMetaDataTask.content
  m.LoadMetaDataTask.content = []

  ' If we have nothing to play, return to previous screen
  if not isValidAndNotEmpty(videoContent)
    stopLoadingSpinner()
    showPlaybackErrorDialog(tr("There was an error retrieving the data for this item from the server."))
    return
  end if


  m.top.observeField("state", "onState")

  m.top.content = videoContent[0].content
  m.top.PlaySessionId = videoContent[0].PlaySessionId
  m.top.videoId = videoContent[0].id
  m.top.container = videoContent[0].container
  m.top.mediaSourceId = videoContent[0].mediaSourceId
  m.top.fullSubtitleData = videoContent[0].fullSubtitleData
  m.top.fullAudioData = videoContent[0].fullAudioData
  m.top.audioIndex = videoContent[0].audioIndex
  m.top.transcodeParams = videoContent[0].transcodeparams
  m.chapters = videoContent[0].chapters
  m.top.showID = videoContent[0].showID

  if isValidAndNotEmpty(videoContent[0].json)
    m.osd.json = formatJson(videoContent[0].json)
  end if

  ' Attempt to add logo to OSD
  if isValidAndNotEmpty(videoContent[0].logoImage)
    m.osd.logoImage = videoContent[0].logoImage
  end if

  populateChapterMenu()


  ' Allow custom captions for all videos including intro videos
  m.top.allowCaptions = true

  ' Allow default subtitles
  m.top.unobserveField("selectedSubtitle")

  ' Set subtitleTrack property if subs are natively supported by Roku
  selectedSubtitle = invalid
  for each subtitle in m.top.fullSubtitleData
    if subtitle.Index = videoContent[0].selectedSubtitle
      selectedSubtitle = subtitle
      exit for
    end if
  end for

  if isValid(selectedSubtitle)
    availableSubtitleTrackIndex = availSubtitleTrackIdx(selectedSubtitle.Track.TrackName)
    if availableSubtitleTrackIndex <> -1
      if not selectedSubtitle.IsEncoded
        if selectedSubtitle.IsForced
          ' If IsForced, make sure to remember the Roku global setting so we
          ' can set it back when the video is done playing.
          m.originalClosedCaptionState = m.top.globalCaptionMode
        end if
        m.top.globalCaptionMode = "On"
        m.top.subtitleTrack = m.top.availableSubtitleTracks[availableSubtitleTrackIndex].TrackName
      end if
    end if
  end if

  m.top.selectedSubtitle = videoContent[0].selectedSubtitle

  m.top.observeField("selectedSubtitle", "onSubtitleChange")

  if isValid(m.top.audioIndex)
    m.top.audioTrack = (m.top.audioIndex + 1).toStr()
  else
    m.top.audioTrack = "2"
  end if

  stopLoadingSpinner()
  m.top.setFocus(true)
  m.top.control = "play"
end sub

' populateChapterMenu: ' Parse chapter data from API and appeand to chapter list menu
'
sub populateChapterMenu()
  ' Clear any existing chapter list data
  m.chapterContent.clear()

  if not isValidAndNotEmpty(m.chapters)
    chapterItem = CreateObject("roSGNode", "ContentNode")
    chapterItem.title = tr("No Chapter Data Found")
    chapterItem.playstart = m.playbackEnum.null
    m.chapterContent.appendChild(chapterItem)
    return
  end if

  for each chapter in m.chapters
    chapterItem = CreateObject("roSGNode", "ContentNode")
    chapterItem.title = chapter.Name
    chapterItem.playstart = chapter.StartPositionTicks / 10000000#
    m.chapterContent.appendChild(chapterItem)
  end for
end sub

' Event handler for when video content field changes
sub onContentChange()
  if not isValid(m.top.content) then return

  m.top.observeField("position", "onPositionChanged")
end sub

sub onNextEpisodeDataLoaded()
  m.checkedForNextEpisode = true

  m.top.observeField("position", "onPositionChanged")

  ' If there is no next episode, disable next episode button
  if m.getNextEpisodeTask.nextEpisodeData.Items.count() <> 2
    m.nextupbuttonseconds = 0
  end if
end sub

'
' Runs Next Episode button animation and sets focus to button
sub showNextEpisodeButton()
  if m.osd.visible then return
  if m.top.content.contenttype <> 4 then return ' only display when content is type "Episode"
  if m.nextupbuttonseconds = 0 then return ' is the button disabled?
  if m.nextEpisodeButton.opacity <> 0 then return
  userSettings = m.global.session.user.settings
  if userSettings["playback.playnextepisode"] = "disabled" then return
  if userSettings["playback.playnextepisode"] = "webclient" and not m.global.session.user.Configuration.EnableNextEpisodeAutoPlay then return

  m.nextEpisodeButton.visible = true
  m.showNextEpisodeButtonAnimation.control = "start"
  m.nextEpisodeButton.setFocus(true)
end sub

'
'Update count down text
sub updateCount()
  nextEpisodeCountdown = Int(m.top.duration - m.top.position)
  if nextEpisodeCountdown < 0
    nextEpisodeCountdown = 0
  end if
  m.nextEpisodeButton.text = tr("Next Episode") + " " + nextEpisodeCountdown.toStr()
end sub

'
' Runs hide Next Episode button animation and sets focus back to video
sub hideNextEpisodeButton()
  m.hideNextEpisodeButtonAnimation.control = "start"
  m.nextEpisodeButton.setFocus(false)
  m.top.setFocus(true)
end sub

' Checks if we need to display the Next Episode button
sub checkTimeToDisplayNextEpisode()
  if m.top.content.contenttype <> 4 then return ' only display when content is type "Episode"
  if m.nextupbuttonseconds = 0 then return ' is the button disabled?

  ' Don't show Next Episode button if trickPlayBar is visible
  if m.top.trickPlayBar.visible then return

  if isValid(m.top.duration) and isValid(m.top.position)
    nextEpisodeCountdown = Int(m.top.duration - m.top.position)

    if nextEpisodeCountdown < 0 and m.nextEpisodeButton.opacity = 0.9
      hideNextEpisodeButton()
      return
    else if nextEpisodeCountdown > 1 and int(m.top.position) >= (m.top.duration - m.nextupbuttonseconds - 1)
      updateCount()
      if m.nextEpisodeButton.opacity = 0
        showNextEpisodeButton()
      end if
      return
    end if
  end if

  if m.nextEpisodeButton.visible or m.nextEpisodeButton.hasFocus()
    m.nextEpisodeButton.visible = false
    m.nextEpisodeButton.setFocus(false)
  end if
end sub

' When Video Player state changes
sub onPositionChanged()
  ' Pass video position data into OSD
  if m.top.duration = 0
    m.osd.progressPercentage = 0
  else
    m.osd.progressPercentage = m.top.position / m.top.duration
  end if
  m.osd.positionTime = m.top.position
  m.osd.remainingPositionTime = m.top.duration - m.top.position

  if isValid(m.captionTask)
    m.captionTask.currentPos = Int(m.top.position * 1000)
  end if

  ' Check if dialog is open
  m.dialog = m.top.getScene().findNode("dialogBackground")
  if not isValid(m.dialog)
    ' Do not show Next Episode button for intro videos
    if not m.LoadMetaDataTask.isIntro
      checkTimeToDisplayNextEpisode()
    end if
  end if
end sub

'
' When Video Player state changes
sub onState()
  m.log.debug("start onState()", m.top.state)
  if isValid(m.captionTask)
    m.captionTask.playerState = m.top.state + m.top.globalCaptionMode
  end if

  ' Pass video state into OSD
  m.osd.playbackState = m.top.state

  if m.top.state = "buffering"
    ' When buffering, start timer to monitor buffering process
    if isValid(m.bufferCheckTimer)
      m.bufferCheckTimer.control = "start"
      m.bufferCheckTimer.ObserveField("fire", "bufferCheck")
    end if
  else if m.top.state = "error"
    m.log.error(m.top.errorCode, m.top.errorMsg, m.top.errorStr, m.top.errorCode)

    print m.top.errorInfo

    if not m.playReported and m.top.transcodeAvailable
      m.top.retryWithTranscoding = true ' If playback was not reported, retry with transcoding
    else if m.top.errorStr = "decoder:pump:Unsupported AAC stream."
      m.log.info("retrying video with mp3 audio stream", m.currentItem.id, m.top.SelectedSubtitle, m.top.audioIndex)

      m.top.unobserveField("state")
      m.LoadMetaDataTask.forceMp3 = true
      m.LoadMetaDataTask.selectedSubtitleIndex = m.top.SelectedSubtitle
      m.LoadMetaDataTask.selectedAudioStreamIndex = m.top.audioIndex
      m.LoadMetaDataTask.itemId = m.currentItem.id
      m.LoadMetaDataTask.observeField("content", "onVideoContentLoaded")

      m.LoadMetaDataTask.control = "RUN"
    else if m.top.errorStr = "player: only one playing instance supported."
      m.global.sceneManager.callfunc("popScene")
    else
      ' If an error was encountered, Display dialog
      showPlaybackErrorDialog(tr("Error During Playback"))
      session.video.Delete()
    end if


  else if m.top.state = "playing"

    ' Check if next episode is available
    if isValid(m.top.showID)
      if m.top.showID <> "" and not m.checkedForNextEpisode and m.top.content.contenttype = 4
        m.getNextEpisodeTask.showID = m.top.showID
        m.getNextEpisodeTask.videoID = m.top.id
        m.getNextEpisodeTask.control = "RUN"
      end if
    end if

    if m.playReported = false
      ReportPlayback("start")
      m.playReported = true
    else
      ReportPlayback()
    end if
    m.playbackTimer.control = "start"
  else if m.top.state = "paused"
    m.playbackTimer.control = "stop"
    ReportPlayback()
  else if m.top.state = "stopped"
    m.playbackTimer.control = "stop"
    ReportPlayback("stop")
    m.playReported = false
    session.video.Delete()
  else if m.top.state = "finished"
    m.playbackTimer.control = "stop"
    ReportPlayback("finished")
    session.video.Delete()
  else
    m.log.warning("Unhandled state", m.top.state, m.playReported, m.playFinished)
  end if
  m.log.debug("end onState()", m.top.state)
end sub

'
' Report playback to server
sub ReportPlayback(state = "update" as string)
  if not isValid(m.top.position) then return

  m.log.debug("start ReportPlayback()", state, int(m.top.position))

  params = {
    "ItemId": m.top.id,
    "PlaySessionId": m.top.PlaySessionId,
    "PositionTicks": int(m.top.position) * 10000000&, 'Ensure a LongInteger is used
    "IsPaused": (m.top.state = "paused")
  }
  if isValid(m.top.content) and isValid(m.top.content.live) and m.top.content.live
    params.append({
      "MediaSourceId": m.top.transcodeParams.MediaSourceId,
      "LiveStreamId": m.top.transcodeParams.LiveStreamId
    })
    m.bufferCheckTimer.duration = 30
  end if

  if (state = "stop" or state = "finished") and isValid(m.originalClosedCaptionState)
    m.log.debug("ReportPlayback() setting", m.top.globalCaptionMode, "back to", m.originalClosedCaptionState)
    m.top.globalCaptionMode = m.originalClosedCaptionState
    m.originalClosedCaptionState = invalid
  end if

  ' Report playstate via worker task
  playstateTask = m.global.playstateTask
  playstateTask.setFields({ status: state, params: params })
  playstateTask.control = "RUN"

  m.log.debug("end ReportPlayback()", state, int(m.top.position))
end sub

'
' Check the the buffering has not hung
sub bufferCheck()

  if m.top.state <> "buffering"
    ' If video is not buffering, stop timer
    m.bufferCheckTimer.control = "stop"
    m.bufferCheckTimer.unobserveField("fire")
    return
  end if
  if isValid(m.top.bufferingStatus)

    ' Check that the buffering percentage is increasing
    if m.top.bufferingStatus["percentage"] > m.bufferPercentage
      m.bufferPercentage = m.top.bufferingStatus["percentage"]
    else if m.top.content.live = true
      m.top.callFunc("refresh")
    else
      ' If buffering has stopped Display dialog
      showPlaybackErrorDialog(tr("There was an error retrieving the data for this item from the server."))

      ' Stop playback and exit player
      m.top.control = "stop"
      session.video.Delete()
    end if
  end if

end sub

' stateAllowsOSD: Check if current video state allows showing the OSD
'
' @return {boolean} indicating if video state allows the OSD to show
function stateAllowsOSD() as boolean
  validStates = ["playing", "paused", "stopped"]
  return inArray(validStates, m.top.state)
end function


' availSubtitleTrackIdx: Returns Roku's index for requested subtitle track
'
' @param {string} tracknameToFind - TrackName for subtitle we're looking to match
' @return {integer} indicating Roku's index for requested subtitle track. Returns -1 if not found
function availSubtitleTrackIdx(tracknameToFind as string) as integer
  idx = 0
  for each availTrack in m.top.availableSubtitleTracks
    ' The TrackName must contain the URL we supplied originally, though
    ' Roku mangles the name a bit, so we check if the URL is a substring, rather
    ' than strict equality
    if Instr(1, availTrack.TrackName, tracknameToFind)
      return idx
    end if
    idx = idx + 1
  end for
  return -1
end function

function onKeyEvent(key as string, press as boolean) as boolean

  ' Keypress handler while user is inside the chapter menu
  if m.chapterMenu.hasFocus()
    if not press then return false

    if key = "OK"
      focusedChapter = m.chapterMenu.itemFocused
      selectedChapter = m.chapterMenu.content.getChild(focusedChapter)
      seekTime = selectedChapter.playstart

      ' Don't seek if user clicked on No Chapter Data
      if seekTime = m.playbackEnum.null then return true

      m.top.seek = seekTime
      return true
    end if

    if key = "back" or key = "replay"
      m.chapterList.visible = false
      m.osd.showChapterList = false
      m.chapterMenu.setFocus(false)
      m.osd.hasFocus = true
      m.osd.setFocus(true)
      return true
    end if

    if key = "play"
      handleVideoPlayPauseAction()
    end if

    return true
  end if

  if key = "OK" and m.nextEpisodeButton.hasfocus() and not m.top.trickPlayBar.visible
    m.top.control = "stop"
    m.top.state = "finished"
    session.video.Delete()
    hideNextEpisodeButton()
    return true
  else
    'Hide Next Episode Button
    if m.nextEpisodeButton.opacity > 0 or m.nextEpisodeButton.hasFocus()
      m.nextEpisodeButton.opacity = 0
      m.nextEpisodeButton.setFocus(false)
      m.top.setFocus(true)
    end if
  end if

  if not press then return false

  if key = "down" and not m.top.trickPlayBar.visible
    ' Don't allow user to open menu prior to video loading
    if not stateAllowsOSD() then return true

    m.osd.visible = true
    m.osd.hasFocus = true
    m.osd.setFocus(true)
    return true

  else if key = "up" and not m.top.trickPlayBar.visible
    ' Don't allow user to open menu prior to video loading
    if not stateAllowsOSD() then return true

    m.osd.visible = true
    m.osd.hasFocus = true
    m.osd.setFocus(true)
    return true

  else if key = "OK" and not m.top.trickPlayBar.visible
    ' Don't allow user to open menu prior to video loading
    if not stateAllowsOSD() then return true

    ' Show OSD, but don't pause video
    m.osd.visible = true
    m.osd.hasFocus = true
    m.osd.setFocus(true)
    return true
  end if

  ' Disable OSD for intro videos
  if key = "play" and not m.top.trickPlayBar.visible

    ' Don't allow user to open menu prior to video loading
    if not stateAllowsOSD() then return true

    ' If video is paused, resume it and don't show OSD
    if m.top.state = "paused"
      m.top.control = "resume"
      return true
    end if

    ' Pause video and show OSD
    m.top.control = "pause"
    m.osd.playbackState = "paused"
    m.osd.visible = true
    m.osd.hasFocus = true
    m.osd.setFocus(true)
    return true
  end if

  if key = "back"
    m.top.control = "stop"
    session.video.Delete()
  end if

  return false
end function