summaryrefslogtreecommitdiffstats
path: root/xbmc/pvr/filesystem
diff options
context:
space:
mode:
Diffstat (limited to 'xbmc/pvr/filesystem')
-rw-r--r--xbmc/pvr/filesystem/CMakeLists.txt5
-rw-r--r--xbmc/pvr/filesystem/PVRGUIDirectory.cpp625
-rw-r--r--xbmc/pvr/filesystem/PVRGUIDirectory.h107
3 files changed, 737 insertions, 0 deletions
diff --git a/xbmc/pvr/filesystem/CMakeLists.txt b/xbmc/pvr/filesystem/CMakeLists.txt
new file mode 100644
index 0000000..823d783
--- /dev/null
+++ b/xbmc/pvr/filesystem/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(SOURCES PVRGUIDirectory.cpp)
+
+set(HEADERS PVRGUIDirectory.h)
+
+core_add_library(pvr_filesystem)
diff --git a/xbmc/pvr/filesystem/PVRGUIDirectory.cpp b/xbmc/pvr/filesystem/PVRGUIDirectory.cpp
new file mode 100644
index 0000000..1ef7810
--- /dev/null
+++ b/xbmc/pvr/filesystem/PVRGUIDirectory.cpp
@@ -0,0 +1,625 @@
+/*
+ * Copyright (C) 2012-2019 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.
+ */
+
+#include "PVRGUIDirectory.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "input/WindowTranslator.h"
+#include "pvr/PVRManager.h"
+#include "pvr/addons/PVRClients.h"
+#include "pvr/channels/PVRChannel.h"
+#include "pvr/channels/PVRChannelGroupMember.h"
+#include "pvr/channels/PVRChannelGroups.h"
+#include "pvr/channels/PVRChannelGroupsContainer.h"
+#include "pvr/channels/PVRChannelsPath.h"
+#include "pvr/epg/EpgContainer.h"
+#include "pvr/epg/EpgSearchFilter.h"
+#include "pvr/epg/EpgSearchPath.h"
+#include "pvr/recordings/PVRRecording.h"
+#include "pvr/recordings/PVRRecordings.h"
+#include "pvr/recordings/PVRRecordingsPath.h"
+#include "pvr/timers/PVRTimerInfoTag.h"
+#include "pvr/timers/PVRTimers.h"
+#include "pvr/timers/PVRTimersPath.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace PVR;
+
+bool CPVRGUIDirectory::Exists() const
+{
+ if (!CServiceBroker::GetPVRManager().IsStarted())
+ return false;
+
+ return m_url.IsProtocol("pvr") && StringUtils::StartsWith(m_url.GetFileName(), "recordings");
+}
+
+bool CPVRGUIDirectory::SupportsWriteFileOperations() const
+{
+ if (!CServiceBroker::GetPVRManager().IsStarted())
+ return false;
+
+ const std::string filename = m_url.GetFileName();
+ return URIUtils::IsPVRRecording(filename);
+}
+
+namespace
+{
+
+bool GetRootDirectory(bool bRadio, CFileItemList& results)
+{
+ std::shared_ptr<CFileItem> item;
+
+ const std::shared_ptr<CPVRClients> clients = CServiceBroker::GetPVRManager().Clients();
+
+ // EPG
+ const bool bAnyClientSupportingEPG = clients->AnyClientSupportingEPG();
+ if (bAnyClientSupportingEPG)
+ {
+ item.reset(
+ new CFileItem(StringUtils::Format("pvr://guide/{}/", bRadio ? "radio" : "tv"), true));
+ item->SetLabel(g_localizeStrings.Get(19069)); // Guide
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(bRadio ? WINDOW_RADIO_GUIDE
+ : WINDOW_TV_GUIDE));
+ item->SetArt("icon", "DefaultPVRGuide.png");
+ results.Add(item);
+ }
+
+ // Channels
+ item.reset(new CFileItem(
+ bRadio ? CPVRChannelsPath::PATH_RADIO_CHANNELS : CPVRChannelsPath::PATH_TV_CHANNELS, true));
+ item->SetLabel(g_localizeStrings.Get(19019)); // Channels
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(bRadio ? WINDOW_RADIO_CHANNELS
+ : WINDOW_TV_CHANNELS));
+ item->SetArt("icon", "DefaultPVRChannels.png");
+ results.Add(item);
+
+ // Recordings
+ if (clients->AnyClientSupportingRecordings())
+ {
+ item.reset(new CFileItem(bRadio ? CPVRRecordingsPath::PATH_ACTIVE_RADIO_RECORDINGS
+ : CPVRRecordingsPath::PATH_ACTIVE_TV_RECORDINGS,
+ true));
+ item->SetLabel(g_localizeStrings.Get(19017)); // Recordings
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(
+ bRadio ? WINDOW_RADIO_RECORDINGS : WINDOW_TV_RECORDINGS));
+ item->SetArt("icon", "DefaultPVRRecordings.png");
+ results.Add(item);
+ }
+
+ // Timers/Timer rules
+ // - always present, because Reminders are always available, no client support needed for this
+ item.reset(new CFileItem(
+ bRadio ? CPVRTimersPath::PATH_RADIO_TIMERS : CPVRTimersPath::PATH_TV_TIMERS, true));
+ item->SetLabel(g_localizeStrings.Get(19040)); // Timers
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(bRadio ? WINDOW_RADIO_TIMERS
+ : WINDOW_TV_TIMERS));
+ item->SetArt("icon", "DefaultPVRTimers.png");
+ results.Add(item);
+
+ item.reset(new CFileItem(
+ bRadio ? CPVRTimersPath::PATH_RADIO_TIMER_RULES : CPVRTimersPath::PATH_TV_TIMER_RULES, true));
+ item->SetLabel(g_localizeStrings.Get(19138)); // Timer rules
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(
+ bRadio ? WINDOW_RADIO_TIMER_RULES : WINDOW_TV_TIMER_RULES));
+ item->SetArt("icon", "DefaultPVRTimerRules.png");
+ results.Add(item);
+
+ // Search
+ if (bAnyClientSupportingEPG)
+ {
+ item.reset(new CFileItem(
+ bRadio ? CPVREpgSearchPath::PATH_RADIO_SEARCH : CPVREpgSearchPath::PATH_TV_SEARCH, true));
+ item->SetLabel(g_localizeStrings.Get(137)); // Search
+ item->SetProperty("node.target", CWindowTranslator::TranslateWindow(bRadio ? WINDOW_RADIO_SEARCH
+ : WINDOW_TV_SEARCH));
+ item->SetArt("icon", "DefaultPVRSearch.png");
+ results.Add(item);
+ }
+
+ return true;
+}
+
+} // unnamed namespace
+
+bool CPVRGUIDirectory::GetDirectory(CFileItemList& results) const
+{
+ std::string base = m_url.Get();
+ URIUtils::RemoveSlashAtEnd(base);
+
+ std::string fileName = m_url.GetFileName();
+ URIUtils::RemoveSlashAtEnd(fileName);
+
+ results.SetCacheToDisc(CFileItemList::CACHE_NEVER);
+
+ if (fileName.empty())
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ std::shared_ptr<CFileItem> item;
+
+ item.reset(new CFileItem(base + "channels/", true));
+ item->SetLabel(g_localizeStrings.Get(19019)); // Channels
+ item->SetLabelPreformatted(true);
+ results.Add(item);
+
+ item.reset(new CFileItem(base + "recordings/active/", true));
+ item->SetLabel(g_localizeStrings.Get(19017)); // Recordings
+ item->SetLabelPreformatted(true);
+ results.Add(item);
+
+ item.reset(new CFileItem(base + "recordings/deleted/", true));
+ item->SetLabel(g_localizeStrings.Get(19184)); // Deleted recordings
+ item->SetLabelPreformatted(true);
+ results.Add(item);
+
+ // Sort by name only. Labels are preformatted.
+ results.AddSortMethod(SortByLabel, 551 /* Name */, LABEL_MASKS("%L", "", "%L", ""));
+ }
+ return true;
+ }
+ else if (StringUtils::StartsWith(fileName, "tv"))
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ return GetRootDirectory(false, results);
+ }
+ return true;
+ }
+ else if (StringUtils::StartsWith(fileName, "radio"))
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ return GetRootDirectory(true, results);
+ }
+ return true;
+ }
+ else if (StringUtils::StartsWith(fileName, "recordings"))
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ return GetRecordingsDirectory(results);
+ }
+ return true;
+ }
+ else if (StringUtils::StartsWith(fileName, "channels"))
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ return GetChannelsDirectory(results);
+ }
+ return true;
+ }
+ else if (StringUtils::StartsWith(fileName, "timers"))
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ return GetTimersDirectory(results);
+ }
+ return true;
+ }
+
+ const CPVREpgSearchPath path(m_url.Get());
+ if (path.IsValid())
+ {
+ if (CServiceBroker::GetPVRManager().IsStarted())
+ {
+ if (path.IsSavedSearchesRoot())
+ return GetSavedSearchesDirectory(path.IsRadio(), results);
+ }
+ return true;
+ }
+
+ return false;
+}
+
+bool CPVRGUIDirectory::HasTVRecordings()
+{
+ return CServiceBroker::GetPVRManager().IsStarted() &&
+ CServiceBroker::GetPVRManager().Recordings()->GetNumTVRecordings() > 0;
+}
+
+bool CPVRGUIDirectory::HasDeletedTVRecordings()
+{
+ return CServiceBroker::GetPVRManager().IsStarted() &&
+ CServiceBroker::GetPVRManager().Recordings()->HasDeletedTVRecordings();
+}
+
+bool CPVRGUIDirectory::HasRadioRecordings()
+{
+ return CServiceBroker::GetPVRManager().IsStarted() &&
+ CServiceBroker::GetPVRManager().Recordings()->GetNumRadioRecordings() > 0;
+}
+
+bool CPVRGUIDirectory::HasDeletedRadioRecordings()
+{
+ return CServiceBroker::GetPVRManager().IsStarted() &&
+ CServiceBroker::GetPVRManager().Recordings()->HasDeletedRadioRecordings();
+}
+
+namespace
+{
+
+std::string TrimSlashes(const std::string& strOrig)
+{
+ std::string strReturn = strOrig;
+ while (strReturn[0] == '/')
+ strReturn.erase(0, 1);
+
+ URIUtils::RemoveSlashAtEnd(strReturn);
+ return strReturn;
+}
+
+bool IsDirectoryMember(const std::string& strDirectory,
+ const std::string& strEntryDirectory,
+ bool bGrouped)
+{
+ const std::string strUseDirectory = TrimSlashes(strDirectory);
+ const std::string strUseEntryDirectory = TrimSlashes(strEntryDirectory);
+
+ // Case-insensitive comparison since sub folders are created with case-insensitive matching (GetSubDirectories)
+ if (bGrouped)
+ return StringUtils::EqualsNoCase(strUseDirectory, strUseEntryDirectory);
+ else
+ return StringUtils::StartsWithNoCase(strUseEntryDirectory, strUseDirectory);
+}
+
+void GetSubDirectories(const CPVRRecordingsPath& recParentPath,
+ const std::vector<std::shared_ptr<CPVRRecording>>& recordings,
+ CFileItemList& results)
+{
+ // Only active recordings are fetched to provide sub directories.
+ // Not applicable for deleted view which is supposed to be flattened.
+ std::set<std::shared_ptr<CFileItem>> unwatchedFolders;
+ bool bRadio = recParentPath.IsRadio();
+
+ for (const auto& recording : recordings)
+ {
+ if (recording->IsDeleted())
+ continue;
+
+ if (recording->IsRadio() != bRadio)
+ continue;
+
+ const std::string strCurrent =
+ recParentPath.GetUnescapedSubDirectoryPath(recording->Directory());
+ if (strCurrent.empty())
+ continue;
+
+ CPVRRecordingsPath recChildPath(recParentPath);
+ recChildPath.AppendSegment(strCurrent);
+ const std::string strFilePath = recChildPath;
+
+ std::shared_ptr<CFileItem> item;
+ if (!results.Contains(strFilePath))
+ {
+ item.reset(new CFileItem(strCurrent, true));
+ item->SetPath(strFilePath);
+ item->SetLabel(strCurrent);
+ item->SetLabelPreformatted(true);
+ item->m_dateTime = recording->RecordingTimeAsLocalTime();
+ item->SetProperty("totalepisodes", 0);
+ item->SetProperty("watchedepisodes", 0);
+ item->SetProperty("unwatchedepisodes", 0);
+ item->SetProperty("sizeinbytes", UINT64_C(0));
+
+ // Assume all folders are watched, we'll change the overlay later
+ item->SetOverlayImage(CGUIListItem::ICON_OVERLAY_WATCHED, false);
+ results.Add(item);
+ }
+ else
+ {
+ item = results.Get(strFilePath);
+ if (item->m_dateTime < recording->RecordingTimeAsLocalTime())
+ item->m_dateTime = recording->RecordingTimeAsLocalTime();
+ }
+
+ item->IncrementProperty("totalepisodes", 1);
+ if (recording->GetPlayCount() == 0)
+ {
+ unwatchedFolders.insert(item);
+ item->IncrementProperty("unwatchedepisodes", 1);
+ }
+ else
+ {
+ item->IncrementProperty("watchedepisodes", 1);
+ }
+ item->SetLabel2(StringUtils::Format("{} / {}", item->GetProperty("watchedepisodes").asString(),
+ item->GetProperty("totalepisodes").asString()));
+
+ item->IncrementProperty("sizeinbytes", recording->GetSizeInBytes());
+ }
+
+ // Replace the incremental size of the recordings with a string equivalent
+ for (auto& item : results.GetList())
+ {
+ int64_t size = item->GetProperty("sizeinbytes").asInteger();
+ item->ClearProperty("sizeinbytes");
+ item->m_dwSize = size; // We'll also sort recording folders by size
+ if (size > 0)
+ item->SetProperty("recordingsize", StringUtils::SizeToString(size));
+ }
+
+ // Change the watched overlay to unwatched for folders containing unwatched entries
+ for (auto& item : unwatchedFolders)
+ item->SetOverlayImage(CGUIListItem::ICON_OVERLAY_UNWATCHED, false);
+}
+
+} // unnamed namespace
+
+bool CPVRGUIDirectory::GetRecordingsDirectory(CFileItemList& results) const
+{
+ results.SetContent("recordings");
+
+ bool bGrouped = false;
+ const std::vector<std::shared_ptr<CPVRRecording>> recordings =
+ CServiceBroker::GetPVRManager().Recordings()->GetAll();
+
+ if (m_url.HasOption("view"))
+ {
+ const std::string view = m_url.GetOption("view");
+ if (view == "grouped")
+ bGrouped = true;
+ else if (view == "flat")
+ bGrouped = false;
+ else
+ {
+ CLog::LogF(LOGERROR, "Unsupported value '{}' for url parameter 'view'", view);
+ return false;
+ }
+ }
+ else
+ {
+ bGrouped = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
+ CSettings::SETTING_PVRRECORD_GROUPRECORDINGS);
+ }
+
+ const CPVRRecordingsPath recPath(m_url.GetWithoutOptions());
+ if (recPath.IsValid())
+ {
+ // Get the directory structure if in non-flatten mode
+ // Deleted view is always flatten. So only for an active view
+ const std::string strDirectory = recPath.GetUnescapedDirectoryPath();
+ if (!recPath.IsDeleted() && bGrouped)
+ GetSubDirectories(recPath, recordings, results);
+
+ // get all files of the current directory or recursively all files starting at the current directory if in flatten mode
+ std::shared_ptr<CFileItem> item;
+ for (const auto& recording : recordings)
+ {
+ // Omit recordings not matching criteria
+ if (recording->IsDeleted() != recPath.IsDeleted() ||
+ recording->IsRadio() != recPath.IsRadio() ||
+ !IsDirectoryMember(strDirectory, recording->Directory(), bGrouped))
+ continue;
+
+ item = std::make_shared<CFileItem>(recording);
+ item->SetOverlayImage(CGUIListItem::ICON_OVERLAY_UNWATCHED, recording->GetPlayCount() > 0);
+ results.Add(item);
+ }
+ }
+
+ return recPath.IsValid();
+}
+
+bool CPVRGUIDirectory::GetSavedSearchesDirectory(bool bRadio, CFileItemList& results) const
+{
+ const std::vector<std::shared_ptr<CPVREpgSearchFilter>> searches =
+ CServiceBroker::GetPVRManager().EpgContainer().GetSavedSearches(bRadio);
+
+ for (const auto& search : searches)
+ {
+ results.Add(std::make_shared<CFileItem>(search));
+ }
+ return true;
+}
+
+bool CPVRGUIDirectory::GetChannelGroupsDirectory(bool bRadio,
+ bool bExcludeHidden,
+ CFileItemList& results)
+{
+ const CPVRChannelGroups* channelGroups =
+ CServiceBroker::GetPVRManager().ChannelGroups()->Get(bRadio);
+ if (channelGroups)
+ {
+ std::shared_ptr<CFileItem> item;
+ const std::vector<std::shared_ptr<CPVRChannelGroup>> groups =
+ channelGroups->GetMembers(bExcludeHidden);
+ for (const auto& group : groups)
+ {
+ item = std::make_shared<CFileItem>(group->GetPath(), true);
+ item->m_strTitle = group->GroupName();
+ item->SetLabel(group->GroupName());
+ results.Add(item);
+ }
+ return true;
+ }
+ return false;
+}
+
+bool CPVRGUIDirectory::GetChannelsDirectory(CFileItemList& results) const
+{
+ const CPVRChannelsPath path(m_url.GetWithoutOptions());
+ if (path.IsValid())
+ {
+ if (path.IsEmpty())
+ {
+ std::shared_ptr<CFileItem> item;
+
+ // all tv channels
+ item.reset(new CFileItem(CPVRChannelsPath::PATH_TV_CHANNELS, true));
+ item->SetLabel(g_localizeStrings.Get(19020)); // TV
+ item->SetLabelPreformatted(true);
+ results.Add(item);
+
+ // all radio channels
+ item.reset(new CFileItem(CPVRChannelsPath::PATH_RADIO_CHANNELS, true));
+ item->SetLabel(g_localizeStrings.Get(19021)); // Radio
+ item->SetLabelPreformatted(true);
+ results.Add(item);
+
+ return true;
+ }
+ else if (path.IsChannelsRoot())
+ {
+ return GetChannelGroupsDirectory(path.IsRadio(), true, results);
+ }
+ else if (path.IsChannelGroup())
+ {
+ const std::string& strGroupName = path.GetGroupName();
+ bool bShowHiddenChannels = path.IsHiddenChannelGroup();
+
+ std::shared_ptr<CPVRChannelGroup> group;
+ if (bShowHiddenChannels || strGroupName == "*") // all channels
+ {
+ group = CServiceBroker::GetPVRManager().ChannelGroups()->GetGroupAll(path.IsRadio());
+ }
+ else
+ {
+ group = CServiceBroker::GetPVRManager()
+ .ChannelGroups()
+ ->Get(path.IsRadio())
+ ->GetByName(strGroupName);
+ }
+
+ if (group)
+ {
+ const bool playedOnly =
+ (m_url.HasOption("view") && (m_url.GetOption("view") == "lastplayed"));
+
+ const std::vector<std::shared_ptr<CPVRChannelGroupMember>> groupMembers =
+ group->GetMembers();
+ for (const auto& groupMember : groupMembers)
+ {
+ if (bShowHiddenChannels != groupMember->Channel()->IsHidden())
+ continue;
+
+ if (playedOnly && !groupMember->Channel()->LastWatched())
+ continue;
+
+ results.Add(std::make_shared<CFileItem>(groupMember));
+ }
+ }
+ else
+ {
+ CLog::LogF(LOGERROR, "Unable to obtain members of channel group '{}'", strGroupName);
+ return false;
+ }
+
+ return true;
+ }
+ }
+ return false;
+}
+
+namespace
+{
+
+bool GetTimersRootDirectory(const CPVRTimersPath& path,
+ bool bHideDisabled,
+ const std::vector<std::shared_ptr<CPVRTimerInfoTag>>& timers,
+ CFileItemList& results)
+{
+ bool bRadio = path.IsRadio();
+ bool bRules = path.IsRules();
+
+ for (const auto& timer : timers)
+ {
+ if ((bRadio == timer->IsRadio() ||
+ (bRules && timer->ClientChannelUID() == PVR_TIMER_ANY_CHANNEL)) &&
+ (bRules == timer->IsTimerRule()) && (!bHideDisabled || !timer->IsDisabled()))
+ {
+ const auto item = std::make_shared<CFileItem>(timer);
+ const CPVRTimersPath timersPath(path.GetPath(), timer->ClientID(), timer->ClientIndex());
+ item->SetPath(timersPath.GetPath());
+ results.Add(item);
+ }
+ }
+ return true;
+}
+
+bool GetTimersSubDirectory(const CPVRTimersPath& path,
+ bool bHideDisabled,
+ const std::vector<std::shared_ptr<CPVRTimerInfoTag>>& timers,
+ CFileItemList& results)
+{
+ bool bRadio = path.IsRadio();
+ int iParentId = path.GetParentId();
+ int iClientId = path.GetClientId();
+
+ std::shared_ptr<CFileItem> item;
+
+ for (const auto& timer : timers)
+ {
+ if ((timer->IsRadio() == bRadio) && timer->HasParent() && (timer->ClientID() == iClientId) &&
+ (timer->ParentClientIndex() == iParentId) && (!bHideDisabled || !timer->IsDisabled()))
+ {
+ item.reset(new CFileItem(timer));
+ const CPVRTimersPath timersPath(path.GetPath(), timer->ClientID(), timer->ClientIndex());
+ item->SetPath(timersPath.GetPath());
+ results.Add(item);
+ }
+ }
+ return true;
+}
+
+} // unnamed namespace
+
+bool CPVRGUIDirectory::GetTimersDirectory(CFileItemList& results) const
+{
+ const CPVRTimersPath path(m_url.GetWithoutOptions());
+ if (path.IsValid() && (path.IsTimersRoot() || path.IsTimerRule()))
+ {
+ bool bHideDisabled = false;
+ if (m_url.HasOption("view"))
+ {
+ const std::string view = m_url.GetOption("view");
+ if (view == "hidedisabled")
+ {
+ bHideDisabled = true;
+ }
+ else
+ {
+ CLog::LogF(LOGERROR, "Unsupported value '{}' for url parameter 'view'", view);
+ return false;
+ }
+ }
+ else
+ {
+ bHideDisabled = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
+ CSettings::SETTING_PVRTIMERS_HIDEDISABLEDTIMERS);
+ }
+
+ const std::vector<std::shared_ptr<CPVRTimerInfoTag>> timers =
+ CServiceBroker::GetPVRManager().Timers()->GetAll();
+
+ if (path.IsTimersRoot())
+ {
+ /* Root folder containing either timer rules or timers. */
+ return GetTimersRootDirectory(path, bHideDisabled, timers, results);
+ }
+ else if (path.IsTimerRule())
+ {
+ /* Sub folder containing the timers scheduled by the given timer rule. */
+ return GetTimersSubDirectory(path, bHideDisabled, timers, results);
+ }
+ }
+
+ return false;
+}
diff --git a/xbmc/pvr/filesystem/PVRGUIDirectory.h b/xbmc/pvr/filesystem/PVRGUIDirectory.h
new file mode 100644
index 0000000..462c553
--- /dev/null
+++ b/xbmc/pvr/filesystem/PVRGUIDirectory.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2012-2019 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 "URL.h"
+
+#include <string>
+
+class CFileItemList;
+
+namespace PVR
+{
+
+class CPVRGUIDirectory
+{
+public:
+ /*!
+ * @brief PVR GUI directory ctor.
+ * @param url The directory's URL.
+ */
+ explicit CPVRGUIDirectory(const CURL& url) : m_url(url) {}
+
+ /*!
+ * @brief PVR GUI directory ctor.
+ * @param path The directory's path.
+ */
+ explicit CPVRGUIDirectory(const std::string& path) : m_url(path) {}
+
+ /*!
+ * @brief PVR GUI directory dtor.
+ */
+ virtual ~CPVRGUIDirectory() = default;
+
+ /*!
+ * @brief Check existence of this directory.
+ * @return True if the directory exists, false otherwise.
+ */
+ bool Exists() const;
+
+ /*!
+ * @brief Obtain the directory listing.
+ * @param results The list to fill with the results.
+ * @return True on success, false otherwise.
+ */
+ bool GetDirectory(CFileItemList& results) const;
+
+ /*!
+ * @brief Check if this directory supports file write operations.
+ * @return True if the directory supports file write operations, false otherwise.
+ */
+ bool SupportsWriteFileOperations() const;
+
+ /*!
+ * @brief Check if any TV recordings are existing.
+ * @return True if TV recordings exists, false otherwise.
+ */
+ static bool HasTVRecordings();
+
+ /*!
+ * @brief Check if any deleted TV recordings are existing.
+ * @return True if deleted TV recordings exists, false otherwise.
+ */
+ static bool HasDeletedTVRecordings();
+
+ /*!
+ * @brief Check if any radio recordings are existing.
+ * @return True if radio recordings exists, false otherwise.
+ */
+ static bool HasRadioRecordings();
+
+ /*!
+ * @brief Check if any deleted radio recordings are existing.
+ * @return True if deleted radio recordings exists, false otherwise.
+ */
+ static bool HasDeletedRadioRecordings();
+
+ /*!
+ * @brief Get the list of channel groups.
+ * @param bRadio If true, obtain radio groups, tv groups otherwise.
+ * @param bExcludeHidden If true exclude hidden groups, include hidden groups otherwise.
+ * @param results The file list to store the results in.
+ * @return True on success, false otherwise..
+ */
+ static bool GetChannelGroupsDirectory(bool bRadio, bool bExcludeHidden, CFileItemList& results);
+
+ /*!
+ * @brief Get the list of channels.
+ * @param results The file list to store the results in.
+ * @return True on success, false otherwise..
+ */
+ bool GetChannelsDirectory(CFileItemList& results) const;
+
+private:
+ bool GetTimersDirectory(CFileItemList& results) const;
+ bool GetRecordingsDirectory(CFileItemList& results) const;
+ bool GetSavedSearchesDirectory(bool bRadio, CFileItemList& results) const;
+
+ const CURL m_url;
+};
+
+} // namespace PVR
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-21 09:52:45 +0000