xbmc/application/ApplicationPowerHandling.cpp

   1 /*
   2  *  Copyright (C) 2005-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 "ApplicationPowerHandling.h"
  10
  11 #include "GUIUserMessages.h"
  12 #include "ServiceBroker.h"
  13 #include "addons/Addon.h"
  14 #include "addons/AddonManager.h"
  15 #include "addons/addoninfo/AddonType.h"
  16 #include "addons/gui/GUIDialogAddonSettings.h"
  17 #include "application/ApplicationComponents.h"
  18 #include "application/ApplicationPlayer.h"
  19 #include "guilib/GUIComponent.h"
  20 #include "guilib/GUIMessage.h"
  21 #include "guilib/GUIWindowManager.h"
  22 #include "input/actions/Action.h"
  23 #include "input/actions/ActionIDs.h"
  24 #include "interfaces/AnnouncementManager.h"
  25 #include "interfaces/generic/ScriptInvocationManager.h"
  26 #include "messaging/ApplicationMessenger.h"
  27 #include "music/MusicLibraryQueue.h"
  28 #include "powermanagement/DPMSSupport.h"
  29 #include "powermanagement/PowerTypes.h"
  30 #include "profiles/ProfileManager.h"
  31 #include "pvr/PVRManager.h"
  32 #include "pvr/guilib/PVRGUIActionsChannels.h"
  33 #include "pvr/guilib/PVRGUIActionsPowerManagement.h"
  34 #include "settings/Settings.h"
  35 #include "settings/SettingsComponent.h"
  36 #include "utils/AlarmClock.h"
  37 #include "utils/log.h"
  38 #include "video/VideoLibraryQueue.h"
  39 #include "windowing/WinSystem.h"
  40
  41 void CApplicationPowerHandling::ResetScreenSaver()
  42 {
  43   // reset our timers
  44   m_shutdownTimer.StartZero();
  45
  46   // screen saver timer is reset only if we're not already in screensaver or
  47   // DPMS mode
  48   if ((!m_screensaverActive && m_iScreenSaveLock == 0) && !m_dpmsIsActive)
  49     ResetScreenSaverTimer();
  50 }
  51
  52 void CApplicationPowerHandling::ResetScreenSaverTimer()
  53 {
  54   m_screenSaverTimer.StartZero();
  55 }
  56
  57 void CApplicationPowerHandling::ResetSystemIdleTimer()
  58 {
  59   // reset system idle timer
  60   m_idleTimer.StartZero();
  61 }
  62
  63 void CApplicationPowerHandling::ResetNavigationTimer()
  64 {
  65   m_navigationTimer.StartZero();
  66 }
  67
  68 void CApplicationPowerHandling::SetRenderGUI(bool renderGUI)
  69 {
  70   m_renderGUI = renderGUI;
  71 }
  72
  73 void CApplicationPowerHandling::StopScreenSaverTimer()
  74 {
  75   m_screenSaverTimer.Stop();
  76 }
  77
  78 bool CApplicationPowerHandling::ToggleDPMS(bool manual)
  79 {
  80   auto winSystem = CServiceBroker::GetWinSystem();
  81   if (!winSystem)
  82     return false;
  83
  84   std::shared_ptr<CDPMSSupport> dpms = winSystem->GetDPMSManager();
  85   if (!dpms)
  86     return false;
  87
  88   if (manual || (m_dpmsIsManual == manual))
  89   {
  90     if (m_dpmsIsActive)
  91     {
  92       m_dpmsIsActive = false;
  93       m_dpmsIsManual = false;
  94       SetRenderGUI(true);
  95       CheckOSScreenSaverInhibitionSetting();
  96       CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::GUI, "OnDPMSDeactivated");
  97       return dpms->DisablePowerSaving();
  98     }
  99     else
 100     {
 101       if (dpms->EnablePowerSaving(dpms->GetSupportedModes()[0]))
 102       {
 103         m_dpmsIsActive = true;
 104         m_dpmsIsManual = manual;
 105         SetRenderGUI(false);
 106         CheckOSScreenSaverInhibitionSetting();
 107         CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::GUI, "OnDPMSActivated");
 108         return true;
 109       }
 110     }
 111   }
 112   return false;
 113 }
 114
 115 bool CApplicationPowerHandling::WakeUpScreenSaverAndDPMS(bool bPowerOffKeyPressed /* = false */)
 116 {
 117   bool result = false;
 118
 119   // First reset DPMS, if active
 120   if (m_dpmsIsActive)
 121   {
 122     if (m_dpmsIsManual)
 123       return false;
 124     //! @todo if screensaver lock is specified but screensaver is not active
 125     //! (DPMS came first), activate screensaver now.
 126     ToggleDPMS(false);
 127     ResetScreenSaverTimer();
 128     result = !m_screensaverActive || WakeUpScreenSaver(bPowerOffKeyPressed);
 129   }
 130   else if (m_screensaverActive)
 131     result = WakeUpScreenSaver(bPowerOffKeyPressed);
 132
 133   if (result)
 134   {
 135     // allow listeners to ignore the deactivation if it precedes a powerdown/suspend etc
 136     CVariant data(CVariant::VariantTypeObject);
 137     data["shuttingdown"] = bPowerOffKeyPressed;
 138     CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::GUI,
 139                                                        "OnScreensaverDeactivated", data);
 140   }
 141
 142   return result;
 143 }
 144
 145 bool CApplicationPowerHandling::WakeUpScreenSaver(bool bPowerOffKeyPressed /* = false */)
 146 {
 147   if (m_iScreenSaveLock == 2)
 148     return false;
 149
 150   // if Screen saver is active
 151   if (m_screensaverActive && !m_screensaverIdInUse.empty())
 152   {
 153     if (m_iScreenSaveLock == 0)
 154     {
 155       const std::shared_ptr<CProfileManager> profileManager =
 156           CServiceBroker::GetSettingsComponent()->GetProfileManager();
 157       if (profileManager->GetMasterProfile().getLockMode() != LockMode::EVERYONE &&
 158           (profileManager->UsingLoginScreen() ||
 159            CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 160                CSettings::SETTING_MASTERLOCK_STARTUPLOCK)) &&
 161           profileManager->GetCurrentProfile().getLockMode() != LockMode::EVERYONE &&
 162           m_screensaverIdInUse != "screensaver.xbmc.builtin.dim" &&
 163           m_screensaverIdInUse != "screensaver.xbmc.builtin.black" &&
 164           m_screensaverIdInUse != "visualization")
 165       {
 166         m_iScreenSaveLock = 2;
 167         CGUIMessage msg(GUI_MSG_CHECK_LOCK, 0, 0);
 168
 169         CGUIWindow* pWindow =
 170             CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SCREENSAVER);
 171         if (pWindow)
 172           pWindow->OnMessage(msg);
 173       }
 174     }
 175     if (m_iScreenSaveLock == -1)
 176     {
 177       m_iScreenSaveLock = 0;
 178       return true;
 179     }
 180
 181     // disable screensaver
 182     m_screensaverActive = false;
 183     m_iScreenSaveLock = 0;
 184     ResetScreenSaverTimer();
 185
 186     if (m_screensaverIdInUse == "visualization")
 187     {
 188       // we can just continue as usual from vis mode
 189       return false;
 190     }
 191     else if (m_screensaverIdInUse == "screensaver.xbmc.builtin.dim" ||
 192              m_screensaverIdInUse == "screensaver.xbmc.builtin.black" ||
 193              m_screensaverIdInUse.empty())
 194     {
 195       return true;
 196     }
 197     else
 198     { // we're in screensaver window
 199       if (m_pythonScreenSaver)
 200       {
 201 // What sound does a python screensaver make?
 202 #define SCRIPT_ALARM "sssssscreensaver"
 203 #define SCRIPT_TIMEOUT 15 // seconds
 204
 205         /* FIXME: This is a hack but a proper fix is non-trivial. Basically this code
 206         * makes sure the addon gets terminated after we've moved out of the screensaver window.
 207         * If we don't do this, we may simply lockup.
 208         */
 209         g_alarmClock.Start(SCRIPT_ALARM, SCRIPT_TIMEOUT,
 210                            "StopScript(" + m_pythonScreenSaver->LibPath() + ")", true, false);
 211         m_pythonScreenSaver.reset();
 212       }
 213       if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_SCREENSAVER)
 214         CServiceBroker::GetGUI()->GetWindowManager().PreviousWindow(); // show the previous window
 215       else if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_SLIDESHOW)
 216         CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ACTION, WINDOW_SLIDESHOW, -1,
 217                                                    static_cast<void*>(new CAction(ACTION_STOP)));
 218     }
 219     return true;
 220   }
 221   else
 222     return false;
 223 }
 224
 225 void CApplicationPowerHandling::CheckOSScreenSaverInhibitionSetting()
 226 {
 227   // Kodi screen saver overrides OS one: always inhibit OS screen saver then
 228   // except when DPMS is active (inhibiting the screen saver then might also
 229   // disable DPMS again)
 230   if (!m_dpmsIsActive &&
 231       !CServiceBroker::GetSettingsComponent()
 232            ->GetSettings()
 233            ->GetString(CSettings::SETTING_SCREENSAVER_MODE)
 234            .empty() &&
 235       CServiceBroker::GetWinSystem()->GetOSScreenSaver())
 236   {
 237     if (!m_globalScreensaverInhibitor)
 238     {
 239       m_globalScreensaverInhibitor =
 240           CServiceBroker::GetWinSystem()->GetOSScreenSaver()->CreateInhibitor();
 241     }
 242   }
 243   else if (m_globalScreensaverInhibitor)
 244   {
 245     m_globalScreensaverInhibitor.Release();
 246   }
 247 }
 248
 249 void CApplicationPowerHandling::CheckScreenSaverAndDPMS()
 250 {
 251   bool maybeScreensaver = true;
 252   if (m_dpmsIsActive)
 253     maybeScreensaver = false;
 254   else if (m_screensaverActive)
 255     maybeScreensaver = false;
 256   else if (CServiceBroker::GetSettingsComponent()
 257                ->GetSettings()
 258                ->GetString(CSettings::SETTING_SCREENSAVER_MODE)
 259                .empty())
 260     maybeScreensaver = false;
 261
 262   auto winSystem = CServiceBroker::GetWinSystem();
 263   if (!winSystem)
 264     return;
 265
 266   std::shared_ptr<CDPMSSupport> dpms = winSystem->GetDPMSManager();
 267
 268   bool maybeDPMS = true;
 269   if (m_dpmsIsActive)
 270     maybeDPMS = false;
 271   else if (!dpms || !dpms->IsSupported())
 272     maybeDPMS = false;
 273   else if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 274                CSettings::SETTING_POWERMANAGEMENT_DISPLAYSOFF) <= 0)
 275     maybeDPMS = false;
 276
 277   // whether the current state of the application should be regarded as active even when there is no
 278   // explicit user activity such as input
 279   bool haveIdleActivity = false;
 280
 281   if (m_bResetScreenSaver)
 282   {
 283     m_bResetScreenSaver = false;
 284     haveIdleActivity = true;
 285   }
 286
 287   // When inhibit screensaver is enabled prevent screensaver from kicking in
 288   if (m_bInhibitScreenSaver)
 289     haveIdleActivity = true;
 290
 291   // Are we playing a video and it is not paused?
 292   const auto& components = CServiceBroker::GetAppComponents();
 293   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 294   if (appPlayer && appPlayer->IsPlayingVideo() && !appPlayer->IsPaused())
 295     haveIdleActivity = true;
 296
 297   // Are we playing audio and screensaver is disabled globally for audio?
 298   else if (appPlayer && appPlayer->IsPlayingAudio() &&
 299            CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 300                CSettings::SETTING_SCREENSAVER_DISABLEFORAUDIO))
 301   {
 302     haveIdleActivity = true;
 303   }
 304
 305   // Handle OS screen saver state
 306   if (haveIdleActivity && CServiceBroker::GetWinSystem()->GetOSScreenSaver())
 307   {
 308     // Always inhibit OS screen saver during these kinds of activities
 309     if (!m_screensaverInhibitor)
 310     {
 311       m_screensaverInhibitor =
 312           CServiceBroker::GetWinSystem()->GetOSScreenSaver()->CreateInhibitor();
 313     }
 314   }
 315   else if (m_screensaverInhibitor)
 316   {
 317     m_screensaverInhibitor.Release();
 318   }
 319
 320   // Has the screen saver window become active?
 321   if (maybeScreensaver &&
 322       CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(WINDOW_SCREENSAVER))
 323   {
 324     m_screensaverActive = true;
 325     maybeScreensaver = false;
 326   }
 327
 328   if (m_screensaverActive && haveIdleActivity)
 329   {
 330     WakeUpScreenSaverAndDPMS();
 331     return;
 332   }
 333
 334   if (!maybeScreensaver && !maybeDPMS)
 335     return; // Nothing to do.
 336
 337   // See if we need to reset timer.
 338   if (haveIdleActivity)
 339   {
 340     ResetScreenSaverTimer();
 341     return;
 342   }
 343
 344   float elapsed = m_screenSaverTimer.IsRunning() ? m_screenSaverTimer.GetElapsedSeconds() : 0.f;
 345
 346   // DPMS has priority (it makes the screensaver not needed)
 347   if (maybeDPMS && elapsed > CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 348                                  CSettings::SETTING_POWERMANAGEMENT_DISPLAYSOFF) *
 349                                  60)
 350   {
 351     ToggleDPMS(false);
 352     WakeUpScreenSaver();
 353   }
 354   else if (maybeScreensaver &&
 355            elapsed > CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 356                          CSettings::SETTING_SCREENSAVER_TIME) *
 357                          60)
 358   {
 359     ActivateScreenSaver();
 360   }
 361 }
 362
 363 // activate the screensaver.
 364 // if forceType is true, we ignore the various conditions that can alter
 365 // the type of screensaver displayed
 366 void CApplicationPowerHandling::ActivateScreenSaver(bool forceType /*= false */)
 367 {
 368   const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
 369   const auto& components = CServiceBroker::GetAppComponents();
 370   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 371
 372   m_screensaverActive = true;
 373   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::GUI, "OnScreensaverActivated");
 374
 375   // disable screensaver lock from the login screen
 376   m_iScreenSaveLock =
 377       CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_LOGIN_SCREEN ? 1 : 0;
 378
 379   m_screensaverIdInUse = settings->GetString(CSettings::SETTING_SCREENSAVER_MODE);
 380
 381   if (!forceType)
 382   {
 383     if (m_screensaverIdInUse == "screensaver.xbmc.builtin.dim" ||
 384         m_screensaverIdInUse == "screensaver.xbmc.builtin.black" || m_screensaverIdInUse.empty())
 385     {
 386       return;
 387     }
 388
 389     // Enforce Dim for special cases.
 390     bool bUseDim = false;
 391     if (appPlayer && appPlayer->IsPlayingVideo() &&
 392         settings->GetBool(CSettings::SETTING_SCREENSAVER_USEDIMONPAUSE))
 393       bUseDim = true;
 394     else if (CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().IsRunningChannelScan())
 395       bUseDim = true;
 396
 397     if (bUseDim)
 398       m_screensaverIdInUse = "screensaver.xbmc.builtin.dim";
 399   }
 400
 401   if (m_screensaverIdInUse == "screensaver.xbmc.builtin.dim" ||
 402       m_screensaverIdInUse == "screensaver.xbmc.builtin.black" || m_screensaverIdInUse.empty())
 403   {
 404     return;
 405   }
 406   else if (CServiceBroker::GetAddonMgr().GetAddon(m_screensaverIdInUse, m_pythonScreenSaver,
 407                                                   ADDON::AddonType::SCREENSAVER,
 408                                                   ADDON::OnlyEnabled::CHOICE_YES))
 409   {
 410     std::string libPath = m_pythonScreenSaver->LibPath();
 411     if (CScriptInvocationManager::GetInstance().HasLanguageInvoker(libPath))
 412     {
 413       CLog::Log(LOGDEBUG, "using python screensaver add-on {}", m_screensaverIdInUse);
 414
 415       // Don't allow a previously-scheduled alarm to kill our new screensaver
 416       g_alarmClock.Stop(SCRIPT_ALARM, true);
 417
 418       if (!CScriptInvocationManager::GetInstance().Stop(libPath))
 419         CScriptInvocationManager::GetInstance().ExecuteAsync(
 420             libPath,
 421             ADDON::AddonPtr(new ADDON::CAddon(dynamic_cast<ADDON::CAddon&>(*m_pythonScreenSaver))));
 422       return;
 423     }
 424     m_pythonScreenSaver.reset();
 425   }
 426
 427   CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SCREENSAVER);
 428 }
 429
 430 void CApplicationPowerHandling::InhibitScreenSaver(bool inhibit)
 431 {
 432   m_bInhibitScreenSaver = inhibit;
 433 }
 434
 435 bool CApplicationPowerHandling::IsScreenSaverInhibited() const
 436 {
 437   return m_bInhibitScreenSaver;
 438 }
 439
 440 // Global Idle Time in Seconds
 441 // idle time will be reset if on any OnKey()
 442 // int return: system Idle time in seconds! 0 is no idle!
 443 int CApplicationPowerHandling::GlobalIdleTime()
 444 {
 445   if (!m_idleTimer.IsRunning())
 446     m_idleTimer.StartZero();
 447   return (int)m_idleTimer.GetElapsedSeconds();
 448 }
 449
 450 float CApplicationPowerHandling::NavigationIdleTime()
 451 {
 452   if (!m_navigationTimer.IsRunning())
 453     m_navigationTimer.StartZero();
 454   return m_navigationTimer.GetElapsedSeconds();
 455 }
 456
 457 void CApplicationPowerHandling::StopShutdownTimer()
 458 {
 459   m_shutdownTimer.Stop();
 460 }
 461
 462 void CApplicationPowerHandling::ResetShutdownTimers()
 463 {
 464   // reset system shutdown timer
 465   m_shutdownTimer.StartZero();
 466
 467   // delete custom shutdown timer
 468   if (g_alarmClock.HasAlarm("shutdowntimer"))
 469     g_alarmClock.Stop("shutdowntimer", true);
 470 }
 471
 472 void CApplicationPowerHandling::HandleShutdownMessage()
 473 {
 474   switch (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 475       CSettings::SETTING_POWERMANAGEMENT_SHUTDOWNSTATE))
 476   {
 477     case POWERSTATE_SHUTDOWN:
 478       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_POWERDOWN);
 479       break;
 480
 481     case POWERSTATE_SUSPEND:
 482       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SUSPEND);
 483       break;
 484
 485     case POWERSTATE_HIBERNATE:
 486       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_HIBERNATE);
 487       break;
 488
 489     case POWERSTATE_QUIT:
 490       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_QUIT);
 491       break;
 492
 493     case POWERSTATE_MINIMIZE:
 494       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_MINIMIZE);
 495       break;
 496
 497     default:
 498       CLog::Log(LOGERROR, "{}: No valid shutdownstate matched", __FUNCTION__);
 499       break;
 500   }
 501 }
 502
 503 void CApplicationPowerHandling::CheckShutdown()
 504 {
 505   // first check if we should reset the timer
 506   const auto& components = CServiceBroker::GetAppComponents();
 507   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 508   if (!appPlayer)
 509     return;
 510
 511   if (m_bInhibitIdleShutdown || appPlayer->IsPlaying() ||
 512       appPlayer->IsPausedPlayback() // is something playing?
 513       || CMusicLibraryQueue::GetInstance().IsRunning() ||
 514       CVideoLibraryQueue::GetInstance().IsRunning() ||
 515       CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(
 516           WINDOW_DIALOG_PROGRESS) // progress dialog is onscreen
 517       ||
 518       !CServiceBroker::GetPVRManager().Get<PVR::GUI::PowerManagement>().CanSystemPowerdown(false))
 519   {
 520     m_shutdownTimer.StartZero();
 521     return;
 522   }
 523
 524   float elapsed = m_shutdownTimer.IsRunning() ? m_shutdownTimer.GetElapsedSeconds() : 0.f;
 525   if (elapsed > CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 526                     CSettings::SETTING_POWERMANAGEMENT_SHUTDOWNTIME) *
 527                     60)
 528   {
 529     // Since it is a sleep instead of a shutdown, let's set everything to reset when we wake up.
 530     m_shutdownTimer.Stop();
 531
 532     // Sleep the box
 533     CLog::LogF(LOGDEBUG, "Timer is over (shutdown function: {})",
 534                CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 535                    CSettings::SETTING_POWERMANAGEMENT_SHUTDOWNSTATE));
 536     CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SHUTDOWN);
 537   }
 538 }
 539
 540 void CApplicationPowerHandling::InhibitIdleShutdown(bool inhibit)
 541 {
 542   m_bInhibitIdleShutdown = inhibit;
 543 }
 544
 545 bool CApplicationPowerHandling::IsIdleShutdownInhibited() const
 546 {
 547   return m_bInhibitIdleShutdown;
 548 }
 549
 550 bool CApplicationPowerHandling::OnSettingChanged(const CSetting& setting)
 551 {
 552   const std::string& settingId = setting.GetId();
 553
 554   if (settingId == CSettings::SETTING_SCREENSAVER_MODE)
 555   {
 556     CheckOSScreenSaverInhibitionSetting();
 557   }
 558   else
 559     return false;
 560
 561   return true;
 562 }
 563
 564 bool CApplicationPowerHandling::OnSettingAction(const CSetting& setting)
 565 {
 566   const std::string& settingId = setting.GetId();
 567
 568   if (settingId == CSettings::SETTING_SCREENSAVER_PREVIEW)
 569     ActivateScreenSaver(true);
 570   else if (settingId == CSettings::SETTING_SCREENSAVER_SETTINGS)
 571   {
 572     ADDON::AddonPtr addon;
 573     if (CServiceBroker::GetAddonMgr().GetAddon(
 574             CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(
 575                 CSettings::SETTING_SCREENSAVER_MODE),
 576             addon, ADDON::AddonType::SCREENSAVER, ADDON::OnlyEnabled::CHOICE_YES))
 577       CGUIDialogAddonSettings::ShowForAddon(addon);
 578   }
 579   else
 580     return false;
 581
 582   return true;
 583 }