int CPVREpgDatabase::Persist(const CPVREpg &epg, bool bQueueWrite /* = false */)
{
int iReturn(-1);
std::string strQuery;
if (epg.EpgID() > 0)
strQuery = PrepareSQL("REPLACE INTO epg (idEpg, sName, sScraperName) "
"VALUES (%u, '%s', '%s');", epg.EpgID(), epg.Name().c_str(), epg.ScraperName().c_str());
else
strQuery = PrepareSQL("INSERT INTO epg (sName, sScraperName) "
"VALUES ('%s', '%s');", epg.Name().c_str(), epg.ScraperName().c_str());
if (bQueueWrite)
{
if (QueueInsertQuery(strQuery))
iReturn = epg.EpgID() <= 0 ? 0 : epg.EpgID();
}
else
{
if (ExecuteQuery(strQuery))
iReturn = epg.EpgID() <= 0 ? (int) m_pDS->lastinsertid() : epg.EpgID();
}
return iReturn;
}
int CPVREpgs::GetEPGNext(CFileItemList* results, bool bRadio)
{
CPVRChannels *channels = bRadio ? &PVRChannelsRadio : &PVRChannelsTV;
int iInitialSize = results->Size();
for (unsigned int iChannelPtr = 0; iChannelPtr < channels->size(); iChannelPtr++)
{
CPVRChannel *channel = channels->GetByIndex(iChannelPtr);
CPVREpg *epg = channel->GetEPG();
if (!epg->HasValidEntries() || epg->IsUpdateRunning())
continue;
const CPVREpgInfoTag *epgNext = epg->InfoTagNext();
if (!epgNext)
{
continue;
}
CFileItemPtr entry(new CFileItem(*epgNext));
entry->SetLabel2(epgNext->Start().GetAsLocalizedTime("", false));
entry->m_strPath = channel->ChannelName();
entry->SetThumbnailImage(channel->IconPath());
results->Add(entry);
}
return results->Size() - iInitialSize;
}
int CPVREpgContainer::GetEPGNext(CFileItemList* results, bool bRadio)
{
CPVRChannelGroup *channels = (CPVRChannelGroup *) CPVRManager::GetChannelGroups()->GetGroupAll(bRadio);
CSingleLock lock(m_critSection);
int iInitialSize = results->Size();
for (unsigned int iChannelPtr = 0; iChannelPtr < channels->Size(); iChannelPtr++)
{
CPVRChannel *channel = (CPVRChannel *) channels->GetByIndex(iChannelPtr);
CPVREpg *epg = channel->GetEPG();
if (!epg->HasValidEntries())
continue;
const CPVREpgInfoTag *epgNext = (CPVREpgInfoTag *) epg->InfoTagNext();
if (!epgNext)
continue;
CFileItemPtr entry(new CFileItem(*epgNext));
entry->SetLabel2(epgNext->Start().GetAsLocalizedTime("", false));
entry->m_strPath = channel->ChannelName();
entry->SetThumbnailImage(channel->IconPath());
results->Add(entry);
}
return results->Size() - iInitialSize;
}
void CPVREpgs::Clear(bool bClearDb /* = false */)
{
/* remove all pointers to epg tables on timers */
for (unsigned int iTimerPtr = 0; iTimerPtr < PVRTimers.size(); iTimerPtr++)
PVRTimers[iTimerPtr].SetEpgInfoTag(NULL);
/* clear all epg tables and remove pointers to epg tables on channels */
for (unsigned int iEpgPtr = 0; iEpgPtr < size(); iEpgPtr++)
{
CPVREpg *epg = at(iEpgPtr);
epg->Clear();
CPVRChannel *channel = (CPVRChannel *) epg->Channel();
if (channel)
channel->m_EPG = NULL;
}
/* remove all EPG tables */
clear();
/* clear the database entries */
if (bClearDb)
{
CPVRDatabase *database = g_PVRManager.GetTVDatabase();
database->Open();
database->EraseEpg();
database->Close();
}
m_iLastEpgUpdate = 0;
m_bDatabaseLoaded = false;
}
bool CPVREpgs::LoadFromDb(bool bShowProgress /* = false */)
{
if (m_bDatabaseLoaded)
return m_bDatabaseLoaded;
CPVRDatabase *database = g_PVRManager.GetTVDatabase();
/* show the progress bar */
CGUIDialogPVRUpdateProgressBar *scanner = NULL;
if (bShowProgress)
{
scanner = (CGUIDialogPVRUpdateProgressBar *)g_windowManager.GetWindow(WINDOW_DIALOG_EPG_SCAN);
scanner->Show();
scanner->SetHeader(g_localizeStrings.Get(19004));
}
/* open the database */
database->Open();
/* load all EPG tables */
bool bLoaded = false;
unsigned int iSize = size();
for (unsigned int iEpgPtr = 0; iEpgPtr < iSize; iEpgPtr++)
{
CPVREpg *epg = at(iEpgPtr);
CPVRChannel *channel = epg->Channel();
if (epg->LoadFromDb())
{
if (channel)
channel->UpdateEPGPointers();
bLoaded = true;
}
if (bShowProgress)
{
/* update the progress bar */
if (channel)
scanner->SetTitle(channel->ChannelName());
scanner->SetProgress(iEpgPtr, iSize);
scanner->UpdateState();
}
}
/* close the database */
database->Close();
if (bShowProgress)
scanner->Close();
m_bDatabaseLoaded = bLoaded;
return bLoaded;
}
const CStdString &CPVREpgInfoTag::Icon(void) const
{
if (m_strIconPath.IsEmpty() && m_Epg)
{
CPVREpg *pvrEpg = (CPVREpg *) m_Epg;
if (pvrEpg->Channel())
return pvrEpg->Channel()->IconPath();
}
return m_strIconPath;
}
int CPVRChannel::GetEPG(CFileItemList *results)
{
CPVREpg *epg = GetEPG();
if (!epg)
{
CLog::Log(LOGERROR, "PVR - %s - cannot get EPG for channel '%s'",
__FUNCTION__, m_strChannelName.c_str());
return -1;
}
return epg->Get(results);
}
bool CPVREpgDatabase::Delete(const CPVREpg &table)
{
/* invalid channel */
if (table.EpgID() <= 0)
{
CLog::Log(LOGERROR, "EpgDB - %s - invalid channel id: %d", __FUNCTION__, table.EpgID());
return false;
}
Filter filter;
filter.AppendWhere(PrepareSQL("idEpg = %u", table.EpgID()));
return DeleteValues("epg", filter);
}
int CPVREpgs::GetEPGAll(CFileItemList* results, bool bRadio /* = false */)
{
int iInitialSize = results->Size();
for (unsigned int iEpgPtr = 0; iEpgPtr < size(); iEpgPtr++)
{
CPVREpg *epg = at(iEpgPtr);
CPVRChannel *channel = at(iEpgPtr)->Channel();
if (!channel || channel->IsRadio() != bRadio)
continue;
epg->Get(results);
}
return results->Size() - iInitialSize;
}
void CAddonHelpers_PVR::PVRTransferEpgEntry(void *addonData, const PVRHANDLE handle, const PVR_PROGINFO *epgentry)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || handle == NULL || epgentry == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferEpgEntry is called with NULL-Pointer!!!");
return;
}
CPVREpg *xbmcEpg = (CPVREpg*) handle->DATA_ADDRESS;
PVR_PROGINFO *epgentry2 = (PVR_PROGINFO*) epgentry;
CPVRClient* client = (CPVRClient*) handle->CALLER_ADDRESS;
epgentry2->starttime += client->GetTimeCorrection();
epgentry2->endtime += client->GetTimeCorrection();
xbmcEpg->UpdateEntry(epgentry2, handle->DATA_IDENTIFIER == 1);
return;
}
void CPVRTimerInfoTag::UpdateEpgEvent(bool bClear /* = false */)
{
/* try to get the channel */
CPVRChannel *channel = (CPVRChannel *) CPVRManager::GetChannelGroups()->GetByUniqueID(m_iClientChannelUid, m_iClientID);
if (!channel)
return;
/* try to get the EPG table */
CPVREpg *epg = channel->GetEPG();
if (!epg)
return;
/* try to set the timer on the epg tag that matches */
m_EpgInfo = (CPVREpgInfoTag *) epg->InfoTagBetween(m_StartTime, m_StopTime);
if (!m_EpgInfo)
m_EpgInfo = (CPVREpgInfoTag *) epg->InfoTagAround(m_StartTime);
if (m_EpgInfo)
m_EpgInfo->SetTimer(bClear ? NULL : this);
}
int CPVRTimers::Update()
{
CSingleLock lock(m_critSection);
CLog::Log(LOGDEBUG, "PVRTimers - %s - updating timers",
__FUNCTION__);
int iCurSize = size();
/* clear channel timers */
for (unsigned int iTimerPtr = 0; iTimerPtr < size(); iTimerPtr++)
{
CPVRTimerInfoTag *timerTag = &at(iTimerPtr);
if (!timerTag || !timerTag->Active())
continue;
CPVREpgInfoTag *epgTag = (CPVREpgInfoTag *)timerTag->EpgInfoTag();
if (!epgTag)
continue;
epgTag->SetTimer(NULL);
}
/* clear timers */
clear();
/* get all timers from the clients */
CLIENTMAP *clients = g_PVRManager.Clients();
CLIENTMAPITR itr = clients->begin();
while (itr != clients->end())
{
if (g_PVRManager.GetClientProps((*itr).second->GetID())->SupportTimers)
{
if ((*itr).second->GetNumTimers() > 0)
{
(*itr).second->GetAllTimers(this);
}
}
itr++;
}
//XXX
g_PVRManager.UpdateRecordingsCache();
/* set channel timers */
for (unsigned int ptr = 0; ptr < size(); ptr++)
{
/* get the timer tag */
CPVRTimerInfoTag *timerTag = &at(ptr);
if (!timerTag || !timerTag->Active())
continue;
/* try to get the channel */
CPVRChannel *channel = CPVRChannels::GetByClientFromAll(timerTag->Number(), timerTag->ClientID());
if (!channel)
continue;
/* try to get the EPG */
CPVREpg *epg = channel->GetEPG();
if (!epg)
continue;
/* try to set the timer on the epg tag that matches */
CPVREpgInfoTag *epgTag = (CPVREpgInfoTag *) epg->InfoTagBetween(timerTag->Start(), timerTag->Stop());
if (epgTag)
epgTag->SetTimer(timerTag);
}
return size() - iCurSize;
}
int CPVREpgDatabase::Get(CPVREpg &epg)
{
int iReturn(-1);
std::string strQuery = PrepareSQL("SELECT * FROM epgtags WHERE idEpg = %u;", epg.EpgID());
if (ResultQuery(strQuery))
{
iReturn = 0;
try
{
while (!m_pDS->eof())
{
CPVREpgInfoTagPtr newTag(new CPVREpgInfoTag());
time_t iStartTime, iEndTime, iFirstAired;
iStartTime = (time_t) m_pDS->fv("iStartTime").get_asInt();
CDateTime startTime(iStartTime);
newTag->m_startTime = startTime;
iEndTime = (time_t) m_pDS->fv("iEndTime").get_asInt();
CDateTime endTime(iEndTime);
newTag->m_endTime = endTime;
iFirstAired = (time_t) m_pDS->fv("iFirstAired").get_asInt();
CDateTime firstAired(iFirstAired);
newTag->m_firstAired = firstAired;
int iBroadcastUID = m_pDS->fv("iBroadcastUid").get_asInt();
// Compat: null value for broadcast uid changed from numerical -1 to 0 with PVR Addon API v4.0.0
newTag->m_iUniqueBroadcastID = iBroadcastUID == -1 ? EPG_TAG_INVALID_UID : iBroadcastUID;
newTag->m_iBroadcastId = m_pDS->fv("idBroadcast").get_asInt();
newTag->m_strTitle = m_pDS->fv("sTitle").get_asString().c_str();
newTag->m_strPlotOutline = m_pDS->fv("sPlotOutline").get_asString().c_str();
newTag->m_strPlot = m_pDS->fv("sPlot").get_asString().c_str();
newTag->m_strOriginalTitle = m_pDS->fv("sOriginalTitle").get_asString().c_str();
newTag->m_strCast = m_pDS->fv("sCast").get_asString().c_str();
newTag->m_strDirector = m_pDS->fv("sDirector").get_asString().c_str();
newTag->m_strWriter = m_pDS->fv("sWriter").get_asString().c_str();
newTag->m_iYear = m_pDS->fv("iYear").get_asInt();
newTag->m_strIMDBNumber = m_pDS->fv("sIMDBNumber").get_asString().c_str();
newTag->m_iGenreType = m_pDS->fv("iGenreType").get_asInt();
newTag->m_iGenreSubType = m_pDS->fv("iGenreSubType").get_asInt();
newTag->m_genre = StringUtils::Split(m_pDS->fv("sGenre").get_asString().c_str(), g_advancedSettings.m_videoItemSeparator);
newTag->m_iParentalRating = m_pDS->fv("iParentalRating").get_asInt();
newTag->m_iStarRating = m_pDS->fv("iStarRating").get_asInt();
newTag->m_bNotify = m_pDS->fv("bNotify").get_asBool();
newTag->m_iEpisodeNumber = m_pDS->fv("iEpisodeId").get_asInt();
newTag->m_iEpisodePart = m_pDS->fv("iEpisodePart").get_asInt();
newTag->m_strEpisodeName = m_pDS->fv("sEpisodeName").get_asString().c_str();
newTag->m_iSeriesNumber = m_pDS->fv("iSeriesId").get_asInt();
newTag->m_strIconPath = m_pDS->fv("sIconPath").get_asString().c_str();
newTag->m_iFlags = m_pDS->fv("iFlags").get_asInt();
epg.AddEntry(*newTag);
++iReturn;
m_pDS->next();
}
m_pDS->close();
}
catch (...)
{
CLog::Log(LOGERROR, "%s - couldn't load EPG data from the database", __FUNCTION__);
}
}
return iReturn;
}
int CPVREpgs::GetEPGSearch(CFileItemList* results, const PVREpgSearchFilter &filter)
{
for (unsigned int iEpgPtr = 0; iEpgPtr < size(); iEpgPtr++)
{
CPVREpg *epg = at(iEpgPtr);
epg->Get(results, filter);
}
/* filter recordings */
if (filter.m_bIgnorePresentRecordings && PVRRecordings.size() > 0)
{
for (unsigned int iRecordingPtr = 0; iRecordingPtr < PVRRecordings.size(); iRecordingPtr++)
{
for (int iResultPtr = 0; iResultPtr < results->Size(); iResultPtr++)
{
const CPVREpgInfoTag *epgentry = results->Get(iResultPtr)->GetEPGInfoTag();
CPVRRecordingInfoTag *recording = &PVRRecordings[iRecordingPtr];
if (epgentry)
{
if (epgentry->Title() != recording->Title() ||
epgentry->PlotOutline() != recording->PlotOutline() ||
epgentry->Plot() != recording->Plot())
continue;
results->Remove(iResultPtr);
iResultPtr--;
}
}
}
}
/* filter timers */
if (filter.m_bIgnorePresentTimers && PVRTimers.size() > 0)
{
for (unsigned int iTimerPtr = 0; iTimerPtr < PVRTimers.size(); iTimerPtr++)
{
for (int iResultPtr = 0; iResultPtr < results->Size(); iResultPtr++)
{
const CPVREpgInfoTag *epgentry = results->Get(iResultPtr)->GetEPGInfoTag();
CPVRTimerInfoTag *timer = &PVRTimers[iTimerPtr];
if (epgentry)
{
if (epgentry->ChannelTag()->ChannelNumber() != timer->ChannelNumber() ||
epgentry->Start() < timer->Start() ||
epgentry->End() > timer->Stop())
continue;
results->Remove(iResultPtr);
iResultPtr--;
}
}
}
}
/* remove duplicate entries */
if (filter.m_bPreventRepeats)
{
unsigned int iSize = results->Size();
for (unsigned int iResultPtr = 0; iResultPtr < iSize; iResultPtr++)
{
const CPVREpgInfoTag *epgentry_1 = results->Get(iResultPtr)->GetEPGInfoTag();
for (unsigned int iTagPtr = 0; iTagPtr < iSize; iTagPtr++)
{
const CPVREpgInfoTag *epgentry_2 = results->Get(iTagPtr)->GetEPGInfoTag();
if (iResultPtr == iTagPtr)
continue;
if (epgentry_1->Title() != epgentry_2->Title() ||
epgentry_1->Plot() != epgentry_2->Plot() ||
epgentry_1->PlotOutline() != epgentry_2->PlotOutline())
continue;
results->Remove(iTagPtr);
iSize = results->Size();
iResultPtr--;
iTagPtr--;
}
}
}
return results->Size();
}
bool CPVREpgs::UpdateEPG(bool bShowProgress /* = false */)
{
long iStartTime = CTimeUtils::GetTimeMS();
int iEpgCount = size();
CPVRDatabase *database = g_PVRManager.GetTVDatabase();
bool bUpdateSuccess = true;
CGUIDialogPVRUpdateProgressBar *scanner = NULL;
/* set start and end time */
time_t start;
time_t end;
CDateTime::GetCurrentDateTime().GetAsTime(start); // NOTE: XBMC stores the EPG times as local time
end = start;
start -= m_iLingerTime;
if (!m_bDatabaseLoaded)
{
CLog::Log(LOGNOTICE, "PVREpgs - %s - loading initial EPG entries for %i tables from clients",
__FUNCTION__, iEpgCount);
end += 60 * 60 * 3; // load 3 hours
}
else
{
CLog::Log(LOGNOTICE, "PVREpgs - %s - starting EPG update for %i tables (update time = %d)",
__FUNCTION__, iEpgCount, m_iUpdateTime);
end += m_iDisplayTime;
}
/* show the progress bar */
if (bShowProgress)
{
scanner = (CGUIDialogPVRUpdateProgressBar *)g_windowManager.GetWindow(WINDOW_DIALOG_EPG_SCAN);
scanner->Show();
scanner->SetHeader(g_localizeStrings.Get(19004));
}
/* open the database */
database->Open();
/* update all EPG tables */
for (unsigned int iEpgPtr = 0; iEpgPtr < size(); iEpgPtr++)
{
/* interrupt the update on exit */
if (m_bStop)
{
bUpdateSuccess = false;
break;
}
CPVREpg *epg = at(iEpgPtr);
bUpdateSuccess = epg->Update(start, end, !m_bIgnoreDbForClient) && bUpdateSuccess;
if (bShowProgress)
{
/* update the progress bar */
scanner->SetProgress(iEpgPtr, iEpgCount);
scanner->SetTitle(epg->Channel()->ChannelName());
scanner->UpdateState();
}
}
/* update the last scan time if the update was successful and if we did a full update */
if (bUpdateSuccess && m_bDatabaseLoaded)
{
database->UpdateLastEpgScanTime();
CDateTime::GetCurrentDateTime().GetAsTime(m_iLastEpgUpdate);
}
database->Close();
if (!m_bDatabaseLoaded)
{
UpdateAllChannelEPGPointers();
m_bDatabaseLoaded = true;
}
if (bShowProgress)
scanner->Close();
long lUpdateTime = CTimeUtils::GetTimeMS() - iStartTime;
CLog::Log(LOGINFO, "PVREpgs - %s - finished updating the EPG after %li.%li seconds",
__FUNCTION__, lUpdateTime / 1000, lUpdateTime % 1000);
return bUpdateSuccess;
}