mythcontrol.h

/*
 *      Copyright (C) 2014 Jean-Luc Barriere
 *
 *  This Program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This Program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301 USA
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */
 
#ifndef MYTHCONTROL_H
#define MYTHCONTROL_H
 
#include "proto/mythprotomonitor.h"
#include "mythtypes.h"
#include "mythwsapi.h"
 
namespace Myth
{
 
  class Control
  {
  public:
    Control(const std::string& server, unsigned protoPort, unsigned wsapiPort, const std::string& wsapiSecurityPin);
    Control(const std::string& server, unsigned protoPort, unsigned wsapiPort, const std::string& wsapiSecurityPin, bool frontend);
    ~Control();
 
    Control& WithAuthorization(const std::string& user, const std::string& password)
    {
      m_wsapi.WithAuthorization(user, password);
      return *this;
    }
    Control& WithSSL(bool yesno)
    {
      m_wsapi.WithSSL(yesno);
      return *this;
    }
 
    bool Open();
    void Close();
    bool IsOpen() { return m_monitor.IsOpen(); }
    bool HasHanging() const { return m_monitor.HasHanging(); }
    void CleanHanging() { m_monitor.CleanHanging(); }
    ProtoBase::ERROR_t GetProtoError() const { return m_monitor.GetProtoError(); }

    unsigned CheckService()
    {
      return m_wsapi.CheckService();
    }

    std::string GetServerHostName()
    {
      return m_wsapi.GetServerHostName();
    }

    std::string GetBaseURL()
    {
      return m_wsapi.GetBaseURL();
    }

    VersionPtr GetVersion()
    {
      return m_wsapi.GetVersion();
    }

    bool QueryFreeSpaceSummary(int64_t *total, int64_t *used)
    {
      return m_monitor.QueryFreeSpaceSummary(total, used);
    }

    bool QueryGenPixmap(const Program& program)
    {
      return m_monitor.QueryGenpixmap(program);
    }

    bool CancelNextRecording(int rnum, bool cancel)
    {
      return m_monitor.CancelNextRecording(rnum, cancel);
    }

    SettingPtr GetHostSetting(const std::string& key, const std::string& hostname)
    {
      return m_wsapi.GetHostSetting(key, hostname);
    }

    SettingPtr GetSetting(const std::string& key, bool myhost)
    {
      return m_wsapi.GetSetting(key, myhost);
    }

    SettingMapPtr GetHostSettings(const std::string& hostname)
    {
      return m_wsapi.GetHostSettings(hostname);
    }

    SettingMapPtr GetSettings(bool myhost)
    {
      return m_wsapi.GetSettings(myhost);
    }

    bool PutSetting(const std::string& key, const std::string& value, bool myhost)
    {
      return m_wsapi.PutSetting(key, value, myhost);
    }

    std::string GetBackendServerIP(const std::string& hostName);

    std::string GetBackendServerIP6(const std::string& hostName);

    unsigned GetBackendServerPort(const std::string& hostName);

    ProgramListPtr GetRecordedList(unsigned n = 0, bool descending = false)
    {
      return m_wsapi.GetRecordedList(n, descending);
    }

    ProgramPtr GetRecorded(uint32_t chanid, time_t recstartts)
    {
      return m_wsapi.GetRecorded(chanid, recstartts);
    }

    ProgramPtr GetRecorded(uint32_t recordedid)
    {
      return m_wsapi.GetRecorded(recordedid);
    }

    bool UpdateRecordedWatchedStatus(const Program& program, bool watched)
    {
      WSServiceVersion_t wsv = m_wsapi.CheckService(WS_Dvr);
      if (wsv.ranking >= 0x00060000)
        return m_wsapi.UpdateRecordedWatchedStatus(program.recording.recordedId, watched);
      return m_wsapi.UpdateRecordedWatchedStatus(program.channel.chanId, program.recording.startTs, watched);
    }

    bool DeleteRecording(const Program& program, bool forceDelete = false, bool allowRerecord = false)
    {
      WSServiceVersion_t wsv = m_wsapi.CheckService(WS_Dvr);
      if (wsv.ranking >= 0x00060000)
        return m_wsapi.DeleteRecording(program.recording.recordedId, forceDelete, allowRerecord);
      if (wsv.ranking >= 0x00020001)
        return m_wsapi.DeleteRecording(program.channel.chanId, program.recording.startTs, forceDelete, allowRerecord);
      return m_monitor.DeleteRecording(program, forceDelete, allowRerecord);
    }
 
    bool UndeleteRecording(const Program& program)
    {
      WSServiceVersion_t wsv = m_wsapi.CheckService(WS_Dvr);
      if (wsv.ranking >= 0x00060000)
        return m_wsapi.UnDeleteRecording(program.recording.recordedId);
      if (wsv.ranking >= 0x00020001)
        return m_wsapi.UnDeleteRecording(program.channel.chanId, program.recording.startTs);
      return m_monitor.UndeleteRecording(program);
    }
 
    bool StopRecording(const Program& program)
    {
      return m_monitor.StopRecording(program);
    }

    CaptureCardListPtr GetCaptureCardList()
    {
      return m_wsapi.GetCaptureCardList();
    }

    VideoSourceListPtr GetVideoSourceList()
    {
      return m_wsapi.GetVideoSourceList();
    }

    ChannelListPtr GetChannelList(uint32_t sourceid, bool onlyVisible = true)
    {
      return m_wsapi.GetChannelList(sourceid, onlyVisible);
    }

    ChannelPtr GetChannel(uint32_t chanid)
    {
      return m_wsapi.GetChannel(chanid);
    }

    ProgramMapPtr GetProgramGuide(uint32_t chanid, time_t starttime, time_t endtime)
    {
      return m_wsapi.GetProgramGuide(chanid, starttime, endtime);
    }

    std::map<uint32_t, ProgramMapPtr> GetProgramGuide(time_t starttime, time_t endtime)
    {
      return m_wsapi.GetProgramGuide(starttime, endtime);
    }

    RecordScheduleListPtr GetRecordScheduleList()
    {
      return m_wsapi.GetRecordScheduleList();
    }

    RecordSchedulePtr GetRecordSchedule(uint32_t recordid)
    {
      return m_wsapi.GetRecordSchedule(recordid);
    }

    bool AddRecordSchedule(RecordSchedule& record)
    {
      return m_wsapi.AddRecordSchedule(record);
    }

    bool UpdateRecordSchedule(RecordSchedule& record)
    {
      return m_wsapi.UpdateRecordSchedule(record);
    }

    bool DisableRecordSchedule(uint32_t recordid)
    {
      return m_wsapi.DisableRecordSchedule(recordid);
    }

    bool EnableRecordSchedule(uint32_t recordid)
    {
      return m_wsapi.EnableRecordSchedule(recordid);
    }

    bool RemoveRecordSchedule(uint32_t recordid)
    {
      return m_wsapi.RemoveRecordSchedule(recordid);
    }

    ProgramListPtr GetUpcomingList()
    {
      return m_wsapi.GetUpcomingList();
    }

    ProgramListPtr GetConflictList()
    {
      return m_wsapi.GetConflictList();
    }

    ProgramListPtr GetExpiringList()
    {
      return m_wsapi.GetExpiringList();
    }

    StringListPtr GetRecGroupList()
    {
      return m_wsapi.GetRecGroupList();
    }

    WSStreamPtr GetFile(const std::string& filename, const std::string& sgname)
    {
      return m_wsapi.GetFile(filename, sgname);
    }

    WSStreamPtr GetChannelIcon(uint32_t chanid, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetChannelIcon(chanid, width, height);
    }

    std::string GetChannelIconUrl(uint32_t chanid, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetChannelIconUrl(chanid, width, height);
    }

    WSStreamPtr GetPreviewImage(const Program& program, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetPreviewImage(program.channel.chanId, program.recording.startTs, width, height);
    }

    std::string GetPreviewImageUrl(const Program& program, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetPreviewImageUrl(program.channel.chanId, program.recording.startTs, width, height);
    }

    WSStreamPtr GetRecordingArtwork(const std::string& type, const Program& program, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetRecordingArtwork(type, program.inetref, program.season, width, height);
    }

    std::string GetRecordingArtworkUrl(const std::string& type, const Program& program, unsigned width = 0, unsigned height = 0)
    {
      return m_wsapi.GetRecordingArtworkUrl(type, program.inetref, program.season, width, height);
    }

    ArtworkListPtr GetRecordingArtworkList(uint32_t chanid, time_t recstartts)
    {
      return m_wsapi.GetRecordingArtworkList(chanid, recstartts);
    }

    bool RefreshRecordedArtwork(Program& program);

    MarkListPtr GetCutList(const Program& program, int unit = 0)
    {
      WSServiceVersion_t wsv = m_wsapi.CheckService(WS_Dvr);
      if (wsv.ranking >= 0x00060001)
        return m_wsapi.GetRecordedCutList(program.recording.recordedId, unit);
      if (unit == 0)
        return m_monitor.GetCutList(program);
      else
        return MarkListPtr(new MarkList);
    }

    MarkListPtr GetCommBreakList(const Program& program, int unit = 0)
    {
      WSServiceVersion_t wsv = m_wsapi.CheckService(WS_Dvr);
      if (wsv.ranking >= 0x00060001)
        return m_wsapi.GetRecordedCommBreak(program.recording.recordedId, unit);
      if (unit == 0)
        return m_monitor.GetCommBreakList(program);
      else
        return MarkListPtr(new MarkList);
    }

    bool BlockShutdown()
    {
      return m_monitor.BlockShutdown();
    }

    bool AllowShutdown()
    {
      return m_monitor.AllowShutdown();
    }

    bool SetSavedBookmark(const Program& program, int unit, int64_t value)
    {
      return m_wsapi.SetSavedBookmark(program.recording.recordedId, unit, value);
    }

    int64_t GetSavedBookmark(const Program& program, int unit)
    {
      return m_wsapi.GetSavedBookmark(program.recording.recordedId, unit);
    }
 
  private:
    ProtoMonitor m_monitor;
    WSAPI m_wsapi;
 
  };
 
}
 
#endif  /* MYTHCONTROL_H */