void CPVRTimerInfoTag::ClearEpgTag(void)
{
CEpgInfoTagPtr deletedTag;
{
CSingleLock lock(m_critSection);
deletedTag = m_epgTag;
m_epgTag.reset();
}
if (deletedTag)
deletedTag->ClearTimer();
}
int EpgSearchFilter::RemoveDuplicates(CFileItemList &results)
{
unsigned int iSize = results.Size();
for (unsigned int iResultPtr = 0; iResultPtr < iSize; iResultPtr++)
{
const CEpgInfoTagPtr epgentry_1(results.Get(iResultPtr)->GetEPGInfoTag());
if (!epgentry_1)
continue;
for (unsigned int iTagPtr = 0; iTagPtr < iSize; iTagPtr++)
{
if (iResultPtr == iTagPtr)
continue;
const CEpgInfoTagPtr epgentry_2(results.Get(iTagPtr)->GetEPGInfoTag());
if (!epgentry_2)
continue;
if (epgentry_1->Title() != epgentry_2->Title() ||
epgentry_1->Plot() != epgentry_2->Plot() ||
epgentry_1->PlotOutline() != epgentry_2->PlotOutline())
continue;
results.Remove(iTagPtr);
iResultPtr--;
iTagPtr--;
iSize--;
}
}
return iSize;
}
bool CGUIWindowPVRBase::StopRecordFile(const CFileItem &item)
{
if (!item.HasEPGInfoTag())
return false;
const CEpgInfoTagPtr tag(item.GetEPGInfoTag());
if (!tag || !tag->HasPVRChannel())
return false;
CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(&item);
if (!timer || !timer->HasPVRTimerInfoTag() || timer->GetPVRTimerInfoTag()->m_bIsRepeating)
return false;
return g_PVRTimers->DeleteTimer(*timer);
}
bool CGUIWindowPVRBase::StartRecordFile(CFileItem *item, bool bAdvanced)
{
if (!item->HasEPGInfoTag())
return false;
const CEpgInfoTagPtr tag = item->GetEPGInfoTag();
CPVRChannelPtr channel = tag->ChannelTag();
if (!channel || !g_PVRManager.CheckParentalLock(channel))
return false;
CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(item);
if (timer && timer->HasPVRTimerInfoTag())
{
CGUIDialogOK::ShowAndGetInput(CVariant{19033}, CVariant{19034});
return false;
}
bool bReturn(false);
if (bAdvanced)
{
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTag::CreateFromEpg(tag, true);
if (newTimer)
{
CFileItem *newItem = new CFileItem(newTimer);
if (ShowTimerSettings(newItem))
bReturn = g_PVRTimers->AddTimer(newItem->GetPVRTimerInfoTag());
delete newItem;
}
}
else
{
// ask for confirmation before starting a timer
if (!CGUIDialogYesNo::ShowAndGetInput(
CVariant{264} /* "Record" */, CVariant{tag->PVRChannelName()}, CVariant{""}, CVariant{tag->Title()}))
return false;
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTag::CreateFromEpg(tag);
if (newTimer)
bReturn = g_PVRTimers->AddTimer(newTimer);
}
return bReturn;
}
void CGUIDialogPVRGuideInfo::OnInitWindow()
{
CGUIDialog::OnInitWindow();
const CEpgInfoTagPtr tag(m_progItem->GetEPGInfoTag());
if (!tag)
{
/* no epg event selected */
return;
}
if (!tag->HasRecording())
{
/* not recording. hide the play recording button */
SET_CONTROL_HIDDEN(CONTROL_BTN_PLAY_RECORDING);
}
if (tag->EndAsLocalTime() <= CDateTime::GetCurrentDateTime())
{
/* event has passed. hide the record button */
SET_CONTROL_HIDDEN(CONTROL_BTN_RECORD);
return;
}
CFileItemPtr match = g_PVRTimers->GetTimerForEpgTag(m_progItem.get());
if (!match || !match->HasPVRTimerInfoTag())
{
/* no timer present on this tag */
if (tag->StartAsLocalTime() < CDateTime::GetCurrentDateTime())
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 264); // Record
else
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19061); // Add timer
}
else
{
/* timer present on this tag */
if (tag->StartAsLocalTime() < CDateTime::GetCurrentDateTime())
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19059); // Stop recording
else if (match->HasPVRTimerInfoTag() &&
match->GetPVRTimerInfoTag()->HasTimerType() &&
!match->GetPVRTimerInfoTag()->GetTimerType()->IsReadOnly())
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19060); // Delete timer
else
SET_CONTROL_HIDDEN(CONTROL_BTN_RECORD);
}
}
bool CPVRGUIActions::AddTimer(const CFileItemPtr &item, bool bCreateRule, bool bShowTimerSettings) const
{
const CPVRChannelPtr channel(CPVRItem(item).GetChannel());
if (!channel)
{
CLog::Log(LOGERROR, "CPVRGUIActions - %s - no channel!", __FUNCTION__);
return false;
}
if (!g_PVRManager.CheckParentalLock(channel))
return false;
const CEpgInfoTagPtr epgTag(CPVRItem(item).GetEpgInfoTag());
if (!epgTag && bCreateRule)
{
CLog::Log(LOGERROR, "CPVRGUIActions - %s - no epg tag!", __FUNCTION__);
return false;
}
CPVRTimerInfoTagPtr timer(bCreateRule || !epgTag ? nullptr : epgTag->Timer());
CPVRTimerInfoTagPtr rule (bCreateRule ? g_PVRTimers->GetTimerRule(timer) : nullptr);
if (timer || rule)
{
CGUIDialogOK::ShowAndGetInput(CVariant{19033}, CVariant{19034}); // "Information", "There is already a timer set for this event"
return false;
}
CPVRTimerInfoTagPtr newTimer(epgTag ? CPVRTimerInfoTag::CreateFromEpg(epgTag, bCreateRule) : CPVRTimerInfoTag::CreateInstantTimerTag(channel));
if (!newTimer)
{
CGUIDialogOK::ShowAndGetInput(CVariant{19033},
bCreateRule
? CVariant{19095} // "Information", "Timer rule creation failed. The PVR add-on does not support a suitable timer rule type."
: CVariant{19094}); // "Information", "Timer creation failed. The PVR add-on does not support a suitable timer type."
return false;
}
if (bShowTimerSettings)
{
if (!ShowTimerSettings(newTimer))
return false;
}
return g_PVRTimers->AddTimer(newTimer);
}
bool CEpg::UpdateEntry(const CEpgInfoTag &tag, bool bUpdateDatabase /* = false */, bool bSort /* = true */)
{
CEpgInfoTagPtr infoTag;
CSingleLock lock(m_critSection);
map<CDateTime, CEpgInfoTagPtr>::iterator it = m_tags.find(tag.StartAsUTC());
bool bNewTag(false);
if (it != m_tags.end())
{
infoTag = it->second;
}
else
{
/* create a new tag if no tag with this ID exists */
infoTag.reset(new CEpgInfoTag(this, m_pvrChannel, m_strName, m_pvrChannel ? m_pvrChannel->IconPath() : ""));
infoTag->SetUniqueBroadcastID(tag.UniqueBroadcastID());
m_tags.insert(make_pair(tag.StartAsUTC(), infoTag));
bNewTag = true;
}
infoTag->Update(tag, bNewTag);
infoTag->SetEpg(this);
infoTag->SetPVRChannel(m_pvrChannel);
if (bUpdateDatabase)
m_changedTags.insert(make_pair(infoTag->UniqueBroadcastID(), infoTag));
return true;
}
void CEpg::AddEntry(const CEpgInfoTag &tag)
{
CEpgInfoTagPtr newTag;
CPVRChannelPtr channel;
{
CSingleLock lock(m_critSection);
std::map<CDateTime, CEpgInfoTagPtr>::iterator itr = m_tags.find(tag.StartAsUTC());
if (itr != m_tags.end())
newTag = itr->second;
else
{
newTag.reset(new CEpgInfoTag(this, m_pvrChannel, m_strName, m_pvrChannel ? m_pvrChannel->IconPath() : ""));
m_tags.insert(make_pair(tag.StartAsUTC(), newTag));
}
channel = m_pvrChannel;
}
if (newTag)
{
newTag->Update(tag);
newTag->SetPVRChannel(channel);
newTag->SetEpg(this);
newTag->SetTimer(g_PVRTimers->GetTimerForEpgTag(newTag));
newTag->SetRecording(g_PVRRecordings->GetRecordingForEpgTag(newTag));
}
}
bool CEpg::UpdateEntry(const CEpgInfoTagPtr &tag, EPG_EVENT_STATE newState, bool bUpdateDatabase /* = false */)
{
bool bRet(true);
bool bNotify(true);
if (newState == EPG_EVENT_CREATED || newState == EPG_EVENT_UPDATED)
{
bRet = UpdateEntry(tag, bUpdateDatabase);
}
else if (newState == EPG_EVENT_DELETED)
{
CSingleLock lock(m_critSection);
auto it = m_tags.begin();
for (; it != m_tags.end(); ++it)
{
if (it->second->UniqueBroadcastID() == tag->UniqueBroadcastID())
break;
}
if (it == m_tags.end())
{
bRet = false;
}
else
{
// Respect epg linger time.
const CDateTime cleanupTime(CDateTime::GetUTCDateTime() - CDateTimeSpan(0, g_advancedSettings.m_iEpgLingerTime / 60, g_advancedSettings.m_iEpgLingerTime % 60, 0));
if (it->second->EndAsUTC() < cleanupTime)
{
if (bUpdateDatabase)
m_deletedTags.insert(std::make_pair(it->second->UniqueBroadcastID(), it->second));
it->second->ClearTimer();
it->second->ClearRecording();
m_tags.erase(it);
}
else
{
bNotify = false;
}
}
}
else
{
CLog::Log(LOGERROR, "EPG - %s - unknown epg event state value: %d", __FUNCTION__, newState);
bRet = false;
}
if (bRet && bNotify)
{
SetChanged();
NotifyObservers(ObservableMessageEpgItemUpdate);
}
return bRet;
}
bool CGUIWindowPVRBase::StopRecordFile(CFileItem *item)
{
if (!item->HasEPGInfoTag())
return false;
const CEpgInfoTagPtr tag(item->GetEPGInfoTag());
if (!tag || !tag->HasPVRChannel())
return false;
CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(item);
if (!timer || !timer->HasPVRTimerInfoTag())
return false;
bool bDeleteScheduled(false);
if (ConfirmDeleteTimer(timer.get(), bDeleteScheduled))
return g_PVRTimers->DeleteTimer(*timer, false, bDeleteScheduled);
return false;
}
void CGUIWindowPVRGuide::OnInputDone()
{
const int iChannelNumber = GetChannelNumber();
if (iChannelNumber >= 0)
{
for (const CFileItemPtr event : m_vecItems->GetList())
{
const CEpgInfoTagPtr tag(event->GetEPGInfoTag());
if (tag->HasPVRChannel() && tag->PVRChannelNumber() == iChannelNumber)
{
CGUIEPGGridContainer* epgGridContainer = dynamic_cast<CGUIEPGGridContainer*>(GetControl(m_viewControl.GetCurrentControl()));
if (epgGridContainer)
{
epgGridContainer->SetChannel(tag->ChannelTag());
return;
}
}
}
}
}
bool CEpg::InfoTagNow(CEpgInfoTag &tag, bool bUpdateIfNeeded /* = true */)
{
CSingleLock lock(m_critSection);
if (m_nowActiveStart.IsValid())
{
map<CDateTime, CEpgInfoTagPtr>::const_iterator it = m_tags.find(m_nowActiveStart);
if (it != m_tags.end() && it->second->IsActive())
{
tag = *it->second;
return true;
}
}
if (bUpdateIfNeeded)
{
CEpgInfoTagPtr lastActiveTag;
/* one of the first items will always match if the list is sorted */
for (map<CDateTime, CEpgInfoTagPtr>::const_iterator it = m_tags.begin(); it != m_tags.end(); it++)
{
if (it->second->IsActive())
{
m_nowActiveStart = it->first;
tag = *it->second;
return true;
}
else if (it->second->WasActive())
lastActiveTag = it->second;
}
/* there might be a gap between the last and next event. return the last if found and it ended not more than 5 minutes ago */
if (lastActiveTag &&
lastActiveTag->EndAsUTC() + CDateTimeSpan(0, 0, 5, 0) >= CDateTime::GetUTCDateTime())
{
tag = *lastActiveTag;
return true;
}
}
return false;
}
bool CGUIWindowPVRSearch::OnContextButton(const CFileItem &item, CONTEXT_BUTTON button)
{
bool bReturn = false;
switch(button)
{
case CONTEXT_BUTTON_FIND:
{
m_searchfilter.Reset();
// construct the search term
if (item.IsEPG())
m_searchfilter.m_strSearchTerm = "\"" + item.GetEPGInfoTag()->Title() + "\"";
else if (item.IsPVRChannel())
{
const CEpgInfoTagPtr tag(item.GetPVRChannelInfoTag()->GetEPGNow());
if (tag)
m_searchfilter.m_strSearchTerm = "\"" + tag->Title() + "\"";
}
else if (item.IsUsablePVRRecording())
m_searchfilter.m_strSearchTerm = "\"" + item.GetPVRRecordingInfoTag()->m_strTitle + "\"";
else if (item.IsPVRTimer())
{
const CPVRTimerInfoTagPtr info(item.GetPVRTimerInfoTag());
const CEpgInfoTagPtr tag(info->GetEpgInfoTag());
if (tag)
m_searchfilter.m_strSearchTerm = "\"" + tag->Title() + "\"";
else
m_searchfilter.m_strSearchTerm = "\"" + info->m_strTitle + "\"";
}
m_bSearchConfirmed = true;
Refresh(true);
bReturn = true;
break;
}
default:
bReturn = false;
}
return bReturn;
}
void CGUIWindowPVRBase::ShowEPGInfo(CFileItem *item)
{
CEpgInfoTagPtr epgTag;
CPVRChannelPtr channel;
if (item->IsEPG())
{
epgTag = item->GetEPGInfoTag();
channel = epgTag->ChannelTag();
}
else if (item->IsPVRChannel())
{
channel = item->GetPVRChannelInfoTag();
epgTag = channel->GetEPGNow();
}
else if (item->IsPVRTimer())
{
epgTag = item->GetPVRTimerInfoTag()->GetEpgInfoTag();
if (epgTag && epgTag->HasPVRChannel())
channel = epgTag->ChannelTag();
}
if (channel && !g_PVRManager.CheckParentalLock(channel))
return;
if (!epgTag)
{
CLog::Log(LOGERROR, "CGUIWindowPVRBase - %s - no epg tag!", __FUNCTION__);
return;
}
CGUIDialogPVRGuideInfo* pDlgInfo = (CGUIDialogPVRGuideInfo*)g_windowManager.GetWindow(WINDOW_DIALOG_PVR_GUIDE_INFO);
if (!pDlgInfo)
{
CLog::Log(LOGERROR, "CGUIWindowPVRBase - %s - unable to get WINDOW_DIALOG_PVR_GUIDE_INFO!", __FUNCTION__);
return;
}
pDlgInfo->SetProgInfo(epgTag);
pDlgInfo->Open();
}
void CEpg::AddEntry(const CEpgInfoTag &tag)
{
CEpgInfoTagPtr newTag;
CSingleLock lock(m_critSection);
map<CDateTime, CEpgInfoTagPtr>::iterator itr = m_tags.find(tag.StartAsUTC());
if (itr != m_tags.end())
newTag = itr->second;
else
{
newTag = CEpgInfoTagPtr(new CEpgInfoTag(this, m_pvrChannel, m_strName, m_pvrChannel ? m_pvrChannel->IconPath() : StringUtils::EmptyString));
m_tags.insert(make_pair(tag.StartAsUTC(), newTag));
}
if (newTag)
{
newTag->Update(tag);
newTag->SetPVRChannel(m_pvrChannel);
newTag->m_epg = this;
newTag->m_bChanged = false;
}
}
JSONRPC_STATUS CPVROperations::AddTimer(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
const CEpgInfoTagPtr epgTag = g_EpgContainer.GetTagById(CPVRChannelPtr(), parameterObject["broadcastid"].asUnsignedInteger());
if (!epgTag)
return InvalidParams;
if (epgTag->HasTimer())
return InvalidParams;
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTag::CreateFromEpg(epgTag, parameterObject["timerrule"].asBoolean(false));
if (newTimer)
{
if (g_PVRTimers->AddTimer(newTimer))
return ACK;
}
return FailedToExecute;
}
bool CGUIWindowPVRBase::StartRecordFile(const CFileItem &item)
{
if (!item.HasEPGInfoTag())
return false;
const CEpgInfoTagPtr tag = item.GetEPGInfoTag();
CPVRChannelPtr channel = tag->ChannelTag();
if (!channel || !g_PVRManager.CheckParentalLock(*channel))
return false;
CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(&item);
if (timer && timer->HasPVRTimerInfoTag())
{
CGUIDialogOK::ShowAndGetInput(19033,19034,0,0);
return false;
}
// ask for confirmation before starting a timer
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return false;
pDialog->SetHeading(264);
pDialog->SetLine(0, tag->PVRChannelName());
pDialog->SetLine(1, "");
pDialog->SetLine(2, tag->Title());
pDialog->DoModal();
if (!pDialog->IsConfirmed())
return false;
CPVRTimerInfoTag *newTimer = CPVRTimerInfoTag::CreateFromEpg(*tag);
bool bReturn(false);
if (newTimer)
{
bReturn = g_PVRTimers->AddTimer(*newTimer);
delete newTimer;
}
return bReturn;
}
bool CGUIDialogPVRGuideInfo::ActionStartTimer(const CEpgInfoTagPtr &tag)
{
bool bReturn = false;
if (!tag)
return false;
CPVRChannelPtr channel = tag->ChannelTag();
if (!channel || !g_PVRManager.CheckParentalLock(channel))
return false;
// prompt user for confirmation of channel record
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (pDialog)
{
pDialog->SetHeading(264);
pDialog->SetLine(0, "");
pDialog->SetLine(1, tag->Title());
pDialog->SetLine(2, "");
pDialog->DoModal();
if (pDialog->IsConfirmed())
{
Close();
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTag::CreateFromEpg(tag);
if (newTimer)
{
bReturn = CPVRTimers::AddTimer(newTimer);
}
else
{
bReturn = false;
}
}
}
return bReturn;
}
bool CGUIDialogPVRGuideInfo::OnClickButtonFind(CGUIMessage &message)
{
bool bReturn = false;
if (message.GetSenderId() == CONTROL_BTN_FIND)
{
const CEpgInfoTagPtr tag(m_progItem->GetEPGInfoTag());
if (tag && tag->HasPVRChannel())
{
int windowSearchId = tag->ChannelTag()->IsRadio() ? WINDOW_RADIO_SEARCH : WINDOW_TV_SEARCH;
CGUIWindowPVRBase *windowSearch = (CGUIWindowPVRBase*) g_windowManager.GetWindow(windowSearchId);
if (windowSearch)
{
Close();
g_windowManager.ActivateWindow(windowSearchId);
bReturn = windowSearch->OnContextButton(*m_progItem.get(), CONTEXT_BUTTON_FIND);
}
}
}
return bReturn;
}
JSONRPC_STATUS CPVROperations::ToggleTimer(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CFileItemPtr broadcast = CPVROperations::GetBroadcastFromBroadcastid(parameterObject["broadcastid"].asUnsignedInteger());
if (!broadcast)
return InvalidParams;
if (!broadcast->HasEPGInfoTag())
return InvalidParams;
CEpgInfoTagPtr epgTag = broadcast->GetEPGInfoTag();
if (!epgTag)
return InvalidParams;
bool timerrule = parameterObject["timerrule"].asBoolean(false);
bool sentOkay = false;
CPVRTimerInfoTagPtr timer(epgTag->Timer());
if (timer)
{
if (timerrule)
timer = g_PVRTimers->GetTimerRule(timer);
if (timer)
sentOkay = g_PVRTimers->DeleteTimer(timer, timer->IsRecording(), false);
}
else
{
timer = CPVRTimerInfoTag::CreateFromEpg(epgTag, timerrule);
sentOkay = g_PVRTimers->AddTimer(timer);
}
if (sentOkay)
return ACK;
return FailedToExecute;
}
CPVRChannelPtr CPVRItem::GetChannel() const
{
if (m_item->IsPVRChannel())
{
return m_item->GetPVRChannelInfoTag();
}
else if (m_item->IsEPG())
{
return m_item->GetEPGInfoTag()->ChannelTag();
}
else if (m_item->IsPVRTimer())
{
const CEpgInfoTagPtr epgTag(m_item->GetPVRTimerInfoTag()->GetEpgInfoTag());
if (epgTag)
return epgTag->ChannelTag();
}
else
{
CLog::Log(LOGERROR, "CPVRItem - %s - unsupported item type!", __FUNCTION__);
}
return CPVRChannelPtr();
}
/*!
* @brief Copy over timer info from xbmcTimer to addonTimer.
* @param xbmcTimer The timer on XBMC's side.
* @param addonTimer The timer on the addon's side.
*/
void CPVRClient::WriteClientTimerInfo(const CPVRTimerInfoTag &xbmcTimer, PVR_TIMER &addonTimer)
{
time_t start, end, firstDay;
xbmcTimer.StartAsUTC().GetAsTime(start);
xbmcTimer.EndAsUTC().GetAsTime(end);
xbmcTimer.FirstDayAsUTC().GetAsTime(firstDay);
CEpgInfoTagPtr epgTag = xbmcTimer.GetEpgInfoTag();
memset(&addonTimer, 0, sizeof(addonTimer));
addonTimer.iClientIndex = xbmcTimer.m_iClientIndex;
addonTimer.iParentClientIndex = xbmcTimer.m_iParentClientIndex;
addonTimer.state = xbmcTimer.m_state;
addonTimer.iTimerType = xbmcTimer.GetTimerType() ? xbmcTimer.GetTimerType()->GetTypeId() : PVR_TIMER_TYPE_NONE;
addonTimer.iClientChannelUid = xbmcTimer.m_iClientChannelUid;
strncpy(addonTimer.strTitle, xbmcTimer.m_strTitle.c_str(), sizeof(addonTimer.strTitle) - 1);
strncpy(addonTimer.strEpgSearchString, xbmcTimer.m_strEpgSearchString.c_str(), sizeof(addonTimer.strEpgSearchString) - 1);
addonTimer.bFullTextEpgSearch = xbmcTimer.m_bFullTextEpgSearch;
strncpy(addonTimer.strDirectory, xbmcTimer.m_strDirectory.c_str(), sizeof(addonTimer.strDirectory) - 1);
addonTimer.iPriority = xbmcTimer.m_iPriority;
addonTimer.iLifetime = xbmcTimer.m_iLifetime;
addonTimer.iMaxRecordings = xbmcTimer.m_iMaxRecordings;
addonTimer.iPreventDuplicateEpisodes = xbmcTimer.m_iPreventDupEpisodes;
addonTimer.iRecordingGroup = xbmcTimer.m_iRecordingGroup;
addonTimer.iWeekdays = xbmcTimer.m_iWeekdays;
addonTimer.startTime = start - g_advancedSettings.m_iPVRTimeCorrection;
addonTimer.endTime = end - g_advancedSettings.m_iPVRTimeCorrection;
addonTimer.bStartAnyTime = xbmcTimer.m_bStartAnyTime;
addonTimer.bEndAnyTime = xbmcTimer.m_bEndAnyTime;
addonTimer.firstDay = firstDay - g_advancedSettings.m_iPVRTimeCorrection;
addonTimer.iEpgUid = epgTag ? epgTag->UniqueBroadcastID() : PVR_TIMER_NO_EPG_UID;
strncpy(addonTimer.strSummary, xbmcTimer.m_strSummary.c_str(), sizeof(addonTimer.strSummary) - 1);
addonTimer.iMarginStart = xbmcTimer.m_iMarginStart;
addonTimer.iMarginEnd = xbmcTimer.m_iMarginEnd;
addonTimer.iGenreType = epgTag ? epgTag->GenreType() : 0;
addonTimer.iGenreSubType = epgTag ? epgTag->GenreSubType() : 0;
}
CPVRTimerInfoTagPtr CPVRTimers::GetTimerForEpgTag(const CEpgInfoTagPtr &epgTag) const
{
if (epgTag)
{
// already a timer assigned to tag?
CPVRTimerInfoTagPtr timer(epgTag->Timer());
if (timer)
return timer;
// try to find a matching timer for the tag.
if (epgTag->ChannelTag())
{
const CPVRChannelPtr channel(epgTag->ChannelTag());
CSingleLock lock(m_critSection);
for (MapTags::const_iterator it = m_tags.begin(); it != m_tags.end(); ++it)
{
for (VecTimerInfoTag::const_iterator timerIt = it->second->begin(); timerIt != it->second->end(); ++timerIt)
{
timer = *timerIt;
if (!timer->IsRepeating() &&
(timer->GetEpgInfoTag() == epgTag ||
(timer->m_iClientChannelUid == channel->UniqueID() &&
timer->m_bIsRadio == channel->IsRadio() &&
timer->StartAsUTC() <= epgTag->StartAsUTC() &&
timer->EndAsUTC() >= epgTag->EndAsUTC())))
{
return timer;
}
}
}
}
}
return CPVRTimerInfoTagPtr();
}
void CPVRTimers::UpdateEpgEvent(CPVRTimerInfoTagPtr timer)
{
CSingleLock lock(timer->m_critSection);
/* repeating timers have no epg event */
if (timer->IsRepeating())
return;
/* already got an epg event set */
if (timer->m_epgTag)
return;
/* try to get the channel */
CPVRChannelPtr channel = g_PVRChannelGroups->GetByUniqueID(timer->m_iClientChannelUid, timer->m_iClientId);
if (!channel)
return;
/* try to get the EPG table */
CEpgPtr epg = channel->GetEPG();
if (!epg)
return;
/* try to set the timer on the epg tag that matches with a 2 minute margin */
CEpgInfoTagPtr epgTag = epg->GetTagBetween(timer->StartAsUTC() - CDateTimeSpan(0, 0, 2, 0), timer->EndAsUTC() + CDateTimeSpan(0, 0, 2, 0));
if (!epgTag)
epgTag = epg->GetTagAround(timer->StartAsUTC());
if (epgTag)
{
timer->m_epgTag = epgTag;
timer->m_genre = epgTag->Genre();
timer->m_iGenreType = epgTag->GenreType();
timer->m_iGenreSubType = epgTag->GenreSubType();
epgTag->SetTimer(timer);
}
}
bool CEpg::UpdateEntry(const CEpgInfoTagPtr &tag, bool bNotifyObeservers, bool bUpdateDatabase /* = false */)
{
CSingleLock lock(m_critSection);
auto it = m_tags.find(tag->StartAsUTC());
EPG_EVENT_STATE state = (it == m_tags.end()) ? EPG_EVENT_CREATED : EPG_EVENT_UPDATED;
if (UpdateEntry(tag, state, it, bUpdateDatabase) && bNotifyObeservers)
{
SetChanged();
lock.Leave();
NotifyObservers(ObservableMessageEpg);
return true;
}
return false;
}
void CGUIEPGGridContainerModel::FindChannelAndBlockIndex(int channelUid, unsigned int broadcastUid, int eventOffset, int &newChannelIndex, int &newBlockIndex) const
{
const CDateTimeSpan blockDuration(0, 0, MINSPERBLOCK, 0);
bool bFoundPrevChannel = false;
for (size_t channel = 0; channel < m_channelItems.size(); ++channel)
{
CDateTime gridCursor(m_gridStart); //reset cursor for new channel
unsigned long progIdx = m_epgItemsPtr[channel].start;
unsigned long lastIdx = m_epgItemsPtr[channel].stop;
int iEpgId = m_programmeItems[progIdx]->GetEPGInfoTag()->EpgID();
CEpgInfoTagPtr tag;
CPVRChannelPtr chan;
for (int block = 0; block < m_blocks; ++block)
{
while (progIdx <= lastIdx)
{
tag = m_programmeItems[progIdx]->GetEPGInfoTag();
if (tag->EpgID() != iEpgId || gridCursor < tag->StartAsUTC() || m_gridEnd <= tag->StartAsUTC())
break; // next block
if (gridCursor < tag->EndAsUTC())
{
if (broadcastUid > 0 && tag->UniqueBroadcastID() == broadcastUid)
{
newChannelIndex = channel;
newBlockIndex = block + eventOffset;
return; // both found. done.
}
if (!bFoundPrevChannel && channelUid > -1)
{
chan = tag->ChannelTag();
if (chan && chan->UniqueID() == channelUid)
{
newChannelIndex = channel;
bFoundPrevChannel = true;
}
}
break; // next block
}
progIdx++;
}
gridCursor += blockDuration;
}
}
}
void CGUIDialogPVRGuideInfo::OnInitWindow()
{
CGUIDialog::OnInitWindow();
const CEpgInfoTagPtr tag(m_progItem->GetEPGInfoTag());
if (!tag)
{
/* no epg event selected */
return;
}
if (!tag->HasRecording())
{
/* not recording. hide the play recording button */
SET_CONTROL_HIDDEN(CONTROL_BTN_PLAY_RECORDING);
}
bool bHideRecord(true);
if (tag->HasTimer())
{
if (tag->Timer()->IsRecording())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19059); /* Stop recording */
bHideRecord = false;
}
else if (tag->Timer()->HasTimerType() && !tag->Timer()->GetTimerType()->IsReadOnly())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19060); /* Delete timer */
bHideRecord = false;
}
}
else if (tag->EndAsLocalTime() > CDateTime::GetCurrentDateTime())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 264); /* Record */
bHideRecord = false;
}
if (bHideRecord)
SET_CONTROL_HIDDEN(CONTROL_BTN_RECORD);
}
bool CEpg::UpdateEntry(const CEpgInfoTagPtr &tag, EPG_EVENT_STATE newState, std::map<CDateTime, CEpgInfoTagPtr>::iterator &eit, bool bUpdateDatabase /* = false */)
{
CEpgInfoTagPtr infoTag;
bool bNewTag(false);
CSingleLock lock(m_critSection);
if (newState == EPG_EVENT_CREATED || newState == EPG_EVENT_UPDATED)
{
// Reuse passed iterator in favor of doing expensive find self
auto it = (eit == m_tags.end()) ? m_tags.find(tag->StartAsUTC()) : eit;
if (it != m_tags.end())
{
if (newState == EPG_EVENT_CREATED)
CLog::Log(LOGERROR, "EPG - %s - Error: EPG_EVENT_CREATED: uid %d found! Updating existing event.", __FUNCTION__, tag->UniqueBroadcastID());
infoTag = it->second;
}
else
{
if (newState == EPG_EVENT_UPDATED)
CLog::Log(LOGERROR, "EPG - %s - Error: EPG_EVENT_UPDATED: uid %d not found. Inserting new event.", __FUNCTION__, tag->UniqueBroadcastID());
infoTag.reset(new CEpgInfoTag(this, m_pvrChannel, m_strName, m_pvrChannel ? m_pvrChannel->IconPath() : ""));
infoTag->SetUniqueBroadcastID(tag->UniqueBroadcastID());
m_tags.insert(std::make_pair(tag->StartAsUTC(), infoTag));
bNewTag = true;
}
}
else if (newState == EPG_EVENT_DELETED)
{
// Reuse passed iterator in favor of doing expensive find self
auto it = (eit == m_tags.end()) ? m_tags.find(tag->StartAsUTC()) : eit;
if (it == m_tags.end())
{
// not guranteed that deleted tag contains valid start time. search sequential.
for (it = m_tags.begin(); it != m_tags.end(); ++it)
{
if (it->second->UniqueBroadcastID() == tag->UniqueBroadcastID())
break;
}
}
if (it != m_tags.end())
{
it->second->ClearTimer();
m_tags.erase(it);
if (bUpdateDatabase)
m_deletedTags.insert(std::make_pair(infoTag->UniqueBroadcastID(), infoTag));
}
else
{
CLog::Log(LOGERROR, "EPG - %s - Error: EPG_EVENT_DELETED: uid %d not found.", __FUNCTION__, tag->UniqueBroadcastID());
return false;
}
return true;
}
else
{
CLog::Log(LOGERROR, "EPG - %s - unknownn epg event state '%d'.", __FUNCTION__, newState);
return false;
}
infoTag->Update(*tag, bNewTag);
infoTag->SetEpg(this);
infoTag->SetPVRChannel(m_pvrChannel);
if (bUpdateDatabase)
m_changedTags.insert(std::make_pair(infoTag->UniqueBroadcastID(), infoTag));
return true;
}
void CPVRTimerInfoTag::SetEpgInfoTag(CEpgInfoTagPtr &tag)
{
CSingleLock lock(m_critSection);
if (tag && *m_epgTag != *tag)
CLog::Log(LOGINFO, "cPVRTimerInfoTag: timer %s set to epg event %s", m_strTitle.c_str(), tag->Title().c_str());
else if (!tag && m_epgTag)
CLog::Log(LOGINFO, "cPVRTimerInfoTag: timer %s set to no epg event", m_strTitle.c_str());
m_epgTag = tag;
}
CPVRTimerInfoTagPtr CPVRTimerInfoTag::CreateFromEpg(const CEpgInfoTagPtr &tag)
{
/* create a new timer */
CPVRTimerInfoTagPtr newTag(new CPVRTimerInfoTag());
if (!newTag)
{
CLog::Log(LOGERROR, "%s - couldn't create new timer", __FUNCTION__);
return CPVRTimerInfoTagPtr();
}
/* 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_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;
}
