bool CPVRClients::SwitchChannel(const CPVRChannelPtr &channel)
{
assert(channel.get());
{
CSingleLock lock(m_critSection);
if (m_bIsSwitchingChannels)
{
CLog::Log(LOGDEBUG, "PVRClients - %s - can't switch to channel '%s'. waiting for the previous switch to complete", __FUNCTION__, channel->ChannelName().c_str());
return false;
}
m_bIsSwitchingChannels = true;
}
bool bSwitchSuccessful(false);
CPVRChannelPtr currentChannel(GetPlayingChannel());
if (// no channel is currently playing
!currentChannel ||
// different backend
currentChannel->ClientID() != channel->ClientID() ||
// stream URL should always be opened as a new file
!channel->StreamURL().empty() || !currentChannel->StreamURL().empty())
{
if (channel->StreamURL().empty())
{
CloseStream();
bSwitchSuccessful = OpenStream(channel, true);
}
else
{
CApplicationMessenger::GetInstance().PostMsg(TMSG_MEDIA_PLAY, 0, 0, static_cast<void*>(new CFileItem(channel)));
bSwitchSuccessful = true;
}
}
// same channel
else if (currentChannel && currentChannel == channel)
{
bSwitchSuccessful = true;
}
else
{
PVR_CLIENT client;
if (GetConnectedClient(channel->ClientID(), client))
bSwitchSuccessful = client->SwitchChannel(channel);
}
{
CSingleLock lock(m_critSection);
m_bIsSwitchingChannels = false;
}
if (!bSwitchSuccessful)
CLog::Log(LOGERROR, "PVR - %s - cannot switch to channel '%s' on client '%d'",__FUNCTION__, channel->ChannelName().c_str(), channel->ClientID());
return bSwitchSuccessful;
}
PVR_ERROR CPVRClients::GetEPGForChannel(const CPVRChannelPtr &channel, CEpg *epg, time_t start, time_t end)
{
assert(channel.get());
PVR_ERROR error(PVR_ERROR_UNKNOWN);
PVR_CLIENT client;
if (GetConnectedClient(channel->ClientID(), client))
error = client->GetEPGForChannel(channel, epg, start, end);
if (error != PVR_ERROR_NO_ERROR)
CLog::Log(LOGERROR, "PVR - %s - cannot get EPG for channel '%s' from client '%d': %s",__FUNCTION__, channel->ChannelName().c_str(), channel->ClientID(), CPVRClient::ToString(error));
return error;
}
bool CEpg::UpdateFromScraper(time_t start, time_t end)
{
bool bGrabSuccess = false;
if (ScraperName() == "client")
{
CPVRChannelPtr channel = Channel();
if (!channel)
{
CLog::Log(LOGWARNING, "EPG - %s - channel not found, can't update", __FUNCTION__);
}
else if (!channel->EPGEnabled())
{
#if EPG_DEBUGGING
CLog::Log(LOGDEBUG, "EPG - %s - EPG updating disabled in the channel configuration", __FUNCTION__);
#endif
bGrabSuccess = true;
}
else if (channel->IsHidden())
{
#if EPG_DEBUGGING
CLog::Log(LOGDEBUG, "EPG - %s - channel '%s' on client '%i' is hidden", __FUNCTION__, channel->ChannelName().c_str(), channel->ClientID());
#endif
bGrabSuccess = true;
}
else if (!g_PVRClients->SupportsEPG(channel->ClientID()))
{
CLog::Log(LOGDEBUG, "EPG - %s - the backend for channel '%s' on client '%i' does not support EPGs", __FUNCTION__, channel->ChannelName().c_str(), channel->ClientID());
}
else
{
CLog::Log(LOGDEBUG, "EPG - %s - updating EPG for channel '%s' from client '%i'", __FUNCTION__, channel->ChannelName().c_str(), channel->ClientID());
bGrabSuccess = (g_PVRClients->GetEPGForChannel(channel, this, start, end) == PVR_ERROR_NO_ERROR);
}
}
else if (m_strScraperName.empty()) /* no grabber defined */
CLog::Log(LOGWARNING, "EPG - %s - no EPG scraper defined for table '%s'", __FUNCTION__, m_strName.c_str());
else
{
CLog::Log(LOGINFO, "EPG - %s - updating EPG table '%s' with scraper '%s'", __FUNCTION__, m_strName.c_str(), m_strScraperName.c_str());
CLog::Log(LOGWARNING, "loading the EPG via scraper has not been implemented yet");
//! @todo Add Support for Web EPG Scrapers here
}
return bGrabSuccess;
}
void CGUIDialogPVRChannelManager::Update()
{
// lock our display, as this window is rendered from the player thread
g_graphicsContext.Lock();
m_viewControl.SetCurrentView(CONTROL_LIST_CHANNELS);
// empty the lists ready for population
Clear();
CPVRChannelGroupPtr channels = g_PVRChannelGroups->GetGroupAll(m_bIsRadio);
// No channels available, nothing to do.
if(!channels)
return;
std::vector<PVRChannelGroupMember> groupMembers(channels->GetMembers());
CFileItemPtr channelFile;
for (std::vector<PVRChannelGroupMember>::const_iterator it = groupMembers.begin(); it != groupMembers.end(); ++it)
{
channelFile = CFileItemPtr(new CFileItem((*it).channel));
if (!channelFile || !channelFile->HasPVRChannelInfoTag())
continue;
const CPVRChannelPtr channel(channelFile->GetPVRChannelInfoTag());
channelFile->SetProperty("ActiveChannel", !channel->IsHidden());
channelFile->SetProperty("Name", channel->ChannelName());
channelFile->SetProperty("UseEPG", channel->EPGEnabled());
channelFile->SetProperty("Icon", channel->IconPath());
channelFile->SetProperty("EPGSource", (int)0);
channelFile->SetProperty("ParentalLocked", channel->IsLocked());
channelFile->SetProperty("Number", StringUtils::Format("%i", channel->ChannelNumber()));
std::string clientName;
g_PVRClients->GetClientName(channel->ClientID(), clientName);
channelFile->SetProperty("ClientName", clientName);
channelFile->SetProperty("SupportsSettings", g_PVRClients->SupportsChannelSettings(channel->ClientID()));
m_channelItems->Add(channelFile);
}
{
std::vector< std::pair<std::string, int> > labels;
labels.push_back(std::make_pair(g_localizeStrings.Get(19210), 0));
/// TODO: Add Labels for EPG scrapers here
SET_CONTROL_LABELS(SPIN_EPGSOURCE_SELECTION, 0, &labels);
}
m_clientsWithSettingsList = g_PVRClients->GetClientsSupportingChannelSettings(m_bIsRadio);
if (!m_clientsWithSettingsList.empty())
m_bAllowNewChannel = true;
if (m_bAllowNewChannel)
SET_CONTROL_VISIBLE(BUTTON_NEW_CHANNEL);
else
SET_CONTROL_HIDDEN(BUTTON_NEW_CHANNEL);
Renumber();
m_viewControl.SetItems(*m_channelItems);
m_viewControl.SetSelectedItem(m_iSelected);
g_graphicsContext.Unlock();
}
bool CPVRGUIActions::SwitchToChannel(const CFileItemPtr &item, bool bPlayMinimized, bool bCheckResume) const
{
if (item->m_bIsFolder)
return false;
const CPVRChannelPtr channel(CPVRItem(item).GetChannel());
if ((channel && g_PVRManager.IsPlayingChannel(channel)) ||
(channel && channel->HasRecording() && g_PVRManager.IsPlayingRecording(channel->GetRecording())))
{
CGUIMessage msg(GUI_MSG_FULLSCREEN, 0, g_windowManager.GetActiveWindow());
g_windowManager.SendMessage(msg);
return true;
}
CMediaSettings::GetInstance().SetVideoStartWindowed(bPlayMinimized);
// switch to channel or if recording present, ask whether to switch or play recording...
bool bSwitchSuccessful(false);
if (channel && g_PVRManager.CheckParentalLock(channel))
{
const CPVRRecordingPtr recording(channel->GetRecording());
if (recording)
{
bool bCancel(false);
bool bPlayRecording = CGUIDialogYesNo::ShowAndGetInput(CVariant{19687}, // "Play recording"
CVariant{""},
CVariant{12021}, // "Play from beginning"
CVariant{recording->m_strTitle},
bCancel,
CVariant{19000}, // "Switch to channel"
CVariant{19687}, // "Play recording"
0); // no autoclose
if (bCancel)
return false;
if (bPlayRecording)
{
const CFileItemPtr recordingItem(new CFileItem(recording));
return PlayRecording(recordingItem, CSettings::GetInstance().GetBool(CSettings::SETTING_PVRPLAYBACK_PLAYMINIMIZED), bCheckResume);
}
}
/* try a fast switch */
if ((g_PVRManager.IsPlayingTV() || g_PVRManager.IsPlayingRadio()) &&
(channel->IsRadio() == g_PVRManager.IsPlayingRadio()))
{
if (channel->StreamURL().empty())
bSwitchSuccessful = g_application.m_pPlayer->SwitchChannel(channel);
}
if (!bSwitchSuccessful)
{
CApplicationMessenger::GetInstance().PostMsg(TMSG_MEDIA_PLAY, 0, 0, static_cast<void*>(new CFileItem(channel)));
return true;
}
}
if (!bSwitchSuccessful)
{
std::string channelName = g_localizeStrings.Get(19029); // Channel
if (channel)
channelName = channel->ChannelName();
std::string msg = StringUtils::Format(g_localizeStrings.Get(19035).c_str(), channelName.c_str()); // CHANNELNAME could not be played. Check the log for details.
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(19166), msg); // PVR information
return false;
}
return true;
}
bool CGUIWindowFullScreen::OnMessage(CGUIMessage& message)
{
switch (message.GetMessage())
{
case GUI_MSG_WINDOW_INIT:
{
// check whether we've come back here from a window during which time we've actually
// stopped playing videos
if (message.GetParam1() == WINDOW_INVALID && !g_application.m_pPlayer->IsPlayingVideo())
{ // why are we here if nothing is playing???
g_windowManager.PreviousWindow();
return true;
}
g_infoManager.SetShowInfo(false);
g_infoManager.SetShowCodec(false);
m_bShowCurrentTime = false;
m_bGroupSelectShow = false;
g_infoManager.SetDisplayAfterSeek(0); // Make sure display after seek is off.
// switch resolution
g_graphicsContext.SetFullScreenVideo(true);
#ifdef HAS_VIDEO_PLAYBACK
// make sure renderer is uptospeed
g_renderManager.Update();
#endif
// now call the base class to load our windows
CGUIWindow::OnMessage(message);
m_bShowViewModeInfo = false;
return true;
}
case GUI_MSG_WINDOW_DEINIT:
{
CGUIDialog *pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_OSD_TELETEXT);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_SLIDER);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_VIDEO_OSD);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_FULLSCREEN_INFO);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_CHANNELS);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_GUIDE);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_DIRECTOR);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_CUTTER);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_SUBTITLES);
if (pDialog) pDialog->Close(true);
CGUIWindow::OnMessage(message);
CSettings::Get().Save();
CSingleLock lock (g_graphicsContext);
g_graphicsContext.SetFullScreenVideo(false);
lock.Leave();
#ifdef HAS_VIDEO_PLAYBACK
// make sure renderer is uptospeed
g_renderManager.Update();
#endif
return true;
}
case GUI_MSG_CLICKED:
{
unsigned int iControl = message.GetSenderId();
if (iControl == CONTROL_GROUP_CHOOSER && g_PVRManager.IsStarted())
{
// Get the currently selected label of the Select button
CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), iControl);
OnMessage(msg);
CStdString strLabel = msg.GetLabel();
CPVRChannelPtr playingChannel;
if (g_PVRManager.GetCurrentChannel(playingChannel))
{
CPVRChannelGroupPtr selectedGroup = g_PVRChannelGroups->Get(playingChannel->IsRadio())->GetByName(strLabel);
if (selectedGroup)
{
g_PVRManager.SetPlayingGroup(selectedGroup);
CLog::Log(LOGDEBUG, "%s - switched to group '%s'", __FUNCTION__, selectedGroup->GroupName().c_str());
if (!selectedGroup->IsGroupMember(*playingChannel))
{
CLog::Log(LOGDEBUG, "%s - channel '%s' is not a member of '%s', switching to channel 1 of the new group",
__FUNCTION__, playingChannel->ChannelName().c_str(), selectedGroup->GroupName().c_str());
CFileItemPtr switchChannel = selectedGroup->GetByChannelNumber(1);
if (switchChannel && switchChannel->HasPVRChannelInfoTag())
g_application.OnAction(CAction(ACTION_CHANNEL_SWITCH, (float) switchChannel->GetPVRChannelInfoTag()->ChannelNumber()));
else
{
CLog::Log(LOGERROR, "%s - cannot find channel '1' in group %s", __FUNCTION__, selectedGroup->GroupName().c_str());
CApplicationMessenger::Get().MediaStop(false);
}
}
}
else
{
CLog::Log(LOGERROR, "%s - could not switch to group '%s'", __FUNCTION__, selectedGroup->GroupName().c_str());
CApplicationMessenger::Get().MediaStop(false);
}
}
else
{
CLog::Log(LOGERROR, "%s - cannot find the current channel", __FUNCTION__);
CApplicationMessenger::Get().MediaStop(false);
}
// hide the control and reset focus
m_bGroupSelectShow = false;
SET_CONTROL_HIDDEN(CONTROL_GROUP_CHOOSER);
// SET_CONTROL_FOCUS(0, 0);
return true;
}
break;
}
case GUI_MSG_SETFOCUS:
case GUI_MSG_LOSTFOCUS:
if (message.GetSenderId() != WINDOW_FULLSCREEN_VIDEO) return true;
break;
}
return CGUIWindow::OnMessage(message);
}
bool CPVRManager::CheckParentalLock(const CPVRChannelPtr &channel)
{
bool bReturn = !IsParentalLocked(channel) ||
CheckParentalPIN();
if (!bReturn)
CLog::Log(LOGERROR, "PVRManager - %s - parental lock verification failed for channel '%s': wrong PIN entered.", __FUNCTION__, channel->ChannelName().c_str());
return bReturn;
}
void CPVRChannelGroup::SearchAndSetChannelIcons(bool bUpdateDb /* = false */)
{
std::string iconPath = CSettings::GetInstance().GetString(CSettings::SETTING_PVRMENU_ICONPATH);
if (iconPath.empty())
return;
CPVRDatabase *database = GetPVRDatabase();
if (!database)
return;
/* fetch files in icon path for fast lookup */
CFileItemList fileItemList;
XFILE::CDirectory::GetDirectory(iconPath, fileItemList, ".jpg|.png|.tbn");
if (fileItemList.IsEmpty())
return;
CGUIDialogExtendedProgressBar* dlgProgress = (CGUIDialogExtendedProgressBar*)g_windowManager.GetWindow(WINDOW_DIALOG_EXT_PROGRESS);
CGUIDialogProgressBarHandle* dlgProgressHandle = dlgProgress ? dlgProgress->GetHandle(g_localizeStrings.Get(19287)) : NULL;
CSingleLock lock(m_critSection);
/* create a map for fast lookup of normalized file base name */
std::map<std::string, std::string> fileItemMap;
const VECFILEITEMS &items = fileItemList.GetList();
for(VECFILEITEMS::const_iterator it = items.begin(); it != items.end(); ++it)
{
std::string baseName = URIUtils::GetFileName((*it)->GetPath());
URIUtils::RemoveExtension(baseName);
StringUtils::ToLower(baseName);
fileItemMap.insert(std::make_pair(baseName, (*it)->GetPath()));
}
int channelIndex = 0;
CPVRChannelPtr channel;
for(PVR_CHANNEL_GROUP_MEMBERS::const_iterator it = m_members.begin(); it != m_members.end(); ++it)
{
channel = it->second.channel;
/* update progress dialog */
if (dlgProgressHandle)
{
dlgProgressHandle->SetProgress(channelIndex++, m_members.size());
dlgProgressHandle->SetText(channel->ChannelName());
}
/* skip if an icon is already set and exists */
if (channel->IsIconExists())
continue;
/* reset icon before searching for a new one */
channel->SetIconPath("");
std::string strChannelUid = StringUtils::Format("%08d", channel->UniqueID());
std::string strLegalClientChannelName = CUtil::MakeLegalFileName(channel->ClientChannelName());
StringUtils::ToLower(strLegalClientChannelName);
std::string strLegalChannelName = CUtil::MakeLegalFileName(channel->ChannelName());
StringUtils::ToLower(strLegalChannelName);
std::map<std::string, std::string>::iterator itItem;
if ((itItem = fileItemMap.find(strLegalClientChannelName)) != fileItemMap.end() ||
(itItem = fileItemMap.find(strLegalChannelName)) != fileItemMap.end() ||
(itItem = fileItemMap.find(strChannelUid)) != fileItemMap.end())
{
channel->SetIconPath(itItem->second, g_advancedSettings.m_bPVRAutoScanIconsUserSet);
}
if (bUpdateDb)
channel->Persist();
/* TODO: start channel icon scraper here if nothing was found */
}
if (dlgProgressHandle)
dlgProgressHandle->MarkFinished();
}
CPVRTimerInfoTagPtr CPVRTimerInfoTag::CreateFromEpg(const CEpgInfoTagPtr &tag, bool bRepeating /* = false */)
{
/* create a new timer */
CPVRTimerInfoTagPtr newTag(new CPVRTimerInfoTag());
/* check if a valid channel is set */
CPVRChannelPtr channel = tag->ChannelTag();
if (!channel)
{
CLog::Log(LOGERROR, "%s - no channel set", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
/* check if the epg end date is in the future */
if (tag->EndAsLocalTime() < CDateTime::GetCurrentDateTime())
{
CLog::Log(LOGERROR, "%s - end time is in the past", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
/* set the timer data */
CDateTime newStart = tag->StartAsUTC();
CDateTime newEnd = tag->EndAsUTC();
newTag->m_iClientIndex = -1;
newTag->m_iParentClientIndex = PVR_TIMER_NO_PARENT;
newTag->m_strTitle = tag->Title().empty() ? channel->ChannelName() : tag->Title();
newTag->m_iChannelNumber = channel->ChannelNumber();
newTag->m_iClientChannelUid = channel->UniqueID();
newTag->m_iClientId = channel->ClientID();
newTag->m_bIsRadio = channel->IsRadio();
newTag->m_iGenreType = tag->GenreType();
newTag->m_iGenreSubType = tag->GenreSubType();
newTag->m_channel = channel;
newTag->SetStartFromUTC(newStart);
newTag->SetEndFromUTC(newEnd);
CPVRTimerTypePtr timerType;
if (bRepeating)
{
// create repeating epg-based timer
timerType = CPVRTimerType::CreateFromAttributes(
PVR_TIMER_TYPE_IS_REPEATING,
PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES, channel->ClientID());
}
if (!timerType)
{
// create one-shot epg-based timer
timerType = CPVRTimerType::CreateFromAttributes(
PVR_TIMER_TYPE_ATTRIBUTE_NONE,
PVR_TIMER_TYPE_IS_REPEATING | PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES, channel->ClientID());
}
if (!timerType)
{
CLog::Log(LOGERROR, "%s - unable to create any epg-based timer type", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
newTag->SetTimerType(timerType);
newTag->UpdateSummary();
newTag->m_epgTag = g_EpgContainer.GetById(tag->EpgID())->GetTag(tag->StartAsUTC());
/* unused only for reference */
newTag->m_strFileNameAndPath = CPVRTimersPath::PATH_NEW;
return newTag;
}
bool CPVRManager::PerformChannelSwitch(const CPVRChannelPtr &channel, bool bPreview)
{
assert(channel.get());
// check parental lock state
if (IsParentalLocked(channel))
return false;
// invalid channel
if (channel->ClientID() < 0)
return false;
// check whether we're waiting for a previous switch to complete
{
CSingleLock lock(m_critSection);
if (m_bIsSwitchingChannels)
{
CLog::Log(LOGDEBUG, "PVRManager - %s - can't switch to channel '%s'. waiting for the previous switch to complete",
__FUNCTION__, channel->ChannelName().c_str());
return false;
}
// no need to do anything except switching m_currentFile
if (bPreview)
{
delete m_currentFile;
m_currentFile = new CFileItem(channel);
return true;
}
m_bIsSwitchingChannels = true;
}
CLog::Log(LOGDEBUG, "PVRManager - %s - switching to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
// will be deleted by CPVRChannelSwitchJob::DoWork()
CFileItem* previousFile = m_currentFile;
m_currentFile = NULL;
bool bSwitched(false);
// switch channel
if (!m_addons->SwitchChannel(channel))
{
// switch failed
CSingleLock lock(m_critSection);
m_bIsSwitchingChannels = false;
CLog::Log(LOGERROR, "PVRManager - %s - failed to switch to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
std::string msg = StringUtils::Format(g_localizeStrings.Get(19035).c_str(), channel->ChannelName().c_str()); // CHANNELNAME could not be played. Check the log for details.
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error,
g_localizeStrings.Get(19166), // PVR information
msg);
}
else
{
// switch successful
bSwitched = true;
// save previous and load new channel's settings (view mode is updated in
// the player)
g_application.SaveFileState();
g_application.LoadVideoSettings(channel);
// set channel as selected item
CGUIWindowPVRBase::SetSelectedItemPath(channel->IsRadio(), channel->Path());
UpdateLastWatched(channel);
CSingleLock lock(m_critSection);
m_currentFile = new CFileItem(channel);
m_bIsSwitchingChannels = false;
CLog::Log(LOGNOTICE, "PVRManager - %s - switched to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
}
// announce OnStop and OnPlay. yes, this ain't pretty
{
CSingleLock lock(m_critSectionTriggers);
m_pendingUpdates.push_back(new CPVRChannelSwitchJob(previousFile, m_currentFile));
}
m_triggerEvent.Set();
return bSwitched;
}
void CPVRChannelGroup::SearchAndSetChannelIcons(bool bUpdateDb /* = false */)
{
std::string iconPath = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_PVRMENU_ICONPATH);
if (iconPath.empty())
return;
/* fetch files in icon path for fast lookup */
CFileItemList fileItemList;
XFILE::CDirectory::GetDirectory(iconPath, fileItemList, ".jpg|.png|.tbn", XFILE::DIR_FLAG_DEFAULTS);
if (fileItemList.IsEmpty())
return;
CSingleLock lock(m_critSection);
/* create a map for fast lookup of normalized file base name */
std::map<std::string, std::string> fileItemMap;
for (const auto& item : fileItemList)
{
std::string baseName = URIUtils::GetFileName(item->GetPath());
URIUtils::RemoveExtension(baseName);
StringUtils::ToLower(baseName);
fileItemMap.insert(std::make_pair(baseName, item->GetPath()));
}
CPVRGUIProgressHandler* progressHandler = new CPVRGUIProgressHandler(g_localizeStrings.Get(19286)); // Searching for channel icons
int channelIndex = 0;
CPVRChannelPtr channel;
for(PVR_CHANNEL_GROUP_MEMBERS::const_iterator it = m_members.begin(); it != m_members.end(); ++it)
{
channel = it->second.channel;
/* update progress dialog */
progressHandler->UpdateProgress(channel->ChannelName(), channelIndex++, m_members.size());
/* skip if an icon is already set and exists */
if (channel->IsIconExists())
continue;
/* reset icon before searching for a new one */
channel->SetIconPath("");
std::string strChannelUid = StringUtils::Format("%08d", channel->UniqueID());
std::string strLegalClientChannelName = CUtil::MakeLegalFileName(channel->ClientChannelName());
StringUtils::ToLower(strLegalClientChannelName);
std::string strLegalChannelName = CUtil::MakeLegalFileName(channel->ChannelName());
StringUtils::ToLower(strLegalChannelName);
std::map<std::string, std::string>::iterator itItem;
if ((itItem = fileItemMap.find(strLegalClientChannelName)) != fileItemMap.end() ||
(itItem = fileItemMap.find(strLegalChannelName)) != fileItemMap.end() ||
(itItem = fileItemMap.find(strChannelUid)) != fileItemMap.end())
{
channel->SetIconPath(itItem->second, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bPVRAutoScanIconsUserSet);
}
if (bUpdateDb)
channel->Persist();
//! @todo start channel icon scraper here if nothing was found
}
progressHandler->DestroyProgress();
}
void CGUIDialogPVRTimerSettings::InitializeChannelsList()
{
m_channelEntries.clear();
CFileItemList channelsList;
CServiceBroker::GetPVRManager().ChannelGroups()->GetGroupAll(m_bIsRadio)->GetMembers(channelsList);
for (int i = 0; i < channelsList.Size(); ++i)
{
const CPVRChannelPtr channel(channelsList[i]->GetPVRChannelInfoTag());
std::string channelDescription(
StringUtils::Format("%s %s", channel->ChannelNumber().FormattedChannelNumber().c_str(), channel->ChannelName().c_str()));
m_channelEntries.insert(
std::make_pair(i, ChannelDescriptor(channel->UniqueID(), channel->ClientID(), channelDescription)));
}
// Add special "any channel" entry (used for epg-based timer rules).
m_channelEntries.insert(
std::make_pair(
ENTRY_ANY_CHANNEL, ChannelDescriptor(PVR_CHANNEL_INVALID_UID, 0, g_localizeStrings.Get(809))));
}
bool CPVRGUIInfo::GetListItemAndPlayerLabel(const CFileItem *item, const CGUIInfo &info, std::string &strValue) const
{
const CPVRTimerInfoTagPtr timer = item->GetPVRTimerInfoTag();
if (timer)
{
switch (info.m_info)
{
case LISTITEM_DATE:
strValue = timer->Summary();
return true;
case LISTITEM_STARTDATE:
strValue = timer->StartAsLocalTime().GetAsLocalizedDate(true);
return true;
case LISTITEM_STARTTIME:
strValue = timer->StartAsLocalTime().GetAsLocalizedTime("", false);
return true;
case LISTITEM_ENDDATE:
strValue = timer->EndAsLocalTime().GetAsLocalizedDate(true);
return true;
case LISTITEM_ENDTIME:
strValue = timer->EndAsLocalTime().GetAsLocalizedTime("", false);
return true;
case LISTITEM_TITLE:
strValue = timer->Title();
return true;
case LISTITEM_COMMENT:
strValue = timer->GetStatus();
return true;
case LISTITEM_TIMERTYPE:
strValue = timer->GetTypeAsString();
return true;
case LISTITEM_CHANNEL_NAME:
strValue = timer->ChannelName();
return true;
case LISTITEM_EPG_EVENT_TITLE:
case LISTITEM_EPG_EVENT_ICON:
case LISTITEM_GENRE:
case LISTITEM_PLOT:
case LISTITEM_PLOT_OUTLINE:
case LISTITEM_DURATION:
case LISTITEM_ORIGINALTITLE:
case LISTITEM_YEAR:
case LISTITEM_SEASON:
case LISTITEM_EPISODE:
case LISTITEM_EPISODENAME:
case LISTITEM_DIRECTOR:
case LISTITEM_CHANNEL_NUMBER:
case LISTITEM_PREMIERED:
break; // obtain value from channel/epg
default:
return false;
}
}
const CPVRRecordingPtr recording(item->GetPVRRecordingInfoTag());
if (recording)
{
// Note: CPVRRecoding is derived from CVideoInfoTag. All base class properties will be handled
// by CVideoGUIInfoProvider. Only properties introduced by CPVRRecording need to be handled here.
switch (info.m_info)
{
case LISTITEM_DATE:
strValue = recording->RecordingTimeAsLocalTime().GetAsLocalizedDateTime(false, false);
return true;
case LISTITEM_STARTDATE:
strValue = recording->RecordingTimeAsLocalTime().GetAsLocalizedDate(true);
return true;
case VIDEOPLAYER_STARTTIME:
case LISTITEM_STARTTIME:
strValue = recording->RecordingTimeAsLocalTime().GetAsLocalizedTime("", false);
return true;
case LISTITEM_ENDDATE:
strValue = recording->EndTimeAsLocalTime().GetAsLocalizedDate(true);
return true;
case VIDEOPLAYER_ENDTIME:
case LISTITEM_ENDTIME:
strValue = recording->EndTimeAsLocalTime().GetAsLocalizedTime("", false);
return true;
case LISTITEM_EXPIRATION_DATE:
if (recording->HasExpirationTime())
{
strValue = recording->ExpirationTimeAsLocalTime().GetAsLocalizedDate(false);
return true;
}
break;
case LISTITEM_EXPIRATION_TIME:
if (recording->HasExpirationTime())
{
strValue = recording->ExpirationTimeAsLocalTime().GetAsLocalizedTime("", false);;
return true;
}
break;
case VIDEOPLAYER_EPISODENAME:
case LISTITEM_EPISODENAME:
strValue = recording->EpisodeName();
return true;
case VIDEOPLAYER_CHANNEL_NAME:
case LISTITEM_CHANNEL_NAME:
strValue = recording->m_strChannelName;
return true;
case VIDEOPLAYER_CHANNEL_NUMBER:
case LISTITEM_CHANNEL_NUMBER:
{
const CPVRChannelPtr channel = recording->Channel();
if (channel)
{
strValue = channel->ChannelNumber().FormattedChannelNumber();
return true;
}
break;
}
case VIDEOPLAYER_CHANNEL_GROUP:
{
CSingleLock lock(m_critSection);
strValue = recording->IsRadio() ? m_strPlayingRadioGroup : m_strPlayingTVGroup;
return true;
}
}
return false;
}
CPVREpgInfoTagPtr epgTag;
CPVRChannelPtr channel;
if (item->IsPVRChannel() || item->IsEPG() || item->IsPVRTimer())
{
CPVRItem pvrItem(item);
channel = pvrItem.GetChannel();
switch (info.m_info)
{
case VIDEOPLAYER_NEXT_TITLE:
case VIDEOPLAYER_NEXT_GENRE:
case VIDEOPLAYER_NEXT_PLOT:
case VIDEOPLAYER_NEXT_PLOT_OUTLINE:
case VIDEOPLAYER_NEXT_STARTTIME:
case VIDEOPLAYER_NEXT_ENDTIME:
case VIDEOPLAYER_NEXT_DURATION:
case LISTITEM_NEXT_TITLE:
case LISTITEM_NEXT_GENRE:
case LISTITEM_NEXT_PLOT:
case LISTITEM_NEXT_PLOT_OUTLINE:
case LISTITEM_NEXT_STARTDATE:
case LISTITEM_NEXT_STARTTIME:
case LISTITEM_NEXT_ENDDATE:
case LISTITEM_NEXT_ENDTIME:
case LISTITEM_NEXT_DURATION:
// next playing event
epgTag = pvrItem.GetNextEpgInfoTag();
break;
default:
// now playing event
epgTag = pvrItem.GetEpgInfoTag();
break;
}
switch (info.m_info)
{
// special handling for channels without epg or with radio rds data
case PLAYER_TITLE:
case VIDEOPLAYER_TITLE:
case LISTITEM_TITLE:
case VIDEOPLAYER_NEXT_TITLE:
case LISTITEM_NEXT_TITLE:
case LISTITEM_EPG_EVENT_TITLE:
// Note: in difference to LISTITEM_TITLE, LISTITEM_EPG_EVENT_TITLE returns the title
// associated with the epg event of a timer, if any, and not the title of the timer.
if (epgTag)
strValue = epgTag->Title();
if (strValue.empty() && !CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_EPG_HIDENOINFOAVAILABLE))
strValue = g_localizeStrings.Get(19055); // no information available
return true;
}
}
if (epgTag)
{
switch (info.m_info)
{
case VIDEOPLAYER_GENRE:
case LISTITEM_GENRE:
case VIDEOPLAYER_NEXT_GENRE:
case LISTITEM_NEXT_GENRE:
strValue = epgTag->GetGenresLabel();
return true;
case VIDEOPLAYER_PLOT:
case LISTITEM_PLOT:
case VIDEOPLAYER_NEXT_PLOT:
case LISTITEM_NEXT_PLOT:
strValue = epgTag->Plot();
return true;
case VIDEOPLAYER_PLOT_OUTLINE:
case LISTITEM_PLOT_OUTLINE:
case VIDEOPLAYER_NEXT_PLOT_OUTLINE:
case LISTITEM_NEXT_PLOT_OUTLINE:
strValue = epgTag->PlotOutline();
return true;
case LISTITEM_DATE:
strValue = epgTag->StartAsLocalTime().GetAsLocalizedDateTime(false, false);
return true;
case LISTITEM_STARTDATE:
case LISTITEM_NEXT_STARTDATE:
strValue = epgTag->StartAsLocalTime().GetAsLocalizedDate(true);
return true;
case VIDEOPLAYER_STARTTIME:
case VIDEOPLAYER_NEXT_STARTTIME:
case LISTITEM_STARTTIME:
case LISTITEM_NEXT_STARTTIME:
strValue = epgTag->StartAsLocalTime().GetAsLocalizedTime("", false);
return true;
case LISTITEM_ENDDATE:
case LISTITEM_NEXT_ENDDATE:
strValue = epgTag->EndAsLocalTime().GetAsLocalizedDate(true);
return true;
case VIDEOPLAYER_ENDTIME:
case VIDEOPLAYER_NEXT_ENDTIME:
case LISTITEM_ENDTIME:
case LISTITEM_NEXT_ENDTIME:
strValue = epgTag->EndAsLocalTime().GetAsLocalizedTime("", false);
return true;
// note: for some reason, there is no VIDEOPLAYER_DURATION
case LISTITEM_DURATION:
case VIDEOPLAYER_NEXT_DURATION:
case LISTITEM_NEXT_DURATION:
if (epgTag->GetDuration() > 0)
{
strValue = StringUtils::SecondsToTimeString(epgTag->GetDuration(), static_cast<TIME_FORMAT>(info.GetData4()));
return true;
}
return false;
case VIDEOPLAYER_IMDBNUMBER:
case LISTITEM_IMDBNUMBER:
strValue = epgTag->IMDBNumber();
return true;
case VIDEOPLAYER_ORIGINALTITLE:
case LISTITEM_ORIGINALTITLE:
strValue = epgTag->OriginalTitle();
return true;
case VIDEOPLAYER_YEAR:
case LISTITEM_YEAR:
if (epgTag->Year() > 0)
{
strValue = StringUtils::Format("%i", epgTag->Year());
return true;
}
return false;
case VIDEOPLAYER_SEASON:
case LISTITEM_SEASON:
if (epgTag->SeriesNumber() > 0)
{
strValue = StringUtils::Format("%i", epgTag->SeriesNumber());
return true;
}
return false;
case VIDEOPLAYER_EPISODE:
case LISTITEM_EPISODE:
if (epgTag->EpisodeNumber() > 0)
{
if (epgTag->SeriesNumber() == 0) // prefix episode with 'S'
strValue = StringUtils::Format("S%i", epgTag->EpisodeNumber());
else
strValue = StringUtils::Format("%i", epgTag->EpisodeNumber());
return true;
}
return false;
case VIDEOPLAYER_EPISODENAME:
case LISTITEM_EPISODENAME:
strValue = epgTag->EpisodeName();
return true;
case VIDEOPLAYER_CAST:
case LISTITEM_CAST:
strValue = epgTag->GetCastLabel();
return true;
case VIDEOPLAYER_DIRECTOR:
case LISTITEM_DIRECTOR:
strValue = epgTag->GetDirectorsLabel();
return true;
case VIDEOPLAYER_WRITER:
case LISTITEM_WRITER:
strValue = epgTag->GetWritersLabel();
return true;
case LISTITEM_EPG_EVENT_ICON:
strValue = epgTag->Icon();
return true;
case VIDEOPLAYER_PARENTAL_RATING:
case LISTITEM_PARENTALRATING:
if (epgTag->ParentalRating() > 0)
{
strValue = StringUtils::Format("%i", epgTag->ParentalRating());
return true;
}
return false;
case LISTITEM_PREMIERED:
if (epgTag->FirstAiredAsLocalTime().IsValid())
{
strValue = epgTag->FirstAiredAsLocalTime().GetAsLocalizedDate(true);
return true;
}
return false;
}
}
if (channel)
{
switch (info.m_info)
{
case MUSICPLAYER_CHANNEL_NAME:
{
const std::shared_ptr<CPVRRadioRDSInfoTag> rdsTag = channel->GetRadioRDSInfoTag();
if (rdsTag)
{
strValue = rdsTag->GetProgStation();
if (!strValue.empty())
return true;
}
// fall-thru is intended
}
case VIDEOPLAYER_CHANNEL_NAME:
case LISTITEM_CHANNEL_NAME:
strValue = channel->ChannelName();
return true;
case MUSICPLAYER_CHANNEL_NUMBER:
case VIDEOPLAYER_CHANNEL_NUMBER:
case LISTITEM_CHANNEL_NUMBER:
strValue = channel->ChannelNumber().FormattedChannelNumber();
return true;
case MUSICPLAYER_CHANNEL_GROUP:
case VIDEOPLAYER_CHANNEL_GROUP:
{
CSingleLock lock(m_critSection);
strValue = channel->IsRadio() ? m_strPlayingRadioGroup : m_strPlayingTVGroup;
return true;
}
}
}
return false;
}
CPVRTimerInfoTag *CPVRTimerInfoTag::CreateFromEpg(const CEpgInfoTag &tag)
{
/* create a new timer */
CPVRTimerInfoTag *newTag = new CPVRTimerInfoTag();
if (!newTag)
{
CLog::Log(LOGERROR, "%s - couldn't create new timer", __FUNCTION__);
return NULL;
}
/* check if a valid channel is set */
CPVRChannelPtr channel = tag.ChannelTag();
if (!channel)
{
CLog::Log(LOGERROR, "%s - no channel set", __FUNCTION__);
delete newTag;
return NULL;
}
/* check if the epg end date is in the future */
if (tag.EndAsLocalTime() < CDateTime::GetCurrentDateTime())
{
CLog::Log(LOGERROR, "%s - end time is in the past", __FUNCTION__);
delete newTag;
return NULL;
}
/* set the timer data */
CDateTime newStart = tag.StartAsUTC();
CDateTime newEnd = tag.EndAsUTC();
newTag->m_iClientIndex = -1;
newTag->m_strTitle = tag.Title().empty() ? channel->ChannelName() : tag.Title();
newTag->m_iChannelNumber = channel->ChannelNumber();
newTag->m_iClientChannelUid = channel->UniqueID();
newTag->m_iClientId = channel->ClientID();
newTag->m_bIsRadio = channel->IsRadio();
newTag->m_iGenreType = tag.GenreType();
newTag->m_iGenreSubType = tag.GenreSubType();
newTag->m_channel = channel;
newTag->SetStartFromUTC(newStart);
newTag->SetEndFromUTC(newEnd);
if (tag.Plot().empty())
{
newTag->m_strSummary= StringUtils::Format("%s %s %s %s %s",
newTag->StartAsLocalTime().GetAsLocalizedDate().c_str(),
g_localizeStrings.Get(19159).c_str(),
newTag->StartAsLocalTime().GetAsLocalizedTime("", false).c_str(),
g_localizeStrings.Get(19160).c_str(),
newTag->EndAsLocalTime().GetAsLocalizedTime("", false).c_str());
}
else
{
newTag->m_strSummary = tag.Plot();
}
newTag->m_epgTag = g_EpgContainer.GetById(tag.EpgID())->GetTag(tag.StartAsUTC());
/* unused only for reference */
newTag->m_strFileNameAndPath = "pvr://timers/new";
return newTag;
}
CPVRTimerInfoTagPtr CPVRTimerInfoTag::CreateInstantTimerTag(const CPVRChannelPtr &channel, int iDuration /* = DEFAULT_PVRRECORD_INSTANTRECORDTIME */)
{
if (!channel)
{
CLog::Log(LOGERROR, "%s - no channel set", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
CEpgInfoTagPtr epgTag(channel->GetEPGNow());
CPVRTimerInfoTagPtr newTimer;
if (epgTag)
newTimer = CreateFromEpg(epgTag);
if (!newTimer)
{
newTimer.reset(new CPVRTimerInfoTag);
newTimer->m_iClientIndex = PVR_TIMER_NO_CLIENT_INDEX;
newTimer->m_iParentClientIndex = PVR_TIMER_NO_PARENT;
newTimer->m_channel = channel;
newTimer->m_strTitle = channel->ChannelName();
newTimer->m_iChannelNumber = channel->ChannelNumber();
newTimer->m_iClientChannelUid = channel->UniqueID();
newTimer->m_iClientId = channel->ClientID();
newTimer->m_bIsRadio = channel->IsRadio();
// timertype: manual one-shot timer for given client
CPVRTimerTypePtr timerType(CPVRTimerType::CreateFromAttributes(
PVR_TIMER_TYPE_IS_MANUAL, PVR_TIMER_TYPE_IS_REPEATING | PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES, channel->ClientID()));
if (!timerType)
{
CLog::Log(LOGERROR, "%s - unable to create one shot manual timer type", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
newTimer->SetTimerType(timerType);
}
/* no matter the timer was created from an epg tag, overwrite timer start and end times. */
CDateTime now(CDateTime::GetUTCDateTime());
newTimer->SetStartFromUTC(now);
if (iDuration == DEFAULT_PVRRECORD_INSTANTRECORDTIME)
iDuration = CServiceBroker::GetSettings().GetInt(CSettings::SETTING_PVRRECORD_INSTANTRECORDTIME);
CDateTime endTime = now + CDateTimeSpan(0, 0, iDuration ? iDuration : 120, 0);
newTimer->SetEndFromUTC(endTime);
/* update summary string according to instant recording start/end time */
newTimer->UpdateSummary();
newTimer->m_strSummary = StringUtils::Format(g_localizeStrings.Get(19093).c_str(), newTimer->Summary().c_str());
CDateTime startTime(INSTANT_TIMER_START);
newTimer->SetStartFromUTC(startTime);
newTimer->m_iMarginStart = 0;
newTimer->m_iMarginEnd = 0;
/* set epg tag at timer & timer at epg tag */
newTimer->UpdateEpgInfoTag();
/* unused only for reference */
newTimer->m_strFileNameAndPath = CPVRTimersPath::PATH_NEW;
return newTimer;
}
bool CGUIWindowFullScreen::OnMessage(CGUIMessage& message)
{
switch (message.GetMessage())
{
case GUI_MSG_WINDOW_INIT:
{
// check whether we've come back here from a window during which time we've actually
// stopped playing videos
if (message.GetParam1() == WINDOW_INVALID && !g_application.IsPlayingVideo())
{ // why are we here if nothing is playing???
g_windowManager.PreviousWindow();
return true;
}
g_infoManager.SetShowInfo(false);
g_infoManager.SetShowCodec(false);
m_bShowCurrentTime = false;
m_bGroupSelectShow = false;
g_infoManager.SetDisplayAfterSeek(0); // Make sure display after seek is off.
// switch resolution
g_graphicsContext.SetFullScreenVideo(true);
#ifdef HAS_VIDEO_PLAYBACK
// make sure renderer is uptospeed
g_renderManager.Update(false);
#endif
// now call the base class to load our windows
CGUIWindow::OnMessage(message);
m_bShowViewModeInfo = false;
if (CUtil::IsUsingTTFSubtitles())
{
CSingleLock lock (m_fontLock);
CStdString fontPath = "special://xbmc/media/Fonts/";
fontPath += CSettings::Get().GetString("subtitles.font");
// We scale based on PAL4x3 - this at least ensures all sizing is constant across resolutions.
RESOLUTION_INFO pal(720, 576, 0);
CGUIFont *subFont = g_fontManager.LoadTTF("__subtitle__", fontPath, color[CSettings::Get().GetInt("subtitles.color")], 0, CSettings::Get().GetInt("subtitles.height"), CSettings::Get().GetInt("subtitles.style"), false, 1.0f, 1.0f, &pal, true);
CGUIFont *borderFont = g_fontManager.LoadTTF("__subtitleborder__", fontPath, 0xFF000000, 0, CSettings::Get().GetInt("subtitles.height"), CSettings::Get().GetInt("subtitles.style"), true, 1.0f, 1.0f, &pal, true);
if (!subFont || !borderFont)
CLog::Log(LOGERROR, "CGUIWindowFullScreen::OnMessage(WINDOW_INIT) - Unable to load subtitle font");
else
m_subsLayout = new CGUITextLayout(subFont, true, 0, borderFont);
}
else
m_subsLayout = NULL;
return true;
}
case GUI_MSG_WINDOW_DEINIT:
{
CGUIDialog *pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_OSD_TELETEXT);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_SLIDER);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_VIDEO_OSD);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_FULLSCREEN_INFO);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_CHANNELS);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_GUIDE);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_DIRECTOR);
if (pDialog) pDialog->Close(true);
pDialog = (CGUIDialog *)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_OSD_CUTTER);
if (pDialog) pDialog->Close(true);
CGUIWindow::OnMessage(message);
CSettings::Get().Save();
CSingleLock lock (g_graphicsContext);
g_graphicsContext.SetFullScreenVideo(false);
lock.Leave();
#ifdef HAS_VIDEO_PLAYBACK
// make sure renderer is uptospeed
g_renderManager.Update(false);
#endif
CSingleLock lockFont(m_fontLock);
if (m_subsLayout)
{
g_fontManager.Unload("__subtitle__");
g_fontManager.Unload("__subtitleborder__");
delete m_subsLayout;
m_subsLayout = NULL;
}
return true;
}
case GUI_MSG_CLICKED:
{
unsigned int iControl = message.GetSenderId();
if (iControl == CONTROL_GROUP_CHOOSER && g_PVRManager.IsStarted())
{
// Get the currently selected label of the Select button
CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), iControl);
OnMessage(msg);
CStdString strLabel = msg.GetLabel();
CPVRChannelPtr playingChannel;
if (g_PVRManager.GetCurrentChannel(playingChannel))
{
CPVRChannelGroupPtr selectedGroup = g_PVRChannelGroups->Get(playingChannel->IsRadio())->GetByName(strLabel);
if (selectedGroup)
{
g_PVRManager.SetPlayingGroup(selectedGroup);
CLog::Log(LOGDEBUG, "%s - switched to group '%s'", __FUNCTION__, selectedGroup->GroupName().c_str());
if (!selectedGroup->IsGroupMember(*playingChannel))
{
CLog::Log(LOGDEBUG, "%s - channel '%s' is not a member of '%s', switching to channel 1 of the new group",
__FUNCTION__, playingChannel->ChannelName().c_str(), selectedGroup->GroupName().c_str());
CFileItemPtr switchChannel = selectedGroup->GetByChannelNumber(1);
if (switchChannel && switchChannel->HasPVRChannelInfoTag())
OnAction(CAction(ACTION_CHANNEL_SWITCH, (float) switchChannel->GetPVRChannelInfoTag()->ChannelNumber()));
else
{
CLog::Log(LOGERROR, "%s - cannot find channel '1' in group %s", __FUNCTION__, selectedGroup->GroupName().c_str());
CApplicationMessenger::Get().MediaStop(false);
}
}
}
else
{
CLog::Log(LOGERROR, "%s - could not switch to group '%s'", __FUNCTION__, selectedGroup->GroupName().c_str());
CApplicationMessenger::Get().MediaStop(false);
}
}
else
{
CLog::Log(LOGERROR, "%s - cannot find the current channel", __FUNCTION__);
CApplicationMessenger::Get().MediaStop(false);
}
// hide the control and reset focus
m_bGroupSelectShow = false;
SET_CONTROL_HIDDEN(CONTROL_GROUP_CHOOSER);
// SET_CONTROL_FOCUS(0, 0);
return true;
}
break;
}
case GUI_MSG_SETFOCUS:
case GUI_MSG_LOSTFOCUS:
if (message.GetSenderId() != WINDOW_FULLSCREEN_VIDEO) return true;
break;
}
return CGUIWindow::OnMessage(message);
}
CPVRTimerInfoTagPtr CPVRTimerInfoTag::CreateFromEpg(const CEpgInfoTagPtr &tag, bool bCreateRule /* = false */)
{
/* create a new timer */
CPVRTimerInfoTagPtr newTag(new CPVRTimerInfoTag());
/* check if a valid channel is set */
CPVRChannelPtr channel = tag->ChannelTag();
if (!channel)
{
CLog::Log(LOGERROR, "%s - no channel set", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
/* check if the epg end date is in the future */
if (tag->EndAsLocalTime() < CDateTime::GetCurrentDateTime() && !bCreateRule)
{
CLog::Log(LOGERROR, "%s - end time is in the past", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
/* set the timer data */
CDateTime newStart = tag->StartAsUTC();
CDateTime newEnd = tag->EndAsUTC();
newTag->m_iClientIndex = PVR_TIMER_NO_CLIENT_INDEX;
newTag->m_iParentClientIndex = PVR_TIMER_NO_PARENT;
newTag->m_strTitle = tag->Title().empty() ? channel->ChannelName() : tag->Title();
newTag->m_iChannelNumber = channel->ChannelNumber();
newTag->m_iClientChannelUid = channel->UniqueID();
newTag->m_iClientId = channel->ClientID();
newTag->m_bIsRadio = channel->IsRadio();
newTag->m_channel = channel;
newTag->m_iEpgUid = tag->UniqueBroadcastID();
newTag->SetStartFromUTC(newStart);
newTag->SetEndFromUTC(newEnd);
CPVRTimerTypePtr timerType;
if (bCreateRule)
{
// create epg-based timer rule
timerType = CPVRTimerType::CreateFromAttributes(
PVR_TIMER_TYPE_IS_REPEATING,
PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES, channel->ClientID());
if (timerType)
{
if (timerType->SupportsEpgTitleMatch())
newTag->m_strEpgSearchString = newTag->m_strTitle;
if (timerType->SupportsWeekdays())
newTag->m_iWeekdays = PVR_WEEKDAY_ALLDAYS;
if (timerType->SupportsStartAnyTime())
newTag->m_bStartAnyTime = true;
if (timerType->SupportsEndAnyTime())
newTag->m_bEndAnyTime = true;
}
}
else
{
// create one-shot epg-based timer
timerType = CPVRTimerType::CreateFromAttributes(
PVR_TIMER_TYPE_ATTRIBUTE_NONE,
PVR_TIMER_TYPE_IS_REPEATING | PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES, channel->ClientID());
}
if (!timerType)
{
CLog::Log(LOGERROR, "%s - unable to create any epg-based timer type", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
newTag->SetTimerType(timerType);
newTag->UpdateSummary();
newTag->UpdateEpgInfoTag();
/* unused only for reference */
newTag->m_strFileNameAndPath = CPVRTimersPath::PATH_NEW;
return newTag;
}
bool CGUIWindowPVRBase::PlayFile(CFileItem *item, bool bPlayMinimized /* = false */, bool bCheckResume /* = true */)
{
if (item->m_bIsFolder)
{
return false;
}
CPVRChannelPtr channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : CPVRChannelPtr();
if (item->GetPath() == g_application.CurrentFile() ||
(channel && channel->HasRecording() && channel->GetRecording()->GetPath() == g_application.CurrentFile()))
{
CGUIMessage msg(GUI_MSG_FULLSCREEN, 0, GetID());
g_windowManager.SendMessage(msg);
return true;
}
CMediaSettings::Get().SetVideoStartWindowed(bPlayMinimized);
if (item->HasPVRRecordingInfoTag())
{
return PlayRecording(item, bPlayMinimized, bCheckResume);
}
else
{
bool bSwitchSuccessful(false);
CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
if (channel && g_PVRManager.CheckParentalLock(channel))
{
CPVRRecordingPtr recording = channel->GetRecording();
if (recording)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*) g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (pDialog)
{
pDialog->SetHeading(CVariant{19687}); // Play recording
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{12021}); // Start from beginning
pDialog->SetLine(2, CVariant{recording->m_strTitle});
pDialog->Open();
if (pDialog->IsConfirmed())
{
CFileItem recordingItem(recording);
return PlayRecording(&recordingItem, CSettings::Get().GetBool("pvrplayback.playminimized"), bCheckResume);
}
}
}
/* try a fast switch */
if ((g_PVRManager.IsPlayingTV() || g_PVRManager.IsPlayingRadio()) &&
(channel->IsRadio() == g_PVRManager.IsPlayingRadio()))
{
if (channel->StreamURL().empty())
bSwitchSuccessful = g_application.m_pPlayer->SwitchChannel(channel);
}
if (!bSwitchSuccessful)
{
CApplicationMessenger::Get().PlayFile(*item, false);
return true;
}
}
if (!bSwitchSuccessful)
{
std::string channelName = g_localizeStrings.Get(19029); // Channel
if (channel)
channelName = channel->ChannelName();
std::string msg = StringUtils::Format(g_localizeStrings.Get(19035).c_str(), channelName.c_str()); // CHANNELNAME could not be played. Check the log for details.
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error,
g_localizeStrings.Get(19166), // PVR information
msg);
return false;
}
}
return true;
}
bool CPVRManager::PerformChannelSwitch(const CPVRChannelPtr &channel, bool bPreview)
{
assert(channel.get());
// check parental lock state
if (IsParentalLocked(channel))
return false;
// invalid channel
if (channel->ClientID() < 0)
return false;
// check whether we're waiting for a previous switch to complete
CFileItemPtr previousFile;
{
CSingleLock lock(m_critSection);
if (m_bIsSwitchingChannels)
{
CLog::Log(LOGDEBUG, "PVRManager - %s - can't switch to channel '%s'. waiting for the previous switch to complete",
__FUNCTION__, channel->ChannelName().c_str());
return false;
}
if (bPreview)
{
if (!g_infoManager.GetShowInfo() && m_settings.GetIntValue(CSettings::SETTING_PVRPLAYBACK_CHANNELENTRYTIMEOUT) == 0)
{
// no need to do anything
return true;
}
m_currentFile.reset(new CFileItem(channel));
if (IsPlayingChannel(channel))
m_isChannelPreview = false;
else
m_isChannelPreview = true;
return true;
}
m_bIsSwitchingChannels = true;
CLog::Log(LOGDEBUG, "PVRManager - %s - switching to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
previousFile = std::move(m_currentFile);
}
bool bSwitched(false);
// switch channel
if (!m_addons->SwitchChannel(channel))
{
// switch failed
CSingleLock lock(m_critSection);
m_bIsSwitchingChannels = false;
CLog::Log(LOGERROR, "PVRManager - %s - failed to switch to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
std::string msg = StringUtils::Format(g_localizeStrings.Get(19035).c_str(), channel->ChannelName().c_str()); // CHANNELNAME could not be played. Check the log for details.
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error,
g_localizeStrings.Get(19166), // PVR information
msg);
}
else
{
// switch successful
bSwitched = true;
// save previous and load new channel's settings (view mode is updated in
// the player)
g_application.SaveFileState();
g_application.LoadVideoSettings(channel);
// set channel as selected item
CGUIWindowPVRBase::SetSelectedItemPath(channel->IsRadio(), channel->Path());
UpdateLastWatched(channel);
CSingleLock lock(m_critSection);
m_currentFile.reset(new CFileItem(channel));
m_bIsSwitchingChannels = false;
CLog::Log(LOGNOTICE, "PVRManager - %s - switched to channel '%s'", __FUNCTION__, channel->ChannelName().c_str());
}
// announce OnStop
if (previousFile)
{
CVariant data(CVariant::VariantTypeObject);
data["end"] = true;
ANNOUNCEMENT::CAnnouncementManager::GetInstance().Announce(ANNOUNCEMENT::Player, "xbmc", "OnStop", previousFile, data);
}
// announce OnPlay
if (m_currentFile)
{
CVariant param;
param["player"]["speed"] = 1;
param["player"]["playerid"] = CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist();
ANNOUNCEMENT::CAnnouncementManager::GetInstance().Announce(ANNOUNCEMENT::Player, "xbmc", "OnPlay", m_currentFile, param);
}
return bSwitched;
}
