EpgContainer.h

/*
 *  Copyright (C) 2012-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_epg.h"
#include "pvr/settings/PVRSettings.h"
#include "threads/CriticalSection.h"
#include "threads/Event.h"
#include "threads/Thread.h"
#include "utils/EventStream.h"

#include <atomic>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

class CDateTime;

namespace PVR
{
  class CEpgUpdateRequest;
  class CEpgTagStateChange;
  class CPVREpg;
  class CPVREpgChannelData;
  class CPVREpgDatabase;
  class CPVREpgInfoTag;
  class CPVREpgSearchFilter;

  enum class PVREvent;

  struct PVREpgSearchData;

  class CPVREpgContainer : private CThread
  {
    friend class CPVREpgDatabase;

  public:
    CPVREpgContainer() = delete;

    explicit CPVREpgContainer(CEventSource<PVREvent>& eventSource);

    ~CPVREpgContainer() override;

    std::shared_ptr<CPVREpgDatabase> GetEpgDatabase() const;

    void Start();

    void Stop();

    bool Load();

    void Unload();

    bool IsStarted() const;

    bool QueueDeleteEpgs(const std::vector<std::shared_ptr<CPVREpg>>& epgs);

    void Notify(const PVREvent& event);

    std::shared_ptr<CPVREpg> CreateChannelEpg(int iEpgId, const std::string& strScraperName, const std::shared_ptr<CPVREpgChannelData>& channelData);

    std::pair<CDateTime, CDateTime> GetFirstAndLastEPGDate() const;

    std::vector<std::shared_ptr<CPVREpg>> GetAllEpgs() const;

    std::shared_ptr<CPVREpg> GetById(int iEpgId) const;

    std::shared_ptr<CPVREpg> GetByChannelUid(int iClientId, int iChannelUid) const;

    std::shared_ptr<CPVREpgInfoTag> GetTagById(const std::shared_ptr<const CPVREpg>& epg,
                                               unsigned int iBroadcastId) const;

    std::shared_ptr<CPVREpgInfoTag> GetTagByDatabaseId(int iDatabaseId) const;

    std::vector<std::shared_ptr<CPVREpgInfoTag>> GetTags(const PVREpgSearchData& searchData) const;

    void SetHasPendingUpdates(bool bHasPendingUpdates = true);

    void UpdateRequest(int iClientID, int iUniqueChannelID);

    void UpdateFromClient(const std::shared_ptr<CPVREpgInfoTag>& tag, EPG_EVENT_STATE eNewState);

    int GetPastDaysToDisplay() const;

    int GetFutureDaysToDisplay() const;

    void OnPlaybackStarted();

    void OnPlaybackStopped();

    void OnSystemSleep();

    void OnSystemWake();

    int CleanupCachedImages();

    std::vector<std::shared_ptr<CPVREpgSearchFilter>> GetSavedSearches(bool bRadio);

    std::shared_ptr<CPVREpgSearchFilter> GetSavedSearchById(bool bRadio, int iId);

    bool PersistSavedSearch(CPVREpgSearchFilter& search);

    bool UpdateSavedSearchLastExecuted(const CPVREpgSearchFilter& epgSearch);

    bool DeleteSavedSearch(const CPVREpgSearchFilter& search);

  private:
    bool CheckPlayingEvents();

    int NextEpgId();

    void WaitForUpdateFinish();

    bool PersistAll(unsigned int iMaxTimeslice) const;

    bool RemoveOldEntries();

    bool UpdateEPG(bool bOnlyPending = false);

    bool InterruptUpdate() const;

    void Process() override;

    void LoadFromDatabase();

    void InsertFromDB(const std::shared_ptr<CPVREpg>& newEpg);

    bool QueueDeleteEpg(const std::shared_ptr<const CPVREpg>& epg,
                        const std::shared_ptr<CPVREpgDatabase>& database);

    std::shared_ptr<CPVREpgDatabase> m_database; 
    bool m_bIsUpdating = false; 
    std::atomic<bool> m_bIsInitialising = {
        true}; 
    bool m_bStarted = false; 
    bool m_bLoaded = false; 
    bool m_bPreventUpdates = false; 
    bool m_bPlaying = false; 
    int m_pendingUpdates = 0; 
    time_t m_iLastEpgCleanup = 0; 
    time_t m_iNextEpgUpdate = 0; 
    time_t m_iNextEpgActiveTagCheck = 0; 
    int m_iNextEpgId = 0; 
    std::map<int, std::shared_ptr<CPVREpg>> m_epgIdToEpgMap; 
    std::map<std::pair<int, int>, std::shared_ptr<CPVREpg>> m_channelUidToEpgMap; 
    mutable CCriticalSection m_critSection; 
    CEvent m_updateEvent; 
    std::list<CEpgUpdateRequest> m_updateRequests; 
    CCriticalSection m_updateRequestsLock; 
    std::list<CEpgTagStateChange> m_epgTagChanges; 
    CCriticalSection m_epgTagChangesLock; 
    bool m_bUpdateNotificationPending = false; 
    CPVRSettings m_settings;
    CEventSource<PVREvent>& m_events;

    std::atomic<bool> m_bSuspended = {false};
  };
}