menu.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <string>
 
#include <vdr/interface.h>
#include <vdr/osdbase.h>
#include <vdr/plugin.h>
#include <vdr/videodir.h>
 
#include "device.h"
#include "logger.h"
#include "mediaplayer.h"
#include "menu.h"
 
cDeviceMenu::cDeviceMenu(const char *title, cOutputDevice *device,
                         int c0, int c1, int c2, int c3, int c4)
    : cOsdMenu(title, c0, c1, c2, c3, c4),
      m_pDevice(device)
{
    pMenu = this;
    m_playlist.clear();
 
    if (cDrmDeviceControl::Control() && cDrmDeviceControl::Control()->Player()->GetFirstPlaylistEntry()) {
        LOGDEBUG2(L_MEDIA, "mediaplayer: %s: pointer to cDrmDeviceControl exist.", __FUNCTION__);
        PlayListMenu();     // Test if PL!!!
    } else {
        MainMenu();
    }
}
 
cDeviceMenu::~cDeviceMenu()
{
    pMenu = NULL;
}
 
static inline cOsdItem *SeparatorName(const char *label)
{
    return new cOsdItem(cString::sprintf("%s:", label), osUnknown, false);
}
 
static inline cOsdItem *SeparatorSpace(void)
{
    return new cOsdItem(" ", osUnknown, false);
}
 
void cDeviceMenu::MainMenu(void)
{
    int current;
 
    current = Current();               // get current menu item index
    Clear();                           // clear the menu
 
    // pip
    if (m_pDevice->UsePip()) {
        Add(SeparatorName("PIP"));
        Add(new cOsdItem(hk(tr(" Toggle")), osUser1));
        Add(new cOsdItem(hk(tr(" Channel +")), osUser2));
        Add(new cOsdItem(hk(tr(" Channel -")), osUser3));
        Add(new cOsdItem(hk(tr(" Swap channels")), osUser4));
        Add(new cOsdItem(hk(tr(" Swap position")), osUser5));
        Add(new cOsdItem(hk(tr(" Switch to pip channel")), osUser6));
    }
 
    Add(SeparatorSpace());
 
    // detach
    Add(SeparatorName("Detach"));
    Add(new cOsdItem(hk(tr(" Detach device")), osUser7));
 
    Add(SeparatorSpace());
 
    // mediaplayer
    Add(SeparatorName("Mediaplayer"));
    Add(new cOsdItem(hk(tr(" play file / make play list")), osUser8));
    Add(new cOsdItem(hk(tr(" select play list")), osUser9));
 
    SetCurrent(Get(current));          // restore selected menu entry
    Display();
}
 
enum Hotkeys {
    PIPKEYBASE = 100,
    PIPTOGGLEONOFF,
    PIPCHANNELUP,
    PIPCHANNELDOWN,
    PIPCHANNELSWAP,
    PIPPOSITIONSWAP,
    PIPCHANNELSWITCHBACK,
    DETACHKEYBASE = 110,
    DETACHDEVICE,
    ATTACHDEVICE
};
 
void cDeviceMenu::HandleHotKey(int code) {
    switch (code) {
        // pip
        case PIPTOGGLEONOFF:
            m_pDevice->PipToggle();
            break;
        case PIPCHANNELUP:
            m_pDevice->PipChannelChange(1);
            break;
        case PIPCHANNELDOWN:
            m_pDevice->PipChannelChange(-1);
            break;
        case PIPCHANNELSWAP:
            m_pDevice->PipChannelSwap(false);
            break;
        case PIPPOSITIONSWAP:
            m_pDevice->PipSwapPosition();
            break;
        case PIPCHANNELSWITCHBACK:
            m_pDevice->PipChannelSwap(true);
            break;
        // detach/ attach
        case DETACHDEVICE:
            m_pDevice->Detach();
            break;
        case ATTACHDEVICE:
            m_pDevice->Attach();
            break;
        default:
            break;
    }
}
 
eOSState cDeviceMenu::ProcessKey(eKeys key)
{
    eOSState state;
    cOsdItem *item;
 
    switch (m_hotkeyState) {
        case HotkeyState::Initial:
            if (key == kBlue) {
                if (!m_pDevice->UsePip())
                    return osEnd;
 
                m_hotkeyState = HotkeyState::Blue;
                return osContinue;
            }
            if (key == kRed) {
                m_hotkeyState = HotkeyState::Red;
                return osContinue;
            }
            break;
        case HotkeyState::Blue:              // pip
            if (k0 <= key && key <= k9) {
                int hotkeyCode = static_cast<int>(PIPKEYBASE) + static_cast<int>(key) - static_cast<int>(k0);
                m_hotkeyState = HotkeyState::Initial;
                HandleHotKey(hotkeyCode);
                return osEnd;
            }
            m_hotkeyState = HotkeyState::Initial;
            break;
        case HotkeyState::Red:               // detach/ attach
            if (k0 <= key && key <= k9) {
                int hotkeyCode = static_cast<int>(DETACHKEYBASE) + static_cast<int>(key) - static_cast<int>(k0);
                m_hotkeyState = HotkeyState::Initial;
                HandleHotKey(hotkeyCode);
                return osEnd;
            }
            m_hotkeyState = HotkeyState::Initial;
            break;
    }
 
    item = (cOsdItem *) Get(Current());
    state = cOsdMenu::ProcessKey(key);
 
    switch (state) {
        // pip
        case osUser1:                   // toggle pip
            m_pDevice->PipToggle();
            return osEnd;
        case osUser2:                   // pip channel +
            m_pDevice->PipChannelChange(1);
            return osEnd;
        case osUser3:                   // pip channel -
            m_pDevice->PipChannelChange(-1);
            return osEnd;
        case osUser4:                   // pip channel swap
            m_pDevice->PipChannelSwap(false);
            return osEnd;
        case osUser5:                   // pip position swap
            m_pDevice->PipSwapPosition();
            return osEnd;
        case osUser6:                   // pip switch main stream back to pip stream and close pip
            m_pDevice->PipChannelSwap(true);
            return osEnd;
 
        // detach
        case osUser7:                   // detach device
            m_pDevice->Detach();
            return osEnd;
 
        // mediaplayer
        case osUser8:                   // play file / make play list
            m_path = cVideoDirectory::Name();
            FindFileMenu(m_path, NULL);
            return osContinue;
        case osUser9:                   // select play list
            m_path = cPlugin::ConfigDirectory("drmdevice");
            SelectPlaylistMenu();
            return osContinue;
        default:
            break;
    }
 
    switch (key) {
        case kOk:
            if (strcasestr(item->Text(), "[..]")) {
                std::string newPath = m_path.substr(0 ,m_path.find_last_of("/"));
 
                if (!m_lastItem.empty())
                    m_lastItem.clear();
                m_lastItem = m_path.substr(m_path.find_last_of("/") + 1);
 
                m_path = newPath;
                FindFileMenu(m_path.c_str(), NULL);
                break;
            }
            if (cDrmDeviceControl::Control() && cDrmDeviceControl::Control()->Player()->GetCurrentPlaylistEntry()) {
                cDrmDeviceControl::Control()->Player()->SetEntry(Current());
//              PlayListMenu();
                break;
            }
            if (IsValidMediaFile(item->Text())) {
                PlayMedia(item->Text());
                return osEnd;
            } else {
                std::string newPath = m_path + "/" + item->Text();
                struct stat sb;
                if (stat(newPath.c_str(), &sb) == 0 && S_ISDIR(sb.st_mode)) {
                    m_path = newPath;
                    FindFileMenu(newPath.c_str(), NULL);
                }
            }
            break;
        case kRed:
            if (cDrmDeviceControl::Control() && cDrmDeviceControl::Control()->Player()->GetCurrentPlaylistEntry()) {
                cDrmDeviceControl::Control()->Player()->ToggleRandomPlay();
                PlayListMenu();
                break;
            }
            if (m_playlist.empty()) {
                if (IsValidMediaFile(item->Text())) {
                    PlayMedia(item->Text());
                    return osEnd;
                }
            } else {
                m_path = cPlugin::ConfigDirectory("drmdevice");
                PlayMedia(m_playlist.c_str());
                return osEnd;
            }
            break;
        case kGreen:
            if (cDrmDeviceControl::Control()) {
                cDrmDeviceControl::Control()->Player()->JumpSec(-60);
            } else {
                MakePlayList(item->Text(), "w");
                Interface->Confirm(tr("New Playlist"), 1, true);
                if (!m_lastItem.empty())
                    m_lastItem.clear();
                m_lastItem = item->Text();
                FindFileMenu(m_path.c_str(), NULL);
            }
            break;
        case kYellow:
            if (cDrmDeviceControl::Control()) {
                cDrmDeviceControl::Control()->Player()->JumpSec(60);
            } else {
                MakePlayList(item->Text(), "a");
                Interface->Confirm(tr("Added to Playlist"), 1, true);
            }
            break;
        case kBlue:
            state = osStopReplay;
            break;
        case kPlay:
            if (IsValidMediaFile(item->Text())) {
                PlayMedia(item->Text());
                return osEnd;
            }
            break;
        case kNext:
            if (cDrmDeviceControl::Control())
                cDrmDeviceControl::Control()->Player()->Stop();
            break;
        default:
            break;
    }
 
    return state;
}
 
/*****************************************************************************
 * Mediaplayer sub menus
 ****************************************************************************/
 
void cDeviceMenu::PlayListMenu(void)
{
    cPlaylistEntry *entry = cDrmDeviceControl::Control()->Player()->GetFirstPlaylistEntry();
    Clear();
    while (1) {
        std::string p_string = entry->OsdItemString();
        Add(new cOsdItem(p_string.c_str()), (entry == cDrmDeviceControl::Control()->Player()->GetCurrentPlaylistEntry()));
 
        if (!entry->GetNextEntry())
            break;
 
        entry = entry->GetNextEntry();
    }
    SetHelp(cDrmDeviceControl::Control()->Player()->IsRandomPlayActive() ? "Random Play" : " No Random Play",
        "Jump -1 min", "Jump +1 min", "End player");
    Display();
}
 
void cDeviceMenu::SelectPlaylistMenu(void)
{
    struct dirent **dirList;
    int n, i;
 
    if ((n = scandir(cPlugin::ConfigDirectory("drmdevice"), &dirList, NULL, alphasort)) == -1) {
        LOGERROR("mediaplayer: %s: searching PL in %s failed (%d): %m", __FUNCTION__,
            cPlugin::ConfigDirectory("drmdevice"), errno);
        return;
    }
 
    Clear();
    for (i = 0; i < n; i++) {
        if (dirList[i]->d_name[0] != '.' && (strcasestr(dirList[i]->d_name, ".M3U"))) {
            Add(new cOsdItem(dirList[i]->d_name));
        }
    }
    SetHelp("Play PL", NULL, NULL, NULL);
    Display();
}
 
void cDeviceMenu::FindFileMenu(std::string searchPath, FILE *playlist)
{
    struct dirent **dirList;
    int n, i;
    const char * sp;
 
    if (!searchPath.size())
        sp = "/";
    else
        sp = searchPath.c_str();
 
    if (!playlist) {
        Clear();
        if (searchPath.size())
            Add(new cOsdItem("[..]"));
    }
 
    if ((n = scandir(sp, &dirList, NULL, alphasort)) == -1) {
        LOGERROR("mediaplayer: %s: scanning directory %s failed (%d): %m", __FUNCTION__, sp, errno);
    } else {
        struct stat fileAttributs;
        for (i = 0; i < n; i++) {
            std::string str = searchPath + "/" + dirList[i]->d_name;
            if (stat(str.c_str(), &fileAttributs) == -1) {
                LOGERROR("mediaplayer: %s: stat on %s failed (%d): %m", __FUNCTION__, str.c_str(), errno);
            } else {
                if (S_ISDIR(fileAttributs.st_mode) && dirList[i]->d_name[0] != '.') {
                    if (playlist) {
                        FindFileMenu(str.c_str(), playlist);
                    } else {
                        Add(new cOsdItem(dirList[i]->d_name),
                            !m_lastItem.compare(0, m_lastItem.length(), dirList[i]->d_name));
                    }
                }
            }
        }
        for (i = 0; i < n; i++) {
            std::string str = searchPath + "/" + dirList[i]->d_name;
            if (stat(str.c_str(), &fileAttributs) == -1) {
                LOGERROR("mediaplayer: %s: stat on %s failed (%d): %m", __FUNCTION__, str.c_str(), errno);
            } else {
                if (S_ISREG(fileAttributs.st_mode) && dirList[i]->d_name[0] != '.') {
                    if (playlist) {
                        if (IsValidMediaFile(dirList[i]->d_name))
                            fprintf(playlist, "%s/%s\n", searchPath.c_str(),
                                dirList[i]->d_name);
                    } else {
                        Add(new cOsdItem(dirList[i]->d_name));
                    }
                }
            }
        }
    }
 
    if (!playlist) {
        SetHelp( m_playlist.empty() ? "Play File" : "Play PL", "New PL", "Add to PL", NULL);
//      SetHelp(Control->Player->Running ? NULL : "Set new PL",
//          Control->Player->Running ? "Play Menu" : "Select PL");
        Display();
    }
}
 
void cDeviceMenu::MakePlayList(const char * target, const char * mode)
{
    if (m_playlist.empty())
        m_playlist = "/default.m3u";
 
    std::string plPath = cPlugin::ConfigDirectory("drmdevice");
    plPath.append(m_playlist.c_str());
    FILE *playlist = fopen(plPath.c_str(), mode);
 
    if (!playlist)
        return;
 
    if (IsValidMediaFile(target)) {
        fprintf(playlist, "%s/%s\n", m_path.c_str(), target);
    } else {
        std::string str = m_path + "/" + target;
        FindFileMenu(str.c_str(), playlist);
    }
 
    fclose (playlist);
}
 
void cDeviceMenu::PlayMedia(const char *name)
{
    std::string aim = m_path + "/" + name;
    if (!cDrmDeviceControl::Control()) {
        cControl::Launch(new cDrmDeviceControl(aim.c_str(), m_pDevice));
    } else {
        LOGERROR("mediaplayer: %s: can't start %s", __FUNCTION__, aim.c_str());
    }
}
 
bool cDeviceMenu::IsValidMediaFile(const char *name)
{
    if (strcasestr(name, ".MP3")  ||
        strcasestr(name, ".MP4")  ||
        strcasestr(name, ".MKV")  ||
        strcasestr(name, ".MPG")  ||
        strcasestr(name, ".AVI")  ||
        strcasestr(name, ".M2TS") ||
        strcasestr(name, ".MPEG") ||
        strcasestr(name, ".M3U")  ||
        strcasestr(name, ".TS")) {
 
        return true;
    }
 
    return false;
}