xbmc/ServiceBroker.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 "ServiceBroker.h"
  10
  11 #include "ServiceManager.h"
  12 #include "application/Application.h"
  13 #include "profiles/ProfileManager.h"
  14 #include "settings/SettingsComponent.h"
  15 #include "utils/log.h"
  16 #include "windowing/WinSystem.h"
  17
  18 #include <stdexcept>
  19 #include <utility>
  20
  21 using namespace KODI;
  22
  23 CServiceBroker::CServiceBroker()
  24   : m_pGUI(nullptr), m_pWinSystem(nullptr), m_pActiveAE(nullptr), m_decoderFilterManager(nullptr)
  25 {
  26 }
  27
  28 CServiceBroker::~CServiceBroker()
  29 {
  30 }
  31
  32 std::shared_ptr<CAppParams> CServiceBroker::GetAppParams()
  33 {
  34   if (!g_serviceBroker.m_appParams)
  35     throw std::logic_error("AppParams not yet available / not available anymore.");
  36
  37   return g_serviceBroker.m_appParams;
  38 }
  39
  40 void CServiceBroker::RegisterAppParams(const std::shared_ptr<CAppParams>& appParams)
  41 {
  42   g_serviceBroker.m_appParams = appParams;
  43 }
  44
  45 void CServiceBroker::UnregisterAppParams()
  46 {
  47   g_serviceBroker.m_appParams.reset();
  48 }
  49
  50 CLog& CServiceBroker::GetLogging()
  51 {
  52   return *(g_serviceBroker.m_logging);
  53 }
  54
  55 void CServiceBroker::CreateLogging()
  56 {
  57   g_serviceBroker.m_logging = std::make_unique<CLog>();
  58 }
  59
  60 void CServiceBroker::DestroyLogging()
  61 {
  62   g_serviceBroker.m_logging.reset();
  63 }
  64
  65 // announcement
  66 std::shared_ptr<ANNOUNCEMENT::CAnnouncementManager> CServiceBroker::GetAnnouncementManager()
  67 {
  68   return g_serviceBroker.m_pAnnouncementManager;
  69 }
  70 void CServiceBroker::RegisterAnnouncementManager(
  71     std::shared_ptr<ANNOUNCEMENT::CAnnouncementManager> port)
  72 {
  73   g_serviceBroker.m_pAnnouncementManager = std::move(port);
  74 }
  75
  76 void CServiceBroker::UnregisterAnnouncementManager()
  77 {
  78   g_serviceBroker.m_pAnnouncementManager.reset();
  79 }
  80
  81 ADDON::CAddonMgr& CServiceBroker::GetAddonMgr()
  82 {
  83   return g_application.m_ServiceManager->GetAddonMgr();
  84 }
  85
  86 ADDON::CBinaryAddonManager& CServiceBroker::GetBinaryAddonManager()
  87 {
  88   return g_application.m_ServiceManager->GetBinaryAddonManager();
  89 }
  90
  91 ADDON::CBinaryAddonCache& CServiceBroker::GetBinaryAddonCache()
  92 {
  93   return g_application.m_ServiceManager->GetBinaryAddonCache();
  94 }
  95
  96 ADDONS::CExtsMimeSupportList& CServiceBroker::GetExtsMimeSupportList()
  97 {
  98   return g_application.m_ServiceManager->GetExtsMimeSupportList();
  99 }
 100
 101 ADDON::CVFSAddonCache& CServiceBroker::GetVFSAddonCache()
 102 {
 103   return g_application.m_ServiceManager->GetVFSAddonCache();
 104 }
 105
 106 #ifdef HAS_PYTHON
 107 XBPython& CServiceBroker::GetXBPython()
 108 {
 109   return g_application.m_ServiceManager->GetXBPython();
 110 }
 111 #endif
 112
 113 #if defined(HAS_FILESYSTEM_SMB)
 114 WSDiscovery::IWSDiscovery& CServiceBroker::GetWSDiscovery()
 115 {
 116   return g_application.m_ServiceManager->GetWSDiscovery();
 117 }
 118 #endif
 119
 120 #if !defined(TARGET_WINDOWS) && defined(HAS_DVD_DRIVE)
 121 MEDIA_DETECT::CDetectDVDMedia& CServiceBroker::GetDetectDVDMedia()
 122 {
 123   return g_application.m_ServiceManager->GetDetectDVDMedia();
 124 }
 125 #endif
 126
 127 PVR::CPVRManager& CServiceBroker::GetPVRManager()
 128 {
 129   return g_application.m_ServiceManager->GetPVRManager();
 130 }
 131
 132 CContextMenuManager& CServiceBroker::GetContextMenuManager()
 133 {
 134   return g_application.m_ServiceManager->GetContextMenuManager();
 135 }
 136
 137 CDataCacheCore& CServiceBroker::GetDataCacheCore()
 138 {
 139   return g_application.m_ServiceManager->GetDataCacheCore();
 140 }
 141
 142 CPlatform& CServiceBroker::GetPlatform()
 143 {
 144   return g_application.m_ServiceManager->GetPlatform();
 145 }
 146
 147 PLAYLIST::CPlayListPlayer& CServiceBroker::GetPlaylistPlayer()
 148 {
 149   return g_application.m_ServiceManager->GetPlaylistPlayer();
 150 }
 151
 152 void CServiceBroker::RegisterSettingsComponent(const std::shared_ptr<CSettingsComponent>& settings)
 153 {
 154   g_serviceBroker.m_pSettingsComponent = settings;
 155 }
 156
 157 void CServiceBroker::UnregisterSettingsComponent()
 158 {
 159   g_serviceBroker.m_pSettingsComponent.reset();
 160 }
 161
 162 std::shared_ptr<CSettingsComponent> CServiceBroker::GetSettingsComponent()
 163 {
 164   return g_serviceBroker.m_pSettingsComponent;
 165 }
 166
 167 GAME::CControllerManager& CServiceBroker::GetGameControllerManager()
 168 {
 169   return g_application.m_ServiceManager->GetGameControllerManager();
 170 }
 171
 172 GAME::CGameServices& CServiceBroker::GetGameServices()
 173 {
 174   return g_application.m_ServiceManager->GetGameServices();
 175 }
 176
 177 KODI::RETRO::CGUIGameRenderManager& CServiceBroker::GetGameRenderManager()
 178 {
 179   return g_application.m_ServiceManager->GetGameRenderManager();
 180 }
 181
 182 PERIPHERALS::CPeripherals& CServiceBroker::GetPeripherals()
 183 {
 184   return g_application.m_ServiceManager->GetPeripherals();
 185 }
 186
 187 CFavouritesService& CServiceBroker::GetFavouritesService()
 188 {
 189   return g_application.m_ServiceManager->GetFavouritesService();
 190 }
 191
 192 ADDON::CServiceAddonManager& CServiceBroker::GetServiceAddons()
 193 {
 194   return g_application.m_ServiceManager->GetServiceAddons();
 195 }
 196
 197 ADDON::CRepositoryUpdater& CServiceBroker::GetRepositoryUpdater()
 198 {
 199   return g_application.m_ServiceManager->GetRepositoryUpdater();
 200 }
 201
 202 CInputManager& CServiceBroker::GetInputManager()
 203 {
 204   return g_application.m_ServiceManager->GetInputManager();
 205 }
 206
 207 CFileExtensionProvider& CServiceBroker::GetFileExtensionProvider()
 208 {
 209   return g_application.m_ServiceManager->GetFileExtensionProvider();
 210 }
 211
 212 CNetworkBase& CServiceBroker::GetNetwork()
 213 {
 214   return g_application.m_ServiceManager->GetNetwork();
 215 }
 216
 217 bool CServiceBroker::IsAddonInterfaceUp()
 218 {
 219   return g_application.m_ServiceManager && g_application.m_ServiceManager->init_level > 1;
 220 }
 221
 222 bool CServiceBroker::IsServiceManagerUp()
 223 {
 224   return g_application.m_ServiceManager && g_application.m_ServiceManager->init_level == 3;
 225 }
 226
 227 CWinSystemBase* CServiceBroker::GetWinSystem()
 228 {
 229   return g_serviceBroker.m_pWinSystem;
 230 }
 231
 232 void CServiceBroker::RegisterWinSystem(CWinSystemBase* winsystem)
 233 {
 234   g_serviceBroker.m_pWinSystem = winsystem;
 235 }
 236
 237 void CServiceBroker::UnregisterWinSystem()
 238 {
 239   g_serviceBroker.m_pWinSystem = nullptr;
 240 }
 241
 242 CRenderSystemBase* CServiceBroker::GetRenderSystem()
 243 {
 244   if (g_serviceBroker.m_pWinSystem)
 245     return g_serviceBroker.m_pWinSystem->GetRenderSystem();
 246
 247   return nullptr;
 248 }
 249
 250 CPowerManager& CServiceBroker::GetPowerManager()
 251 {
 252   return g_application.m_ServiceManager->GetPowerManager();
 253 }
 254
 255 CWeatherManager& CServiceBroker::GetWeatherManager()
 256 {
 257   return g_application.m_ServiceManager->GetWeatherManager();
 258 }
 259
 260 CPlayerCoreFactory& CServiceBroker::GetPlayerCoreFactory()
 261 {
 262   return g_application.m_ServiceManager->GetPlayerCoreFactory();
 263 }
 264
 265 CDatabaseManager& CServiceBroker::GetDatabaseManager()
 266 {
 267   return g_application.m_ServiceManager->GetDatabaseManager();
 268 }
 269
 270 CEventLog* CServiceBroker::GetEventLog()
 271 {
 272   if (!g_serviceBroker.m_pSettingsComponent)
 273     return nullptr;
 274
 275   auto profileManager = g_serviceBroker.m_pSettingsComponent->GetProfileManager();
 276   if (!profileManager)
 277     return nullptr;
 278
 279   return &profileManager->GetEventLog();
 280 }
 281
 282 CMediaManager& CServiceBroker::GetMediaManager()
 283 {
 284   return g_application.m_ServiceManager->GetMediaManager();
 285 }
 286
 287 CApplicationComponents& CServiceBroker::GetAppComponents()
 288 {
 289   return g_application;
 290 }
 291
 292 CGUIComponent* CServiceBroker::GetGUI()
 293 {
 294   return g_serviceBroker.m_pGUI;
 295 }
 296
 297 void CServiceBroker::RegisterGUI(CGUIComponent* gui)
 298 {
 299   g_serviceBroker.m_pGUI = gui;
 300 }
 301
 302 void CServiceBroker::UnregisterGUI()
 303 {
 304   g_serviceBroker.m_pGUI = nullptr;
 305 }
 306
 307 // audio
 308 IAE* CServiceBroker::GetActiveAE()
 309 {
 310   return g_serviceBroker.m_pActiveAE;
 311 }
 312 void CServiceBroker::RegisterAE(IAE* ae)
 313 {
 314   g_serviceBroker.m_pActiveAE = ae;
 315 }
 316 void CServiceBroker::UnregisterAE()
 317 {
 318   g_serviceBroker.m_pActiveAE = nullptr;
 319 }
 320
 321 // application
 322 std::shared_ptr<CAppInboundProtocol> CServiceBroker::GetAppPort()
 323 {
 324   return g_serviceBroker.m_pAppPort;
 325 }
 326 void CServiceBroker::RegisterAppPort(std::shared_ptr<CAppInboundProtocol> port)
 327 {
 328   g_serviceBroker.m_pAppPort = std::move(port);
 329 }
 330 void CServiceBroker::UnregisterAppPort()
 331 {
 332   g_serviceBroker.m_pAppPort.reset();
 333 }
 334
 335 void CServiceBroker::RegisterDecoderFilterManager(CDecoderFilterManager* manager)
 336 {
 337   g_serviceBroker.m_decoderFilterManager = manager;
 338 }
 339
 340 CDecoderFilterManager* CServiceBroker::GetDecoderFilterManager()
 341 {
 342   return g_serviceBroker.m_decoderFilterManager;
 343 }
 344
 345 std::shared_ptr<CCPUInfo> CServiceBroker::GetCPUInfo()
 346 {
 347   return g_serviceBroker.m_cpuInfo;
 348 }
 349
 350 void CServiceBroker::RegisterCPUInfo(std::shared_ptr<CCPUInfo> cpuInfo)
 351 {
 352   g_serviceBroker.m_cpuInfo = std::move(cpuInfo);
 353 }
 354
 355 void CServiceBroker::UnregisterCPUInfo()
 356 {
 357   g_serviceBroker.m_cpuInfo.reset();
 358 }
 359
 360 void CServiceBroker::RegisterTextureCache(const std::shared_ptr<CTextureCache>& cache)
 361 {
 362   g_serviceBroker.m_textureCache = cache;
 363 }
 364
 365 void CServiceBroker::UnregisterTextureCache()
 366 {
 367   g_serviceBroker.m_textureCache.reset();
 368 }
 369
 370 std::shared_ptr<CTextureCache> CServiceBroker::GetTextureCache()
 371 {
 372   return g_serviceBroker.m_textureCache;
 373 }
 374
 375 void CServiceBroker::RegisterJobManager(const std::shared_ptr<CJobManager>& jobManager)
 376 {
 377   g_serviceBroker.m_jobManager = jobManager;
 378 }
 379
 380 void CServiceBroker::UnregisterJobManager()
 381 {
 382   g_serviceBroker.m_jobManager.reset();
 383 }
 384
 385 std::shared_ptr<CJobManager> CServiceBroker::GetJobManager()
 386 {
 387   return g_serviceBroker.m_jobManager;
 388 }
 389
 390 void CServiceBroker::RegisterAppMessenger(
 391     const std::shared_ptr<KODI::MESSAGING::CApplicationMessenger>& appMessenger)
 392 {
 393   g_serviceBroker.m_appMessenger = appMessenger;
 394 }
 395
 396 void CServiceBroker::UnregisterAppMessenger()
 397 {
 398   g_serviceBroker.m_appMessenger.reset();
 399 }
 400
 401 std::shared_ptr<KODI::MESSAGING::CApplicationMessenger> CServiceBroker::GetAppMessenger()
 402 {
 403   return g_serviceBroker.m_appMessenger;
 404 }
 405
 406 void CServiceBroker::RegisterKeyboardLayoutManager(
 407     const std::shared_ptr<CKeyboardLayoutManager>& keyboardLayoutManager)
 408 {
 409   g_serviceBroker.m_keyboardLayoutManager = keyboardLayoutManager;
 410 }
 411
 412 void CServiceBroker::UnregisterKeyboardLayoutManager()
 413 {
 414   g_serviceBroker.m_keyboardLayoutManager.reset();
 415 }
 416
 417 std::shared_ptr<CKeyboardLayoutManager> CServiceBroker::GetKeyboardLayoutManager()
 418 {
 419   return g_serviceBroker.m_keyboardLayoutManager;
 420 }
 421
 422 void CServiceBroker::RegisterSpeechRecognition(
 423     const std::shared_ptr<speech::ISpeechRecognition>& speechRecognition)
 424 {
 425   g_serviceBroker.m_speechRecognition = speechRecognition;
 426 }
 427
 428 void CServiceBroker::UnregisterSpeechRecognition()
 429 {
 430   g_serviceBroker.m_speechRecognition.reset();
 431 }
 432
 433 std::shared_ptr<speech::ISpeechRecognition> CServiceBroker::GetSpeechRecognition()
 434 {
 435   return g_serviceBroker.m_speechRecognition;
 436 }