bool CPVRChannelGroup::UpdateClientPriorities()
{
const CPVRClientsPtr clients = CServiceBroker::GetPVRManager().Clients();
bool bChanged = false;
CSingleLock lock(m_critSection);
for (auto& member : m_sortedMembers)
{
int iNewPriority = 0;
if (m_bUsingBackendChannelOrder)
{
CPVRClientPtr client;
if (!clients->GetCreatedClient(member.channel->ClientID(), client))
continue;
iNewPriority = client->GetPriority();
}
else
{
iNewPriority = 0;
}
bChanged |= (member.iClientPriority != iNewPriority);
member.iClientPriority = iNewPriority;
}
return bChanged;
}
DemuxPacket* CDVDInputStreamPVRManager::ReadDemux()
{
CPVRClientPtr client;
if (!CServiceBroker::GetPVRManager().Clients()->GetPlayingClient(client))
{
return nullptr;
}
DemuxPacket* pPacket = nullptr;
client->DemuxRead(pPacket);
if (!pPacket)
{
return nullptr;
}
else if (pPacket->iStreamId == DMX_SPECIALID_STREAMINFO)
{
client->GetStreamProperties(m_StreamProps);
return pPacket;
}
else if (pPacket->iStreamId == DMX_SPECIALID_STREAMCHANGE)
{
client->GetStreamProperties(m_StreamProps);
UpdateStreamMap();
}
return pPacket;
}
void CDVDInputStreamPVRManager::FlushDemux()
{
CPVRClientPtr client;
if (CServiceBroker::GetPVRManager().Clients()->GetPlayingClient(client))
{
client->DemuxFlush();
}
}
void CDVDInputStreamPVRManager::SetSpeed(int Speed)
{
CPVRClientPtr client;
if (CServiceBroker::GetPVRManager().Clients()->GetPlayingClient(client))
{
client->SetSpeed(Speed);
}
}
bool CDVDInputStreamPVRManager::SeekTime(double timems, bool backwards, double *startpts)
{
CPVRClientPtr client;
if (CServiceBroker::GetPVRManager().Clients()->GetPlayingClient(client))
{
return client->SeekTime(timems, backwards, startpts);
}
return false;
}
void CPVRManager::OnPlaybackStarted(const CFileItemPtr item)
{
m_playingChannel.reset();
m_playingRecording.reset();
m_playingEpgTag.reset();
m_playingClientId = -1;
m_strPlayingClientName.clear();
if (item->HasPVRChannelInfoTag())
{
const CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
m_playingChannel = channel;
m_playingClientId = m_playingChannel->ClientID();
SetPlayingGroup(channel);
int iLastWatchedDelay = m_settings.GetIntValue(CSettings::SETTING_PVRPLAYBACK_DELAYMARKLASTWATCHED) * 1000;
if (iLastWatchedDelay > 0)
{
// Insert new / replace existing last watched update timer
if (m_lastWatchedUpdateTimer)
m_lastWatchedUpdateTimer->Stop(true);
m_lastWatchedUpdateTimer.reset(new CLastWatchedUpdateTimer(*this, channel, CDateTime::GetUTCDateTime()));
m_lastWatchedUpdateTimer->Start(iLastWatchedDelay);
}
else
{
// Store last watched timestamp immediately
UpdateLastWatched(channel, CDateTime::GetUTCDateTime());
}
}
else if (item->HasPVRRecordingInfoTag())
{
m_playingRecording = item->GetPVRRecordingInfoTag();
m_playingClientId = m_playingRecording->m_iClientId;
}
else if (item->HasEPGInfoTag())
{
m_playingEpgTag = item->GetEPGInfoTag();
m_playingClientId = m_playingEpgTag->ClientID();
}
if (m_playingClientId != -1)
{
const CPVRClientPtr client = GetClient(m_playingClientId);
if (client)
m_strPlayingClientName = client->GetFriendlyName();
}
m_guiActions->OnPlaybackStarted(item);
m_epgContainer.OnPlaybackStarted(item);
}
bool CDVDInputStreamPVRManager::OpenDemux()
{
CPVRClientPtr client;
if (!CServiceBroker::GetPVRManager().Clients()->GetPlayingClient(client))
{
return false;
}
client->GetStreamProperties(m_StreamProps);
UpdateStreamMap();
return true;
}
void CGUIDialogPVRGuideInfo::OnInitWindow()
{
CGUIDialog::OnInitWindow();
if (!m_progItem)
{
/* no epg event selected */
return;
}
if (!m_progItem->HasRecording())
{
/* not recording. hide the play recording button */
SET_CONTROL_HIDDEN(CONTROL_BTN_PLAY_RECORDING);
}
bool bHideRecord(true);
bool bHideAddTimer(true);
if (m_progItem->HasTimer())
{
if (m_progItem->Timer()->IsRecording())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19059); /* Stop recording */
bHideRecord = false;
}
else if (m_progItem->Timer()->HasTimerType() && !m_progItem->Timer()->GetTimerType()->IsReadOnly())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 19060); /* Delete timer */
bHideRecord = false;
}
}
else if (m_progItem->Channel() && m_progItem->IsRecordable())
{
const CPVRClientPtr client = CServiceBroker::GetPVRManager().GetClient(m_progItem->ClientID());
if (client && client->GetClientCapabilities().SupportsTimers())
{
SET_CONTROL_LABEL(CONTROL_BTN_RECORD, 264); /* Record */
bHideRecord = false;
bHideAddTimer = false;
}
}
if (!m_progItem->IsPlayable())
SET_CONTROL_HIDDEN(CONTROL_BTN_PLAY_EPGTAG);
if (bHideRecord)
SET_CONTROL_HIDDEN(CONTROL_BTN_RECORD);
if (bHideAddTimer)
SET_CONTROL_HIDDEN(CONTROL_BTN_ADD_TIMER);
}
bool CPVRManager::FillStreamFileItem(CFileItem &fileItem)
{
const CPVRClientPtr client = GetClient(fileItem);
if (client)
{
if (fileItem.IsPVRChannel())
return client->FillChannelStreamFileItem(fileItem) == PVR_ERROR_NO_ERROR;
else if (fileItem.IsPVRRecording())
return client->FillRecordingStreamFileItem(fileItem) == PVR_ERROR_NO_ERROR;
else if (fileItem.IsEPG())
return client->FillEpgTagStreamFileItem(fileItem) == PVR_ERROR_NO_ERROR;
}
return false;
}
void CPVRGUIInfo::UpdateDescrambleData(void)
{
PVR_DESCRAMBLE_INFO descrambleInfo;
ClearDescrambleInfo(descrambleInfo);
bool bIsPlayingRecording = CServiceBroker::GetPVRManager().IsPlayingRecording();
if (!bIsPlayingRecording)
{
CPVRClientPtr client;
CServiceBroker::GetPVRManager().Clients()->GetCreatedClient(CServiceBroker::GetPVRManager().GetPlayingClientID(), client);
if (client && client->GetDescrambleInfo(descrambleInfo) == PVR_ERROR_NO_ERROR)
{
m_descrambleInfo = descrambleInfo;
}
}
}
void CPVRChannel::UpdatePath(const std::string& groupPath)
{
const CPVRClientPtr client = CServiceBroker::GetPVRManager().GetClient(m_iClientId);
if (client)
{
CSingleLock lock(m_critSection);
const std::string strFileNameAndPath = StringUtils::Format("%s%s_%d.pvr",
groupPath,
client->ID().c_str(),
m_iUniqueId);
if (m_strFileNameAndPath != strFileNameAndPath)
{
m_strFileNameAndPath = strFileNameAndPath;
SetChanged();
}
}
}
void CPVRGUIInfo::UpdateQualityData(void)
{
PVR_SIGNAL_STATUS qualityInfo;
ClearQualityInfo(qualityInfo);
if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_PVRPLAYBACK_SIGNALQUALITY))
{
bool bIsPlayingRecording = CServiceBroker::GetPVRManager().IsPlayingRecording();
if (!bIsPlayingRecording)
{
CPVRClientPtr client;
CServiceBroker::GetPVRManager().Clients()->GetCreatedClient(CServiceBroker::GetPVRManager().GetPlayingClientID(), client);
if (client && client->SignalQuality(qualityInfo) == PVR_ERROR_NO_ERROR)
{
m_qualityInfo = qualityInfo;
}
}
}
}
void CPVRManager::OnPlaybackStarted(const CFileItemPtr item)
{
m_playingChannel.reset();
m_playingRecording.reset();
m_playingEpgTag.reset();
m_playingClientId = -1;
m_strPlayingClientName.clear();
if (item->HasPVRChannelInfoTag())
{
const CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
m_playingChannel = channel;
m_playingClientId = m_playingChannel->ClientID();
SetPlayingGroup(channel);
UpdateLastWatched(channel);
}
else if (item->HasPVRRecordingInfoTag())
{
m_playingRecording = item->GetPVRRecordingInfoTag();
m_playingClientId = m_playingRecording->m_iClientId;
}
else if (item->HasEPGInfoTag())
{
m_playingEpgTag = item->GetEPGInfoTag();
m_playingClientId = m_playingEpgTag->ClientID();
}
if (m_playingClientId != -1)
{
const CPVRClientPtr client = GetClient(m_playingClientId);
if (client)
m_strPlayingClientName = client->GetFriendlyName();
}
m_guiActions->OnPlaybackStarted(item);
}
bool CPVRTimers::UpdateEntries(const CPVRTimersContainer &timers, const std::vector<int> &failedClients)
{
bool bChanged(false);
bool bAddedOrDeleted(false);
std::vector< std::pair< int, std::string> > timerNotifications;
CSingleLock lock(m_critSection);
/* go through the timer list and check for updated or new timers */
for (MapTags::const_iterator it = timers.GetTags().begin(); it != timers.GetTags().end(); ++it)
{
for (VecTimerInfoTag::const_iterator timerIt = it->second.begin(); timerIt != it->second.end(); ++timerIt)
{
/* check if this timer is present in this container */
CPVRTimerInfoTagPtr existingTimer = GetByClient((*timerIt)->m_iClientId, (*timerIt)->m_iClientIndex);
if (existingTimer)
{
/* if it's present, update the current tag */
bool bStateChanged(existingTimer->m_state != (*timerIt)->m_state);
if (existingTimer->UpdateEntry(*timerIt))
{
bChanged = true;
existingTimer->ResetChildState();
if (bStateChanged)
{
std::string strMessage;
existingTimer->GetNotificationText(strMessage);
timerNotifications.push_back(std::make_pair((*timerIt)->m_iClientId, strMessage));
}
CLog::LogFC(LOGDEBUG, LOGPVR, "Updated timer %d on client %d",
(*timerIt)->m_iClientIndex, (*timerIt)->m_iClientId);
}
}
else
{
/* new timer */
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTagPtr(new CPVRTimerInfoTag);
newTimer->UpdateEntry(*timerIt);
newTimer->m_iTimerId = ++m_iLastId;
InsertTimer(newTimer);
bChanged = true;
bAddedOrDeleted = true;
std::string strMessage;
newTimer->GetNotificationText(strMessage);
timerNotifications.push_back(std::make_pair(newTimer->m_iClientId, strMessage));
CLog::LogFC(LOGDEBUG, LOGPVR, "Added timer %d on client %d",
(*timerIt)->m_iClientIndex, (*timerIt)->m_iClientId);
}
}
}
/* to collect timer with changed starting time */
VecTimerInfoTag timersToMove;
/* check for deleted timers */
for (MapTags::iterator it = m_tags.begin(); it != m_tags.end();)
{
for (std::vector<CPVRTimerInfoTagPtr>::iterator it2 = it->second.begin(); it2 != it->second.end();)
{
CPVRTimerInfoTagPtr timer(*it2);
if (!timers.GetByClient(timer->m_iClientId, timer->m_iClientIndex))
{
/* timer was not found */
bool bIgnoreTimer(false);
for (const auto &failedClient : failedClients)
{
if (failedClient == timer->m_iClientId)
{
bIgnoreTimer = true;
break;
}
}
if (bIgnoreTimer)
{
++it2;
continue;
}
CLog::LogFC(LOGDEBUG, LOGPVR, "Deleted timer %d on client %d",
timer->m_iClientIndex, timer->m_iClientId);
timerNotifications.push_back(std::make_pair(timer->m_iClientId, timer->GetDeletedNotificationText()));
it2 = it->second.erase(it2);
bChanged = true;
bAddedOrDeleted = true;
}
else if ((timer->m_bStartAnyTime && it->first != CDateTime()) ||
(!timer->m_bStartAnyTime && timer->StartAsUTC() != it->first))
{
/* timer start has changed */
CLog::LogFC(LOGDEBUG, LOGPVR, "Changed start time timer %d on client %d",
timer->m_iClientIndex, timer->m_iClientId);
/* remember timer */
timersToMove.push_back(timer);
/* remove timer for now, reinsert later */
it2 = it->second.erase(it2);
bChanged = true;
bAddedOrDeleted = true;
}
else
{
++it2;
}
}
if (it->second.empty())
it = m_tags.erase(it);
else
++it;
}
/* reinsert timers with changed timer start */
for (VecTimerInfoTag::const_iterator timerIt = timersToMove.begin(); timerIt != timersToMove.end(); ++timerIt)
InsertTimer(*timerIt);
/* update child information for all parent timers */
for (const auto &tagsEntry : m_tags)
{
for (const auto &timersEntry : tagsEntry.second)
{
if (timersEntry->GetTimerRuleId() != PVR_TIMER_NO_PARENT)
{
const CPVRTimerInfoTagPtr parentTimer(GetByClient(timersEntry->m_iClientId, timersEntry->GetTimerRuleId()));
if (parentTimer)
parentTimer->UpdateChildState(timersEntry);
}
}
}
m_bIsUpdating = false;
if (bChanged)
{
UpdateChannels();
lock.Leave();
CServiceBroker::GetPVRManager().SetChanged();
CServiceBroker::GetPVRManager().NotifyObservers(bAddedOrDeleted ? ObservableMessageTimersReset : ObservableMessageTimers);
if (!timerNotifications.empty() && CServiceBroker::GetPVRManager().IsStarted())
{
CPVREventlogJob *job = new CPVREventlogJob;
/* queue notifications / fill eventlog */
for (const auto &entry : timerNotifications)
{
const CPVRClientPtr client = CServiceBroker::GetPVRManager().GetClient(entry.first);
if (client)
{
job->AddEvent(m_settings.GetBoolValue(CSettings::SETTING_PVRRECORD_TIMERNOTIFICATIONS),
false, // info, no error
client->Name(),
entry.second,
client->Icon());
}
}
CJobManager::GetInstance().AddJob(job, nullptr);
}
}
return bChanged;
}
bool CPVRChannel::CanRecord(void) const
{
const CPVRClientPtr client = CServiceBroker::GetPVRManager().GetClient(m_iClientId);
return client && client->GetClientCapabilities().SupportsRecordings();
}
