jf-roku/components/home/HomeRows.bs

import "pkg:/source/utils/misc.bs"
import "pkg:/source/constants/ImageSizes.bs"

' The maximum number of seconds we will show the loading spinner and delay the user from using the home view while the content loads
' We use this to wait for the rows to load so we can reset focus to the row/item once it loads
const MAX_TIME_HOME_LOADING_SPINNER_SHOWN = 1

sub init()
    m.top.itemComponentName = "HomeItem"
    ' how many rows are visible on the screen
    m.top.numRows = 2

    m.top.rowFocusAnimationStyle = "fixedFocusWrap"
    m.top.vertFocusAnimationStyle = "fixedFocus"

    m.top.showRowLabel = [true]
    m.top.rowLabelOffset = [0, 20]
    m.top.showRowCounter = [true]

    m.homeSections = {}

    m.loadingTimer = createObject("roSGNode", "Timer")
    m.loadingTimer.duration = MAX_TIME_HOME_LOADING_SPINNER_SHOWN
    m.loadingTimer.observeField("fire", "stopLoadingSpinner")

    updateSize()

    m.top.setfocus(true)

    m.top.observeField("rowItemSelected", "itemSelected")

    ' Load the Libraries from API via task
    m.LoadLibrariesTask = createObject("roSGNode", "LoadItemsTask")
    m.LoadLibrariesTask.observeField("content", "onLibrariesLoaded")

    ' set up tesk nodes for other rows
    m.LoadContinueWatchingTask = createObject("roSGNode", "LoadItemsTask")
    m.LoadContinueWatchingTask.itemsToLoad = "continue"

    m.LoadNextUpTask = createObject("roSGNode", "LoadItemsTask")
    m.LoadNextUpTask.itemsToLoad = "nextUp"

    m.LoadOnNowTask = createObject("roSGNode", "LoadItemsTask")
    m.LoadOnNowTask.itemsToLoad = "onNow"

    m.LoadFavoritesTask = createObject("roSGNode", "LoadItemsTask")
    m.LoadFavoritesTask.itemsToLoad = "favorites"
end sub

sub loadLibraries()
    m.LoadLibrariesTask.control = "RUN"
end sub

sub updateSize()
    m.top.translation = [111, 180]
    itemHeight = 330

    'Set width of Rows to cut off at edge of Safe Zone
    m.top.itemSize = [1703, itemHeight]

    ' spacing between rows
    m.top.itemSpacing = [0, 105]

    ' spacing between items in a row
    m.top.rowItemSpacing = [20, 0]

    m.top.visible = true
end sub

' processUserSections: Loop through user's chosen home section settings and generate the content for each row
'
' @return {dynamic} content node filled with child nodes for each row
function processUserSections() as dynamic
    m.homeSections = {}

    loadedSections = 0
    content = CreateObject("roSGNode", "ContentNode")

    ' Add sections in order based on user settings
    for i = 0 to 6
        sectionName = LCase(m.global.session.user.settings["homesection" + i.toStr()])
        sectionLoaded = addHomeSection(content, sectionName)

        ' Count how many sections with data are loaded
        if sectionLoaded then loadedSections++

        ' If 2 sections with data are loaded or we're at the end of the web client section data, consider the home view loaded
        if not m.global.app_loaded
            if loadedSections = 2 or i = 6
                m.top.signalBeacon("AppLaunchComplete") ' Roku Performance monitoring
                m.global.app_loaded = true
            end if
        end if
    end for

    ' Favorites isn't an option on Web settings, so we must manually add it for now
    addHomeSection(content, "favorites")

    return content
end function


' onLibrariesLoaded: Handler when LoadLibrariesTask returns data
'
sub onLibrariesLoaded()
    ' save data for other functions
    m.libraryData = m.LoadLibrariesTask.content
    m.LoadLibrariesTask.unobserveField("content")
    m.LoadLibrariesTask.content = []

    content = processUserSections()

    setRowItemSizes()

    m.top.content = content
end sub

' Removes a home section from the home rows
sub removeHomeSection(sectionType as string)
    sectionName = LCase(sectionType)

    removedSection = m.homeSections[sectionName]

    if not isValid(removedSection) then return
    if not isValid(removedSection.index) then return

    for each section in m.homeSections
        if m.homeSections[section].index > removedSection.index
            m.homeSections[section].index--
        end if
    end for

    m.homeSections.Delete(sectionName)
    m.top.content.removeChildIndex(removedSection.index)

    setRowItemSizes()
end sub

' setRowItemSizes: Loops through all home sections and sets the correct item sizes per row
'
sub setRowItemSizes()
    newSizeArray = CreateObject("roArray", m.homeSections.count(), false)

    for each section in m.homeSections
        newSizeArray[m.homeSections[section].index] = m.homeSections[section].imagesize
    end for

    m.top.rowItemSize = newSizeArray
end sub

' Adds a new home section to the home rows.
' Returns a boolean indicating whether the section was handled.
function addHomeSection(content as dynamic, sectionName as string) as boolean
    ' Poster size library items
    if sectionName = "livetv"
        createLiveTVRow(content)
        return true
    end if

    ' Poster size library items
    if sectionName = "smalllibrarytiles"
        createLibraryRow(content)
        return true
    end if

    ' Continue Watching items
    if sectionName = "resume"
        createContinueWatchingRow(content)
        return true
    end if

    ' Next Up items
    if sectionName = "nextup"
        createNextUpRow(content)
        return true
    end if

    ' Latest items in each library
    if sectionName = "latestmedia"
        createLatestInRows(content)
        return true
    end if

    ' Favorite Items
    if sectionName = "favorites"
        createFavoritesRow(content)
        return true
    end if

    return false
end function

' Create a row displaying the user's libraries
sub createLibraryRow(content as dynamic)
    ' Ensure we have data
    if not isValidAndNotEmpty(m.libraryData) then return

    mediaRow = content.CreateChild("HomeRow")
    mediaRow.title = tr("My Media")

    m.homeSections.AddReplace("library", {
        imageSize: imageSizes.WIDE_POSTER,
        index: m.homeSections.count()
    })

    filteredMedia = filterNodeArray(m.libraryData, "id", m.global.session.user.configuration.MyMediaExcludes)
    for each item in filteredMedia
        mediaRow.appendChild(item)
    end for
end sub

' Create a row displaying latest items in each of the user's libraries
sub createLatestInRows(content as dynamic)
    ' Ensure we have data
    if not isValidAndNotEmpty(m.libraryData) then return

    ' create a "Latest In" row for each library
    filteredLatest = filterNodeArray(m.libraryData, "id", m.global.session.user.configuration.LatestItemsExcludes)
    for each lib in filteredLatest
        if lib.collectionType <> "boxsets" and lib.collectionType <> "livetv" and lib.json.CollectionType <> "Program"
            latestInRow = content.CreateChild("HomeRow")
            latestInRow.title = tr("Latest in") + " " + lib.name + " >"

            imagesize = imageSizes.WIDE_POSTER

            if LCase(lib.collectionType) = "movies"
                imagesize = imageSizes.MOVIE_POSTER
            else if LCase(lib.collectionType) = "music"
                imagesize = imageSizes.MUSIC_ALBUM
            end if

            m.homeSections.AddReplace("latestin" + LCase(lib.name).Replace(" ", ""), {
                imageSize: imagesize,
                index: m.homeSections.count()
            })

            loadLatest = createObject("roSGNode", "LoadItemsTask")
            loadLatest.itemsToLoad = "latest"
            loadLatest.itemId = lib.id

            metadata = { "title": lib.name }
            metadata.Append({ "contentType": lib.json.CollectionType })
            loadLatest.metadata = metadata

            loadLatest.observeField("content", "updateLatestItems")
            loadLatest.control = "RUN"
        end if
    end for
end sub

' Create a row displaying the live tv now on section
sub createLiveTVRow(content as dynamic)
    contentRow = content.CreateChild("HomeRow")
    contentRow.title = tr("On Now")
    m.homeSections.AddReplace("livetv", {
        imageSize: imageSizes.WIDE_POSTER,
        index: m.homeSections.count()
    })

    m.LoadOnNowTask.observeField("content", "updateOnNowItems")
    m.LoadOnNowTask.control = "RUN"
end sub

' Create a row displaying items the user can continue watching
sub createContinueWatchingRow(content as dynamic)
    continueWatchingRow = content.CreateChild("HomeRow")
    continueWatchingRow.title = tr("Continue Watching")
    m.homeSections.AddReplace("resume", {
        imageSize: imageSizes.WIDE_POSTER,
        index: m.homeSections.count()
    })

    ' Load the Continue Watching Data
    m.LoadContinueWatchingTask.observeField("content", "updateContinueWatchingItems")
    m.LoadContinueWatchingTask.control = "RUN"
end sub

' Create a row displaying next episodes up to watch
sub createNextUpRow(content as dynamic)
    nextUpRow = content.CreateChild("HomeRow")
    nextUpRow.title = tr("Next Up >")
    m.homeSections.AddReplace("nextup", {
        imageSize: imageSizes.WIDE_POSTER,
        index: m.homeSections.count()
    })

    ' Load the Next Up Data
    m.LoadNextUpTask.observeField("content", "updateNextUpItems")
    m.LoadNextUpTask.control = "RUN"
end sub

' Create a row displaying items from the user's favorites list
sub createFavoritesRow(content as dynamic)
    favoritesRow = content.CreateChild("HomeRow")
    favoritesRow.title = tr("Favorites")

    m.homeSections.AddReplace("favorites", {
        imageSize: imageSizes.WIDE_POSTER,
        index: m.homeSections.count()
    })

    ' Load the Favorites Data
    m.LoadFavoritesTask.observeField("content", "updateFavoritesItems")
    m.LoadFavoritesTask.control = "RUN"
end sub

' Update home row data
sub updateHomeRows()
    startMediaLoadingSpinner()
    m.loadingTimer.control = "start"
    content = processUserSections()
    setRowItemSizes()
    m.top.content = content
end sub

sub updateFavoritesItems()
    itemData = m.LoadFavoritesTask.content
    m.LoadFavoritesTask.unobserveField("content")
    m.LoadFavoritesTask.content = []

    if itemData = invalid then return

    rowIndex = m.homeSections.favorites.index

    if itemData.count() < 1
        removeHomeSection("favorites")
        return
    else
        ' remake row using the new data
        row = CreateObject("roSGNode", "HomeRow")
        row.title = tr("Favorites")

        for each item in itemData
            usePoster = true

            if lcase(item.type) = "episode" or lcase(item.type) = "audio" or lcase(item.type) = "musicartist"
                usePoster = false
            end if

            item.usePoster = usePoster
            item.imageWidth = row.imageWidth
            row.appendChild(item)
        end for

        ' replace the old row
        m.top.content.replaceChild(row, rowIndex)
        ' Set focus on previously focused item
        setFocusToPreviousFocusedItem()

    end if
end sub

sub updateContinueWatchingItems()
    itemData = m.LoadContinueWatchingTask.content
    m.LoadContinueWatchingTask.unobserveField("content")
    m.LoadContinueWatchingTask.content = []

    if itemData = invalid then return

    if itemData.count() < 1
        removeHomeSection("resume")
        return
    end if

    ' remake row using the new data
    row = CreateObject("roSGNode", "HomeRow")
    row.title = tr("Continue Watching")

    for each item in itemData
        if isValid(item.json) and isValid(item.json.UserData) and isValid(item.json.UserData.PlayedPercentage)
            item.PlayedPercentage = item.json.UserData.PlayedPercentage
        end if

        item.usePoster = row.usePoster
        item.imageWidth = row.imageWidth
        row.appendChild(item)
    end for

    ' replace the old row
    m.top.content.replaceChild(row, m.homeSections.resume.index)
    ' Set focus on previously focused item
    setFocusToPreviousFocusedItem()
end sub

sub updateNextUpItems()
    itemData = m.LoadNextUpTask.content
    m.LoadNextUpTask.unobserveField("content")
    m.LoadNextUpTask.content = []
    m.LoadNextUpTask.control = "STOP"

    if itemData = invalid then return

    if itemData.count() < 1
        removeHomeSection("nextup")
        return
    else
        ' remake row using the new data
        row = CreateObject("roSGNode", "HomeRow")
        row.title = tr("Next Up") + " >"
        for each item in itemData
            item.usePoster = row.usePoster
            item.imageWidth = row.imageWidth
            row.appendChild(item)
        end for

        ' replace the old row
        m.top.content.replaceChild(row, m.homeSections.nextup.index)
        ' Set focus on previously focused item
        setFocusToPreviousFocusedItem()
    end if
end sub

' Iterate over user's libraries and update data for each Latest In section
sub updateLatestInRows()
    ' Ensure we have data
    if not isValidAndNotEmpty(m.libraryData) then return

    ' Load new data for each library
    filteredLatest = filterNodeArray(m.libraryData, "id", m.global.session.user.configuration.LatestItemsExcludes)
    for each lib in filteredLatest
        if lib.collectionType <> "boxsets" and lib.collectionType <> "livetv" and lib.json.CollectionType <> "Program"
            loadLatest = createObject("roSGNode", "LoadItemsTask")
            loadLatest.itemsToLoad = "latest"
            loadLatest.itemId = lib.id

            metadata = {
                "title": lib.name,
                "contentType": lib.json.CollectionType
            }

            loadLatest.metadata = metadata
            loadLatest.observeField("content", "updateLatestItems")
            loadLatest.control = "RUN"
        end if
    end for
end sub

sub updateLatestItems(msg)
    itemData = msg.GetData()

    node = msg.getRoSGNode()
    node.unobserveField("content")
    node.content = []

    if itemData = invalid then return

    sectionName = "latestin" + LCase(node.metadata.title).Replace(" ", "")

    if itemData.count() < 1
        removeHomeSection(sectionName)
        return
    else
        ' remake row using new data
        row = CreateObject("roSGNode", "HomeRow")
        row.title = tr("Latest in") + " " + node.metadata.title + " >"
        row.usePoster = true

        ' Handle specific types with different item widths
        if node.metadata.contentType = "movies"
            row.imageWidth = imageSizes.MOVIE_POSTER[0]
            itemSize = imageSizes.MOVIE_POSTER
        else if node.metadata.contentType = "music"
            row.imageWidth = imageSizes.MUSIC_ALBUM[0]
            itemSize = imageSizes.MUSIC_ALBUM
        else
            row.imageWidth = imageSizes.WIDE_POSTER[0]
            itemSize = imageSizes.WIDE_POSTER
        end if

        for each item in itemData
            item.usePoster = row.usePoster
            item.imageWidth = row.imageWidth
            row.appendChild(item)
        end for

        if isValid(m.homeSections[sectionName])
            rowIndex = m.homeSections[sectionName].index

            ' Replace the old row
            if isValid(rowIndex)
                m.top.content.replaceChild(row, rowIndex)

                ' Set focus on previously focused item
                setFocusToPreviousFocusedItem()

                return
            end if
        end if

        ' Determine highest index of a Lastest In section so we can append the new section after it
        highestLatestHomeSectionIndex = 0

        for each section in m.homeSections
            if LCase(Left(section, 6)) = "latest"
                if m.homeSections[section].index > highestLatestHomeSectionIndex
                    highestLatestHomeSectionIndex = m.homeSections[section].index
                end if
            end if
        end for

        ' We have data for a section that doesn't currently exist
        rowIndex = highestLatestHomeSectionIndex + 1

        ' Advance all the indexes greater than or equal than our new row
        for each section in m.homeSections
            if m.homeSections[section].index >= rowIndex
                m.homeSections[section].index++
            end if
        end for

        m.homeSections.AddReplace(sectionName, {
            imageSize: itemSize,
            index: rowIndex
        })

        m.top.content.insertChild(row, rowIndex)

        ' We've inserted a new row, we must set the row sizes again to ensure they're correct
        setRowItemSizes()

        return
    end if
end sub

' setFocusToPreviousFocusedItem: Sets the cursor focus to the row and item previously selected
'
sub setFocusToPreviousFocusedItem()
    if not isValidAndNotEmpty(m.selectedRowItem) then return

    ' Set focus to row if it exists
    itemRow = m.top.content.getChild(m.selectedRowItem[0])
    if isValid(itemRow)
        m.top.jumpToItem = m.selectedRowItem[0]

        ' Set focus to column if it exists
        itemColumn = itemRow.getChild(m.selectedRowItem[1])
        if isValid(itemColumn)
            m.top.jumpToRowItem = [m.selectedRowItem[0], m.selectedRowItem[1]]
            m.loadingTimer.control = "stop"
            stopLoadingSpinner()
        end if
    end if
end sub

sub updateOnNowItems()
    itemData = m.LoadOnNowTask.content
    m.LoadOnNowTask.unobserveField("content")
    m.LoadOnNowTask.content = []

    if itemData = invalid then return

    if itemData.count() < 1
        removeHomeSection("livetv")
        return
    else
        ' remake row using the new data
        row = CreateObject("roSGNode", "HomeRow")
        row.title = tr("On Now")
        row.imageWidth = imageSizes.WIDE_POSTER[0]
        for each item in itemData
            row.usePoster = false

            if (not isValid(item.thumbnailURL) or item.thumbnailURL = "") and isValid(item.json) and isValid(item.json.imageURL)
                item.thumbnailURL = item.json.imageURL
                row.usePoster = true
                row.imageWidth = imageSizes.MOVIE_POSTER[0]

                m.homeSections.livetv.imageSize = imageSizes.MOVIE_POSTER
            end if

            item.usePoster = row.usePoster
            item.imageWidth = row.imageWidth
            row.appendChild(item)
        end for

        ' replace the old row
        m.top.content.replaceChild(row, m.homeSections.livetv.index)
        ' Set focus on previously focused item
        setFocusToPreviousFocusedItem()

        ' We may now have different poster sizes. Reset the row item sizes
        setRowItemSizes()

    end if
end sub

sub itemSelected()
    m.selectedRowItem = m.top.rowItemSelected

    m.top.selectedItem = m.top.content.getChild(m.top.rowItemSelected[0]).getChild(m.top.rowItemSelected[1])

    'Prevent the selected item event from double firing
    m.top.selectedItem = invalid
end sub

function onKeyEvent(key as string, press as boolean) as boolean
    if press
        if key = "play"
            print "play was pressed from homerow"
            itemToPlay = m.top.content.getChild(m.top.rowItemFocused[0]).getChild(m.top.rowItemFocused[1])
            if isValid(itemToPlay)
                m.top.quickPlayNode = itemToPlay
            end if
            return true
        else if key = "replay"
            m.top.jumpToRowItem = [m.top.rowItemFocused[0], 0]
            return true
        end if
    end if
    return false
end function

function filterNodeArray(nodeArray as object, nodeKey as string, excludeArray as object) as object
    if excludeArray.IsEmpty() then return nodeArray

    newNodeArray = []
    for each node in nodeArray
        excludeThisNode = false
        for each exclude in excludeArray
            if node[nodeKey] = exclude
                excludeThisNode = true
            end if
        end for
        if excludeThisNode = false
            newNodeArray.Push(node)
        end if
    end for
    return newNodeArray
end function