CFileItemPtr CPVRChannelGroup::GetLastPlayedChannel(int iCurrentChannel /* = -1 */) const
{
CSingleLock lock(m_critSection);
CPVRChannelPtr returnChannel;
for (std::vector<PVRChannelGroupMember>::const_iterator it = m_members.begin(); it != m_members.end(); ++it)
{
CPVRChannelPtr channel = (*it).channel;
if (channel->ChannelID() != iCurrentChannel &&
g_PVRClients->IsConnectedClient(channel->ClientID()) &&
channel->LastWatched() > 0 &&
(!returnChannel || channel->LastWatched() > returnChannel->LastWatched()))
{
returnChannel = channel;
}
}
if (returnChannel)
{
CFileItemPtr retVal = CFileItemPtr(new CFileItem(*returnChannel));
return retVal;
}
CFileItemPtr retVal = CFileItemPtr(new CFileItem);
return retVal;
}
int CPVRManager::GetPreviousChannel(void)
{
CPVRChannelPtr currentChannel;
if (GetCurrentChannel(currentChannel))
{
CPVRChannelGroupPtr selectedGroup = GetPlayingGroup(currentChannel->IsRadio());
CFileItemPtr channel = selectedGroup->GetLastPlayedChannel(currentChannel->ChannelID());
if (channel && channel->HasPVRChannelInfoTag())
return channel->GetPVRChannelInfoTag()->ChannelNumber();
}
return -1;
}
unsigned int CPVRChannelGroup::GetChannelNumber(const CPVRChannelPtr &channel) const
{
unsigned int iReturn(0);
CSingleLock lock(m_critSection);
for (std::vector<PVRChannelGroupMember>::const_iterator it = m_members.begin(); iReturn == 0 && it != m_members.end(); ++it)
{
if ((*it).channel->ChannelID() == channel->ChannelID())
iReturn = (*it).iChannelNumber;
}
return iReturn;
}
bool CDVDInputStreamPVRManager::SelectChannel(const CPVRChannelPtr &channel)
{
assert(channel.get());
PVR_CLIENT client;
if (IsOtherStreamHack())
{
CFileItem item(channel);
return CloseAndOpen(item.GetPath().c_str());
}
else if (m_pLiveTV)
{
return m_pLiveTV->SelectChannelById(channel->ChannelID());
}
return false;
}
bool CDVDInputStreamPVRManager::SelectChannel(const CPVRChannelPtr &channel)
{
assert(channel.get());
PVR_CLIENT client;
if (IsOtherStreamHack())
{
CFileItem item(channel);
return CloseAndOpen(item.GetPath());
}
else if (!m_isRecording)
{
return g_PVRManager.ChannelSwitchById(channel->ChannelID());
}
return false;
}
JSONRPC_STATUS CPVROperations::Record(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRChannelPtr pChannel;
CVariant channel = parameterObject["channel"];
if (channel.isString() && channel.asString() == "current")
{
pChannel = g_PVRManager.GetCurrentChannel();
if (!pChannel)
return InternalError;
}
else if (channel.isInteger())
{
CPVRChannelGroupsContainer *channelGroupContainer = g_PVRManager.ChannelGroups();
if (channelGroupContainer == NULL)
return FailedToExecute;
pChannel = channelGroupContainer->GetChannelById((int)channel.asInteger());
}
else
return InvalidParams;
if (pChannel == NULL)
return InvalidParams;
else if (!pChannel->CanRecord())
return FailedToExecute;
CVariant record = parameterObject["record"];
bool toggle = true;
if (record.isBoolean() && record.asBoolean() == pChannel->IsRecording())
toggle = false;
if (toggle)
{
if (!g_PVRManager.ToggleRecordingOnChannel(pChannel->ChannelID()))
return FailedToExecute;
}
return ACK;
}
void CGUIEPGGridContainerModel::Initialize(const std::unique_ptr<CFileItemList> &items, const CDateTime &gridStart, const CDateTime &gridEnd, int iRulerUnit, int iBlocksPerPage, float fBlockSize)
{
if (!m_channelItems.empty())
{
CLog::LogF(LOGERROR, "Already initialized!");
return;
}
////////////////////////////////////////////////////////////////////////
// Create programme & channel items
m_programmeItems.reserve(items->Size());
CFileItemPtr fileItem;
int iLastChannelID = -1;
ItemsPtr itemsPointer;
itemsPointer.start = 0;
CPVRChannelPtr channel;
int j = 0;
for (int i = 0; i < items->Size(); ++i)
{
fileItem = items->Get(i);
if (!fileItem->HasEPGInfoTag() || !fileItem->GetEPGInfoTag()->HasChannel())
continue;
m_programmeItems.emplace_back(fileItem);
channel = fileItem->GetEPGInfoTag()->Channel();
if (!channel)
continue;
int iCurrentChannelID = channel->ChannelID();
if (iCurrentChannelID != iLastChannelID)
{
if (j > 0)
{
itemsPointer.stop = j - 1;
m_epgItemsPtr.emplace_back(itemsPointer);
itemsPointer.start = j;
}
iLastChannelID = iCurrentChannelID;
m_channelItems.emplace_back(CFileItemPtr(new CFileItem(channel)));
}
++j;
}
if (!m_programmeItems.empty())
{
itemsPointer.stop = m_programmeItems.size() - 1;
m_epgItemsPtr.emplace_back(itemsPointer);
}
/* check for invalid start and end time */
if (gridStart >= gridEnd)
{
// default to start "now minus GRID_START_PADDING minutes" and end "start plus one page".
m_gridStart = CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0);
m_gridEnd = m_gridStart + CDateTimeSpan(0, 0, iBlocksPerPage * MINSPERBLOCK, 0);
}
else if (gridStart > (CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0)))
{
// adjust to start "now minus GRID_START_PADDING minutes".
m_gridStart = CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0);
m_gridEnd = gridEnd;
}
else
{
m_gridStart = gridStart;
m_gridEnd = gridEnd;
}
// roundup
m_gridStart = CDateTime(m_gridStart.GetYear(), m_gridStart.GetMonth(), m_gridStart.GetDay(), m_gridStart.GetHour(), m_gridStart.GetMinute() >= 30 ? 30 : 0, 0);
m_gridEnd = CDateTime(m_gridEnd.GetYear(), m_gridEnd.GetMonth(), m_gridEnd.GetDay(), m_gridEnd.GetHour(), m_gridEnd.GetMinute() >= 30 ? 30 : 0, 0);
////////////////////////////////////////////////////////////////////////
// Create ruler items
CDateTime ruler;
ruler.SetFromUTCDateTime(m_gridStart);
CDateTime rulerEnd;
rulerEnd.SetFromUTCDateTime(m_gridEnd);
CFileItemPtr rulerItem(new CFileItem(ruler.GetAsLocalizedDate(true)));
rulerItem->SetProperty("DateLabel", true);
m_rulerItems.emplace_back(rulerItem);
const CDateTimeSpan unit(0, 0, iRulerUnit * MINSPERBLOCK, 0);
for (; ruler < rulerEnd; ruler += unit)
{
rulerItem.reset(new CFileItem(ruler.GetAsLocalizedTime("", false)));
rulerItem->SetLabel2(ruler.GetAsLocalizedDate(true));
m_rulerItems.emplace_back(rulerItem);
}
FreeItemsMemory();
////////////////////////////////////////////////////////////////////////
// Create epg grid
const CDateTimeSpan blockDuration(0, 0, MINSPERBLOCK, 0);
const CDateTimeSpan gridDuration(m_gridEnd - m_gridStart);
m_blocks = (gridDuration.GetDays() * 24 * 60 + gridDuration.GetHours() * 60 + gridDuration.GetMinutes()) / MINSPERBLOCK;
if (m_blocks >= MAXBLOCKS)
m_blocks = MAXBLOCKS;
else if (m_blocks < iBlocksPerPage)
m_blocks = iBlocksPerPage;
m_gridIndex.reserve(m_channelItems.size());
const std::vector<GridItem> blocks(m_blocks);
for (size_t channel = 0; channel < m_channelItems.size(); ++channel)
{
m_gridIndex.emplace_back(blocks);
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();
int itemSize = 1; // size of the programme in blocks
int savedBlock = 0;
CFileItemPtr item;
CPVREpgInfoTagPtr tag;
for (int block = 0; block < m_blocks; ++block)
{
while (progIdx <= lastIdx)
{
item = m_programmeItems[progIdx];
tag = item->GetEPGInfoTag();
// Note: Start block of an event is start-time-based calculated block + 1,
// unless start times matches exactly the begin of a block.
if (tag->EpgID() != iEpgId || gridCursor < tag->StartAsUTC() || m_gridEnd <= tag->StartAsUTC())
break;
if (gridCursor < tag->EndAsUTC())
{
m_gridIndex[channel][block].item = item;
m_gridIndex[channel][block].progIndex = progIdx;
break;
}
progIdx++;
}
gridCursor += blockDuration;
if (block == 0)
continue;
const CFileItemPtr prevItem(m_gridIndex[channel][block - 1].item);
const CFileItemPtr currItem(m_gridIndex[channel][block].item);
if (block == m_blocks - 1 || prevItem != currItem)
{
// special handling for last block.
int blockDelta = -1;
int sizeDelta = 0;
if (block == m_blocks - 1 && prevItem == currItem)
{
itemSize++;
blockDelta = 0;
sizeDelta = 1;
}
if (prevItem)
{
m_gridIndex[channel][savedBlock].item->SetProperty("GenreType", prevItem->GetEPGInfoTag()->GenreType());
}
else
{
CPVREpgInfoTagPtr gapTag(CPVREpgInfoTag::CreateDefaultTag());
gapTag->SetChannel(m_channelItems[channel]->GetPVRChannelInfoTag());
CFileItemPtr gapItem(new CFileItem(gapTag));
for (int i = block + blockDelta; i >= block - itemSize + sizeDelta; --i)
{
m_gridIndex[channel][i].item = gapItem;
}
}
float fItemWidth = itemSize * fBlockSize;
m_gridIndex[channel][savedBlock].originWidth = fItemWidth;
m_gridIndex[channel][savedBlock].width = fItemWidth;
itemSize = 1;
savedBlock = block;
// special handling for last block.
if (block == m_blocks - 1 && prevItem != currItem)
{
if (currItem)
{
m_gridIndex[channel][savedBlock].item->SetProperty("GenreType", currItem->GetEPGInfoTag()->GenreType());
}
else
{
CPVREpgInfoTagPtr gapTag(CPVREpgInfoTag::CreateDefaultTag());
gapTag->SetChannel(m_channelItems[channel]->GetPVRChannelInfoTag());
CFileItemPtr gapItem(new CFileItem(gapTag));
m_gridIndex[channel][block].item = gapItem;
}
m_gridIndex[channel][savedBlock].originWidth = fBlockSize; // size always 1 block here
m_gridIndex[channel][savedBlock].width = fBlockSize;
}
}
else
{
itemSize++;
}
}
}
}
bool CGUIWindowFullScreen::OnAction(const CAction &action)
{
if (m_timeCodePosition > 0 && action.GetButtonCode())
{ // check whether we have a mapping in our virtual videotimeseek "window" and have a select action
CKey key(action.GetButtonCode());
CAction timeSeek = CButtonTranslator::GetInstance().GetAction(WINDOW_VIDEO_TIME_SEEK, key, false);
if (timeSeek.GetID() == ACTION_SELECT_ITEM)
{
SeekToTimeCodeStamp(SEEK_ABSOLUTE);
return true;
}
}
switch (action.GetID())
{
case ACTION_SHOW_OSD:
ToggleOSD();
return true;
case ACTION_SHOW_GUI:
{
// switch back to the menu
OutputDebugString("Switching to GUI\n");
g_windowManager.PreviousWindow();
OutputDebugString("Now in GUI\n");
return true;
}
break;
case ACTION_PLAYER_PLAY:
case ACTION_PAUSE:
if (m_timeCodePosition > 0)
{
SeekToTimeCodeStamp(SEEK_ABSOLUTE);
return true;
}
break;
case ACTION_STEP_BACK:
if (m_timeCodePosition > 0)
SeekToTimeCodeStamp(SEEK_RELATIVE, SEEK_BACKWARD);
else
g_application.m_pPlayer->Seek(false, false);
return true;
case ACTION_STEP_FORWARD:
if (m_timeCodePosition > 0)
SeekToTimeCodeStamp(SEEK_RELATIVE, SEEK_FORWARD);
else
g_application.m_pPlayer->Seek(true, false);
return true;
case ACTION_BIG_STEP_BACK:
case ACTION_CHAPTER_OR_BIG_STEP_BACK:
if (m_timeCodePosition > 0)
SeekToTimeCodeStamp(SEEK_RELATIVE, SEEK_BACKWARD);
else
g_application.m_pPlayer->Seek(false, true, action.GetID() == ACTION_CHAPTER_OR_BIG_STEP_BACK);
return true;
case ACTION_BIG_STEP_FORWARD:
case ACTION_CHAPTER_OR_BIG_STEP_FORWARD:
if (m_timeCodePosition > 0)
SeekToTimeCodeStamp(SEEK_RELATIVE, SEEK_FORWARD);
else
g_application.m_pPlayer->Seek(true, true, action.GetID() == ACTION_CHAPTER_OR_BIG_STEP_FORWARD);
return true;
case ACTION_NEXT_SCENE:
if (g_application.m_pPlayer->SeekScene(true))
g_infoManager.SetDisplayAfterSeek();
return true;
break;
case ACTION_PREV_SCENE:
if (g_application.m_pPlayer->SeekScene(false))
g_infoManager.SetDisplayAfterSeek();
return true;
break;
case ACTION_SHOW_OSD_TIME:
m_bShowCurrentTime = !m_bShowCurrentTime;
if(!m_bShowCurrentTime)
g_infoManager.SetDisplayAfterSeek(0); //Force display off
g_infoManager.SetShowTime(m_bShowCurrentTime);
return true;
break;
case ACTION_SHOW_INFO:
{
CGUIDialogFullScreenInfo* pDialog = (CGUIDialogFullScreenInfo*)g_windowManager.GetWindow(WINDOW_DIALOG_FULLSCREEN_INFO);
if (pDialog)
{
CFileItem item(g_application.CurrentFileItem());
pDialog->DoModal();
return true;
}
break;
}
case REMOTE_0:
case REMOTE_1:
case REMOTE_2:
case REMOTE_3:
case REMOTE_4:
case REMOTE_5:
case REMOTE_6:
case REMOTE_7:
case REMOTE_8:
case REMOTE_9:
{
if (g_application.CurrentFileItem().IsLiveTV())
{
if(CPVRManager::Get().IsPlaying())
{
// pvr client addon
CPVRChannelPtr playingChannel;
if(!g_PVRManager.GetCurrentChannel(playingChannel))
return false;
if (action.GetID() == REMOTE_0)
{
CPVRChannelGroupPtr group = g_PVRChannelGroups->GetPreviousPlayedGroup();
if (group)
{
g_PVRManager.SetPlayingGroup(group);
CFileItemPtr fileItem = group->GetLastPlayedChannel(playingChannel->ChannelID());
if (fileItem && fileItem->HasPVRChannelInfoTag())
{
CLog::Log(LOGDEBUG, "%s - switch to channel number %d", __FUNCTION__, fileItem->GetPVRChannelInfoTag()->ChannelNumber());
g_application.OnAction(CAction(ACTION_CHANNEL_SWITCH, (float) fileItem->GetPVRChannelInfoTag()->ChannelNumber()));
}
}
}
else
{
int autoCloseTime = CSettings::Get().GetBool("pvrplayback.confirmchannelswitch") ? 0 : g_advancedSettings.m_iPVRNumericChannelSwitchTimeout;
CStdString strChannel = StringUtils::Format("%i", action.GetID() - REMOTE_0);
if (CGUIDialogNumeric::ShowAndGetNumber(strChannel, g_localizeStrings.Get(19000), autoCloseTime) || autoCloseTime)
{
int iChannelNumber = atoi(strChannel.c_str());
if (iChannelNumber > 0 && iChannelNumber != playingChannel->ChannelNumber())
{
CPVRChannelGroupPtr selectedGroup = g_PVRManager.GetPlayingGroup(playingChannel->IsRadio());
CFileItemPtr channel = selectedGroup->GetByChannelNumber(iChannelNumber);
if (!channel || !channel->HasPVRChannelInfoTag())
return false;
g_application.OnAction(CAction(ACTION_CHANNEL_SWITCH, (float)iChannelNumber));
}
}
}
}
else
{
// filesystem provider like slingbox, cmyth, etc
int iChannelNumber = -1;
CStdString strChannel = StringUtils::Format("%i", action.GetID() - REMOTE_0);
if (CGUIDialogNumeric::ShowAndGetNumber(strChannel, g_localizeStrings.Get(19000)))
iChannelNumber = atoi(strChannel.c_str());
if (iChannelNumber > 0)
g_application.OnAction(CAction(ACTION_CHANNEL_SWITCH, (float)iChannelNumber));
}
}
else
{
ChangetheTimeCode(action.GetID());
}
return true;
}
break;
case ACTION_ASPECT_RATIO:
{ // toggle the aspect ratio mode (only if the info is onscreen)
if (m_bShowViewModeInfo)
{
#ifdef HAS_VIDEO_PLAYBACK
g_renderManager.SetViewMode(++CMediaSettings::Get().GetCurrentVideoSettings().m_ViewMode);
#endif
}
m_bShowViewModeInfo = true;
m_dwShowViewModeTimeout = XbmcThreads::SystemClockMillis();
}
return true;
break;
case ACTION_SMALL_STEP_BACK:
if (m_timeCodePosition > 0)
SeekToTimeCodeStamp(SEEK_RELATIVE, SEEK_BACKWARD);
else
{
int orgpos = (int)g_application.GetTime();
int jumpsize = g_advancedSettings.m_videoSmallStepBackSeconds; // secs
int setpos = (orgpos > jumpsize) ? orgpos - jumpsize : 0;
g_application.SeekTime((double)setpos);
}
return true;
break;
case ACTION_SHOW_PLAYLIST:
{
CFileItem item(g_application.CurrentFileItem());
if (item.HasPVRChannelInfoTag())
g_windowManager.ActivateWindow(WINDOW_DIALOG_PVR_OSD_CHANNELS);
else if (item.HasVideoInfoTag())
g_windowManager.ActivateWindow(WINDOW_VIDEO_PLAYLIST);
else if (item.HasMusicInfoTag())
g_windowManager.ActivateWindow(WINDOW_MUSIC_PLAYLIST);
}
return true;
break;
case ACTION_PREVIOUS_CHANNELGROUP:
{
if (g_application.CurrentFileItem().HasPVRChannelInfoTag())
ChangetheTVGroup(false);
return true;
}
case ACTION_NEXT_CHANNELGROUP:
{
if (g_application.CurrentFileItem().HasPVRChannelInfoTag())
ChangetheTVGroup(true);
return true;
}
default:
break;
}
return CGUIWindow::OnAction(action);
}
