xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp

   1 /*
   2  *  Copyright (C) 2012-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PVRGUITimesInfo.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "cores/DataCacheCore.h"
  13 #include "pvr/PVRManager.h"
  14 #include "pvr/PVRPlaybackState.h"
  15 #include "pvr/channels/PVRChannel.h"
  16 #include "pvr/channels/PVRChannelGroupsContainer.h"
  17 #include "pvr/epg/EpgInfoTag.h"
  18 #include "pvr/recordings/PVRRecording.h"
  19 #include "settings/AdvancedSettings.h"
  20 #include "settings/SettingsComponent.h"
  21 #include "utils/MathUtils.h"
  22 #include "utils/StringUtils.h"
  23
  24 #include <chrono>
  25 #include <cmath>
  26 #include <ctime>
  27 #include <memory>
  28 #include <mutex>
  29
  30 using namespace PVR;
  31
  32 CPVRGUITimesInfo::CPVRGUITimesInfo()
  33 {
  34   Reset();
  35 }
  36
  37 void CPVRGUITimesInfo::Reset()
  38 {
  39   std::unique_lock<CCriticalSection> lock(m_critSection);
  40
  41   m_iStartTime = 0;
  42   m_iDuration = 0;
  43   m_iTimeshiftStartTime = 0;
  44   m_iTimeshiftEndTime = 0;
  45   m_iTimeshiftPlayTime = 0;
  46   m_iTimeshiftOffset = 0;
  47
  48   m_iTimeshiftProgressStartTime = 0;
  49   m_iTimeshiftProgressEndTime = 0;
  50   m_iTimeshiftProgressDuration = 0;
  51
  52   m_playingEpgTag.reset();
  53   m_playingChannel.reset();
  54 }
  55
  56 void CPVRGUITimesInfo::UpdatePlayingTag()
  57 {
  58   const std::shared_ptr<const CPVRChannel> currentChannel =
  59       CServiceBroker::GetPVRManager().PlaybackState()->GetPlayingChannel();
  60   std::shared_ptr<CPVREpgInfoTag> currentTag = CServiceBroker::GetPVRManager().PlaybackState()->GetPlayingEpgTag();
  61
  62   if (currentChannel || currentTag)
  63   {
  64     if (currentChannel && !currentTag)
  65       currentTag = currentChannel->GetEPGNow();
  66
  67     const std::shared_ptr<const CPVRChannelGroupsContainer> groups =
  68         CServiceBroker::GetPVRManager().ChannelGroups();
  69
  70     std::unique_lock<CCriticalSection> lock(m_critSection);
  71
  72     const std::shared_ptr<const CPVRChannel> playingChannel =
  73         m_playingEpgTag ? groups->GetChannelForEpgTag(m_playingEpgTag) : nullptr;
  74
  75     if (!m_playingEpgTag || !currentTag || !playingChannel || !currentChannel ||
  76         m_playingEpgTag->StartAsUTC() != currentTag->StartAsUTC() ||
  77         m_playingEpgTag->EndAsUTC() != currentTag->EndAsUTC() || *playingChannel != *currentChannel)
  78     {
  79       if (currentTag)
  80       {
  81         m_playingEpgTag = currentTag;
  82         m_iDuration = m_playingEpgTag->GetDuration();
  83       }
  84       else if (m_iTimeshiftEndTime > m_iTimeshiftStartTime)
  85       {
  86         m_playingEpgTag.reset();
  87         std::chrono::duration<unsigned int> duration{m_iTimeshiftEndTime - m_iTimeshiftStartTime};
  88         m_iDuration = duration.count();
  89       }
  90       else
  91       {
  92         m_playingEpgTag.reset();
  93         m_iDuration = 0;
  94       }
  95     }
  96   }
  97   else
  98   {
  99     const std::shared_ptr<const CPVRRecording> recording =
 100         CServiceBroker::GetPVRManager().PlaybackState()->GetPlayingRecording();
 101     if (recording)
 102     {
 103       std::unique_lock<CCriticalSection> lock(m_critSection);
 104       m_playingEpgTag.reset();
 105       m_iDuration = recording->GetDuration();
 106     }
 107   }
 108 }
 109
 110 void CPVRGUITimesInfo::UpdateTimeshiftData()
 111 {
 112   if (!CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingTV() && !CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingRadio())
 113   {
 114     // If nothing is playing (anymore), there is no need to update data.
 115     Reset();
 116     return;
 117   }
 118
 119   time_t now = std::time(nullptr);
 120   time_t iStartTime;
 121   int64_t iPlayTime, iMinTime, iMaxTime;
 122   CServiceBroker::GetDataCacheCore().GetPlayTimes(iStartTime, iPlayTime, iMinTime, iMaxTime);
 123   bool bPlaying = CServiceBroker::GetDataCacheCore().GetSpeed() == 1.0f;
 124   const std::shared_ptr<const CPVRChannel> playingChannel =
 125       CServiceBroker::GetPVRManager().PlaybackState()->GetPlayingChannel();
 126
 127   std::unique_lock<CCriticalSection> lock(m_critSection);
 128
 129   if (playingChannel != m_playingChannel)
 130   {
 131     // playing channel changed. we need to reset offset and playtime.
 132     m_iTimeshiftOffset = 0;
 133     m_iTimeshiftPlayTime = 0;
 134     m_playingChannel = playingChannel;
 135   }
 136
 137   if (!iStartTime)
 138   {
 139     if (m_iStartTime == 0)
 140       iStartTime = now;
 141     else
 142       iStartTime = m_iStartTime;
 143
 144     iMinTime = iPlayTime;
 145     iMaxTime = iPlayTime;
 146   }
 147
 148   m_iStartTime = iStartTime;
 149   m_iTimeshiftStartTime = iStartTime + iMinTime / 1000;
 150   m_iTimeshiftEndTime = iStartTime + iMaxTime / 1000;
 151
 152   if (m_iTimeshiftEndTime > m_iTimeshiftStartTime)
 153   {
 154     // timeshifting supported
 155     m_iTimeshiftPlayTime = iStartTime + iPlayTime / 1000;
 156     if (iMaxTime > iPlayTime)
 157       m_iTimeshiftOffset = (iMaxTime - iPlayTime) / 1000;
 158     else
 159       m_iTimeshiftOffset = 0;
 160   }
 161   else
 162   {
 163     // timeshifting not supported
 164     if (bPlaying)
 165       m_iTimeshiftPlayTime = now - m_iTimeshiftOffset;
 166
 167     m_iTimeshiftOffset = now - m_iTimeshiftPlayTime;
 168   }
 169
 170   UpdateTimeshiftProgressData();
 171 }
 172
 173 void CPVRGUITimesInfo::UpdateTimeshiftProgressData()
 174 {
 175   // Note: General idea of the ts progress is always to be able to visualise both the complete
 176   //       ts buffer and the complete playing epg event (if any) side by side with the same time
 177   //       scale. TS progress start and end times will be calculated accordingly.
 178   //       + Start is usually ts buffer start, except if start time of playing epg event is
 179   //         before ts buffer start, then progress start is epg event start.
 180   //       + End is usually ts buffer end, except if end time of playing epg event is
 181   //         after ts buffer end, then progress end is epg event end.
 182   //       In simple timeshift mode (settings value), progress start is always the start time of
 183   //       playing epg event and progress end is always the end time of playing epg event.
 184
 185   std::unique_lock<CCriticalSection> lock(m_critSection);
 186
 187   //////////////////////////////////////////////////////////////////////////////////////
 188   // start time
 189   //////////////////////////////////////////////////////////////////////////////////////
 190   bool bUpdatedStartTime = false;
 191   if (m_playingEpgTag)
 192   {
 193     time_t start = 0;
 194     m_playingEpgTag->StartAsUTC().GetAsTime(start);
 195     if (start < m_iTimeshiftStartTime ||
 196         CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bPVRTimeshiftSimpleOSD)
 197     {
 198       // playing event started before start of ts buffer or simple ts osd to be used
 199       m_iTimeshiftProgressStartTime = start;
 200       bUpdatedStartTime = true;
 201     }
 202   }
 203
 204   if (!bUpdatedStartTime)
 205   {
 206     // default to ts buffer start
 207     m_iTimeshiftProgressStartTime = m_iTimeshiftStartTime;
 208   }
 209
 210   //////////////////////////////////////////////////////////////////////////////////////
 211   // end time
 212   //////////////////////////////////////////////////////////////////////////////////////
 213   bool bUpdatedEndTime = false;
 214   if (m_playingEpgTag)
 215   {
 216     time_t end = 0;
 217     m_playingEpgTag->EndAsUTC().GetAsTime(end);
 218     if (end > m_iTimeshiftEndTime ||
 219         CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bPVRTimeshiftSimpleOSD)
 220     {
 221       // playing event will end after end of ts buffer or simple ts osd to be used
 222       m_iTimeshiftProgressEndTime = end;
 223       bUpdatedEndTime = true;
 224     }
 225   }
 226
 227   if (!bUpdatedEndTime)
 228   {
 229     // default to ts buffer end
 230     m_iTimeshiftProgressEndTime = m_iTimeshiftEndTime;
 231   }
 232
 233   //////////////////////////////////////////////////////////////////////////////////////
 234   // duration
 235   //////////////////////////////////////////////////////////////////////////////////////
 236   std::chrono::duration<unsigned int> duration{m_iTimeshiftProgressEndTime -
 237                                                m_iTimeshiftProgressStartTime};
 238   m_iTimeshiftProgressDuration = duration.count();
 239 }
 240
 241 void CPVRGUITimesInfo::Update()
 242 {
 243   UpdatePlayingTag();
 244   UpdateTimeshiftData();
 245 }
 246
 247 std::string CPVRGUITimesInfo::TimeToTimeString(time_t datetime, TIME_FORMAT format, bool withSeconds)
 248 {
 249   CDateTime time;
 250   time.SetFromUTCDateTime(datetime);
 251   return time.GetAsLocalizedTime(format, withSeconds);
 252 }
 253
 254 std::string CPVRGUITimesInfo::GetTimeshiftStartTime(TIME_FORMAT format) const
 255 {
 256   std::unique_lock<CCriticalSection> lock(m_critSection);
 257   return TimeToTimeString(m_iTimeshiftStartTime, format, false);
 258 }
 259
 260 std::string CPVRGUITimesInfo::GetTimeshiftEndTime(TIME_FORMAT format) const
 261 {
 262   std::unique_lock<CCriticalSection> lock(m_critSection);
 263   return TimeToTimeString(m_iTimeshiftEndTime, format, false);
 264 }
 265
 266 std::string CPVRGUITimesInfo::GetTimeshiftPlayTime(TIME_FORMAT format) const
 267 {
 268   std::unique_lock<CCriticalSection> lock(m_critSection);
 269   return TimeToTimeString(m_iTimeshiftPlayTime, format, true);
 270 }
 271
 272 std::string CPVRGUITimesInfo::GetTimeshiftOffset(TIME_FORMAT format) const
 273 {
 274   std::unique_lock<CCriticalSection> lock(m_critSection);
 275   return StringUtils::SecondsToTimeString(m_iTimeshiftOffset, format);
 276 }
 277
 278 std::string CPVRGUITimesInfo::GetTimeshiftProgressDuration(TIME_FORMAT format) const
 279 {
 280   std::unique_lock<CCriticalSection> lock(m_critSection);
 281   return StringUtils::SecondsToTimeString(m_iTimeshiftProgressDuration, format);
 282 }
 283
 284 std::string CPVRGUITimesInfo::GetTimeshiftProgressStartTime(TIME_FORMAT format) const
 285 {
 286   std::unique_lock<CCriticalSection> lock(m_critSection);
 287   return TimeToTimeString(m_iTimeshiftProgressStartTime, format, false);
 288 }
 289
 290 std::string CPVRGUITimesInfo::GetTimeshiftProgressEndTime(TIME_FORMAT format) const
 291 {
 292   std::unique_lock<CCriticalSection> lock(m_critSection);
 293   return TimeToTimeString(m_iTimeshiftProgressEndTime, format, false);
 294 }
 295
 296 std::string CPVRGUITimesInfo::GetEpgEventDuration(
 297     const std::shared_ptr<const CPVREpgInfoTag>& epgTag, TIME_FORMAT format) const
 298 {
 299   std::unique_lock<CCriticalSection> lock(m_critSection);
 300   return StringUtils::SecondsToTimeString(GetEpgEventDuration(epgTag), format);
 301 }
 302
 303 std::string CPVRGUITimesInfo::GetEpgEventElapsedTime(
 304     const std::shared_ptr<const CPVREpgInfoTag>& epgTag, TIME_FORMAT format) const
 305 {
 306   int iElapsed = 0;
 307   std::unique_lock<CCriticalSection> lock(m_critSection);
 308   if (epgTag && m_playingEpgTag && *epgTag != *m_playingEpgTag)
 309     iElapsed = epgTag->Progress();
 310   else
 311     iElapsed = GetElapsedTime();
 312
 313   return StringUtils::SecondsToTimeString(iElapsed, format);
 314 }
 315
 316 std::string CPVRGUITimesInfo::GetEpgEventRemainingTime(
 317     const std::shared_ptr<const CPVREpgInfoTag>& epgTag, TIME_FORMAT format) const
 318 {
 319   std::unique_lock<CCriticalSection> lock(m_critSection);
 320   return StringUtils::SecondsToTimeString(GetRemainingTime(epgTag), format);
 321 }
 322
 323 std::string CPVRGUITimesInfo::GetEpgEventFinishTime(
 324     const std::shared_ptr<const CPVREpgInfoTag>& epgTag, TIME_FORMAT format) const
 325 {
 326   CDateTime finish = CDateTime::GetCurrentDateTime();
 327   finish += CDateTimeSpan(0, 0, 0, GetRemainingTime(epgTag));
 328   return finish.GetAsLocalizedTime(format);
 329 }
 330
 331 std::string CPVRGUITimesInfo::GetEpgEventSeekTime(int iSeekSize, TIME_FORMAT format) const
 332 {
 333   return StringUtils::SecondsToTimeString(GetElapsedTime() + iSeekSize, format);
 334 }
 335
 336 int CPVRGUITimesInfo::GetElapsedTime() const
 337 {
 338   std::unique_lock<CCriticalSection> lock(m_critSection);
 339   if (m_playingEpgTag || m_iTimeshiftStartTime)
 340   {
 341     CDateTime current(m_iTimeshiftPlayTime);
 342     CDateTime start = m_playingEpgTag ? m_playingEpgTag->StartAsUTC() : CDateTime(m_iTimeshiftStartTime);
 343     CDateTimeSpan time = current > start ? current - start : CDateTimeSpan(0, 0, 0, 0);
 344     return time.GetSecondsTotal();
 345   }
 346   else
 347   {
 348     return 0;
 349   }
 350 }
 351
 352 int CPVRGUITimesInfo::GetRemainingTime(const std::shared_ptr<const CPVREpgInfoTag>& epgTag) const
 353 {
 354   std::unique_lock<CCriticalSection> lock(m_critSection);
 355   if (epgTag && m_playingEpgTag && *epgTag != *m_playingEpgTag)
 356     return epgTag->GetDuration() - epgTag->Progress();
 357   else
 358     return static_cast<int>(m_iDuration - GetElapsedTime());
 359 }
 360
 361 int CPVRGUITimesInfo::GetTimeshiftProgress() const
 362 {
 363   std::unique_lock<CCriticalSection> lock(m_critSection);
 364   const std::chrono::duration<double> total{m_iTimeshiftEndTime - m_iTimeshiftStartTime};
 365   if (total.count())
 366   {
 367     const std::chrono::duration<double> current{m_iTimeshiftPlayTime - m_iTimeshiftStartTime};
 368     return MathUtils::round_int(current.count() / total.count() * 100.0);
 369   }
 370   return 0;
 371 }
 372
 373 int CPVRGUITimesInfo::GetTimeshiftProgressDuration() const
 374 {
 375   std::unique_lock<CCriticalSection> lock(m_critSection);
 376   return static_cast<int>(m_iTimeshiftProgressDuration);
 377 }
 378
 379 int CPVRGUITimesInfo::GetTimeshiftProgressPlayPosition() const
 380 {
 381   std::unique_lock<CCriticalSection> lock(m_critSection);
 382   if (m_iTimeshiftProgressDuration)
 383   {
 384     const std::chrono::duration<double> duration{m_iTimeshiftPlayTime -
 385                                                  m_iTimeshiftProgressStartTime};
 386     return MathUtils::round_int(duration.count() / m_iTimeshiftProgressDuration * 100.0);
 387   }
 388   return 0;
 389 }
 390
 391 int CPVRGUITimesInfo::GetTimeshiftProgressEpgStart() const
 392 {
 393   std::unique_lock<CCriticalSection> lock(m_critSection);
 394   if (m_playingEpgTag && m_iTimeshiftProgressDuration)
 395   {
 396     time_t epgStart = 0;
 397     m_playingEpgTag->StartAsUTC().GetAsTime(epgStart);
 398     const std::chrono::duration<double> duration{epgStart - m_iTimeshiftProgressStartTime};
 399     return MathUtils::round_int(duration.count() / m_iTimeshiftProgressDuration * 100.0);
 400   }
 401   return 0;
 402 }
 403
 404 int CPVRGUITimesInfo::GetTimeshiftProgressEpgEnd() const
 405 {
 406   std::unique_lock<CCriticalSection> lock(m_critSection);
 407   if (m_playingEpgTag && m_iTimeshiftProgressDuration)
 408   {
 409     time_t epgEnd = 0;
 410     m_playingEpgTag->EndAsUTC().GetAsTime(epgEnd);
 411     const std::chrono::duration<double> duration{epgEnd - m_iTimeshiftProgressStartTime};
 412     return MathUtils::round_int(duration.count() / m_iTimeshiftProgressDuration * 100.0);
 413   }
 414   return 0;
 415 }
 416
 417 int CPVRGUITimesInfo::GetTimeshiftProgressBufferStart() const
 418 {
 419   std::unique_lock<CCriticalSection> lock(m_critSection);
 420   if (m_iTimeshiftProgressDuration)
 421   {
 422     const std::chrono::duration<double> duration{m_iTimeshiftStartTime -
 423                                                  m_iTimeshiftProgressStartTime};
 424     return MathUtils::round_int(duration.count() / m_iTimeshiftProgressDuration * 100.0);
 425   }
 426   return 0;
 427 }
 428
 429 int CPVRGUITimesInfo::GetTimeshiftProgressBufferEnd() const
 430 {
 431   std::unique_lock<CCriticalSection> lock(m_critSection);
 432   if (m_iTimeshiftProgressDuration)
 433   {
 434     const std::chrono::duration<double> duration{m_iTimeshiftEndTime -
 435                                                  m_iTimeshiftProgressStartTime};
 436     return MathUtils::round_int(duration.count() / m_iTimeshiftProgressDuration * 100.0);
 437   }
 438   return 0;
 439 }
 440
 441 int CPVRGUITimesInfo::GetEpgEventDuration(const std::shared_ptr<const CPVREpgInfoTag>& epgTag) const
 442 {
 443   std::unique_lock<CCriticalSection> lock(m_critSection);
 444   if (epgTag && m_playingEpgTag && *epgTag != *m_playingEpgTag)
 445     return epgTag->GetDuration();
 446   else
 447     return static_cast<int>(m_iDuration);
 448 }
 449
 450 int CPVRGUITimesInfo::GetEpgEventProgress(const std::shared_ptr<const CPVREpgInfoTag>& epgTag) const
 451 {
 452   std::unique_lock<CCriticalSection> lock(m_critSection);
 453   if (epgTag && m_playingEpgTag && *epgTag != *m_playingEpgTag)
 454     return MathUtils::round_int(epgTag->ProgressPercentage());
 455   else if (m_iDuration)
 456     return MathUtils::round_int(static_cast<double>(GetElapsedTime()) / m_iDuration * 100.0);
 457   else
 458     return 0;
 459 }
 460
 461 bool CPVRGUITimesInfo::IsTimeshifting() const
 462 {
 463   std::unique_lock<CCriticalSection> lock(m_critSection);
 464   return (m_iTimeshiftOffset > static_cast<unsigned int>(CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_iPVRTimeshiftThreshold));
 465 }