xbmc/ServiceManager.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 "ServiceManager.h"
  10
  11 #include "ContextMenuManager.h"
  12 #include "DatabaseManager.h"
  13 #include "PlayListPlayer.h"
  14 #include "addons/AddonManager.h"
  15 #include "addons/BinaryAddonCache.h"
  16 #include "addons/ExtsMimeSupportList.h"
  17 #include "addons/RepositoryUpdater.h"
  18 #include "addons/Service.h"
  19 #include "addons/VFSEntry.h"
  20 #include "addons/binary-addons/BinaryAddonManager.h"
  21 #include "cores/DataCacheCore.h"
  22 #include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
  23 #include "cores/playercorefactory/PlayerCoreFactory.h"
  24 #include "favourites/FavouritesService.h"
  25 #include "games/GameServices.h"
  26 #include "games/controllers/ControllerManager.h"
  27 #include "input/InputManager.h"
  28 #include "interfaces/generic/ScriptInvocationManager.h"
  29 #include "interfaces/python/XBPython.h"
  30 #include "network/Network.h"
  31 #include "peripherals/Peripherals.h"
  32 #if defined(HAS_FILESYSTEM_SMB)
  33 #include "network/IWSDiscovery.h"
  34 #if defined(TARGET_WINDOWS)
  35 #include "platform/win32/network/WSDiscoveryWin32.h"
  36 #else // !defined(TARGET_WINDOWS)
  37 #include "platform/posix/filesystem/SMBWSDiscovery.h"
  38 #endif // defined(TARGET_WINDOWS)
  39 #endif // HAS_FILESYSTEM_SMB
  40 #include "powermanagement/PowerManager.h"
  41 #include "profiles/ProfileManager.h"
  42 #include "pvr/PVRManager.h"
  43 #if !defined(TARGET_WINDOWS) && defined(HAS_OPTICAL_DRIVE)
  44 #include "storage/DetectDVDType.h"
  45 #endif
  46 #include "pictures/SlideShowDelegator.h"
  47 #include "storage/MediaManager.h"
  48 #include "utils/FileExtensionProvider.h"
  49 #include "utils/log.h"
  50 #include "weather/WeatherManager.h"
  51
  52 #include <memory>
  53
  54 using namespace KODI;
  55
  56 CServiceManager::CServiceManager() = default;
  57
  58 CServiceManager::~CServiceManager()
  59 {
  60   if (init_level > 2)
  61     DeinitStageThree();
  62   if (init_level > 1)
  63     DeinitStageTwo();
  64   if (init_level > 0)
  65     DeinitStageOne();
  66 }
  67
  68 bool CServiceManager::InitForTesting()
  69 {
  70   m_network = CNetworkBase::GetNetwork();
  71
  72   m_databaseManager = std::make_unique<CDatabaseManager>();
  73
  74   m_binaryAddonManager = std::make_unique<ADDON::CBinaryAddonManager>();
  75   m_addonMgr = std::make_unique<ADDON::CAddonMgr>();
  76   if (!m_addonMgr->Init())
  77   {
  78     CLog::Log(LOGFATAL, "CServiceManager::{}: Unable to start CAddonMgr", __FUNCTION__);
  79     return false;
  80   }
  81
  82   m_extsMimeSupportList = std::make_unique<ADDONS::CExtsMimeSupportList>(*m_addonMgr);
  83   m_fileExtensionProvider = std::make_unique<CFileExtensionProvider>(*m_addonMgr);
  84
  85   init_level = 1;
  86   return true;
  87 }
  88
  89 void CServiceManager::DeinitTesting()
  90 {
  91   init_level = 0;
  92   m_fileExtensionProvider.reset();
  93   m_extsMimeSupportList.reset();
  94   m_binaryAddonManager.reset();
  95   m_addonMgr.reset();
  96   m_databaseManager.reset();
  97   m_network.reset();
  98 }
  99
 100 bool CServiceManager::InitStageOne()
 101 {
 102   m_Platform.reset(CPlatform::CreateInstance());
 103   if (!m_Platform->InitStageOne())
 104     return false;
 105
 106 #ifdef HAS_PYTHON
 107   m_XBPython = std::make_unique<XBPython>();
 108   CScriptInvocationManager::GetInstance().RegisterLanguageInvocationHandler(m_XBPython.get(),
 109                                                                             ".py");
 110 #endif
 111
 112   m_playlistPlayer = std::make_unique<PLAYLIST::CPlayListPlayer>();
 113   m_slideShowDelegator = std::make_unique<CSlideShowDelegator>();
 114
 115   m_network = CNetworkBase::GetNetwork();
 116
 117   init_level = 1;
 118   return true;
 119 }
 120
 121 bool CServiceManager::InitStageTwo(const std::string& profilesUserDataFolder)
 122 {
 123   // Initialize the addon database (must be before the addon manager is init'd)
 124   m_databaseManager = std::make_unique<CDatabaseManager>();
 125
 126   m_binaryAddonManager = std::make_unique<
 127       ADDON::
 128           CBinaryAddonManager>(); /* Need to constructed before, GetRunningInstance() of binary CAddonDll need to call them */
 129   m_addonMgr = std::make_unique<ADDON::CAddonMgr>();
 130   if (!m_addonMgr->Init())
 131   {
 132     CLog::Log(LOGFATAL, "CServiceManager::{}: Unable to start CAddonMgr", __FUNCTION__);
 133     return false;
 134   }
 135
 136   m_repositoryUpdater = std::make_unique<ADDON::CRepositoryUpdater>(*m_addonMgr);
 137
 138   m_extsMimeSupportList = std::make_unique<ADDONS::CExtsMimeSupportList>(*m_addonMgr);
 139
 140   m_vfsAddonCache = std::make_unique<ADDON::CVFSAddonCache>();
 141   m_vfsAddonCache->Init();
 142
 143   m_PVRManager = std::make_unique<PVR::CPVRManager>();
 144
 145   m_dataCacheCore = std::make_unique<CDataCacheCore>();
 146
 147   m_binaryAddonCache = std::make_unique<ADDON::CBinaryAddonCache>();
 148   m_binaryAddonCache->Init();
 149
 150   m_favouritesService = std::make_unique<CFavouritesService>(profilesUserDataFolder);
 151
 152   m_serviceAddons = std::make_unique<ADDON::CServiceAddonManager>(*m_addonMgr);
 153
 154   m_contextMenuManager = std::make_unique<CContextMenuManager>(*m_addonMgr);
 155
 156   m_gameControllerManager = std::make_unique<GAME::CControllerManager>(*m_addonMgr);
 157   m_inputManager = std::make_unique<CInputManager>();
 158   m_inputManager->InitializeInputs();
 159
 160   m_peripherals =
 161       std::make_unique<PERIPHERALS::CPeripherals>(*m_inputManager, *m_gameControllerManager);
 162
 163   m_gameRenderManager = std::make_unique<RETRO::CGUIGameRenderManager>();
 164
 165   m_fileExtensionProvider = std::make_unique<CFileExtensionProvider>(*m_addonMgr);
 166
 167   m_powerManager = std::make_unique<CPowerManager>();
 168   m_powerManager->Initialize();
 169   m_powerManager->SetDefaults();
 170
 171   m_weatherManager = std::make_unique<CWeatherManager>();
 172
 173   m_mediaManager = std::make_unique<CMediaManager>();
 174   m_mediaManager->Initialize();
 175
 176 #if !defined(TARGET_WINDOWS) && defined(HAS_OPTICAL_DRIVE)
 177   m_DetectDVDType = std::make_unique<MEDIA_DETECT::CDetectDVDMedia>();
 178 #endif
 179
 180 #if defined(HAS_FILESYSTEM_SMB)
 181   m_WSDiscovery = WSDiscovery::IWSDiscovery::GetInstance();
 182 #endif
 183
 184   if (!m_Platform->InitStageTwo())
 185     return false;
 186
 187   init_level = 2;
 188   return true;
 189 }
 190
 191 // stage 3 is called after successful initialization of WindowManager
 192 bool CServiceManager::InitStageThree(const std::shared_ptr<CProfileManager>& profileManager)
 193 {
 194 #if !defined(TARGET_WINDOWS) && defined(HAS_OPTICAL_DRIVE)
 195   // Start Thread for DVD Mediatype detection
 196   CLog::Log(LOGINFO, "[Media Detection] starting service for optical media detection");
 197   m_DetectDVDType->Create(false);
 198 #endif
 199
 200   // Peripherals depends on strings being loaded before stage 3
 201   m_peripherals->Initialise();
 202
 203   m_gameServices =
 204       std::make_unique<GAME::CGameServices>(*m_gameControllerManager, *m_gameRenderManager,
 205                                             *m_peripherals, *profileManager, *m_inputManager);
 206
 207   m_contextMenuManager->Init();
 208
 209   // Init PVR manager after login, not already on login screen
 210   if (!profileManager->UsingLoginScreen())
 211     m_PVRManager->Init();
 212
 213   m_playerCoreFactory = std::make_unique<CPlayerCoreFactory>(*profileManager);
 214
 215   if (!m_Platform->InitStageThree())
 216     return false;
 217
 218   init_level = 3;
 219   return true;
 220 }
 221
 222 void CServiceManager::DeinitStageThree()
 223 {
 224   init_level = 2;
 225 #if !defined(TARGET_WINDOWS) && defined(HAS_OPTICAL_DRIVE)
 226   m_DetectDVDType->StopThread();
 227   m_DetectDVDType.reset();
 228 #endif
 229   m_playerCoreFactory.reset();
 230   m_PVRManager->Deinit();
 231   m_contextMenuManager->Deinit();
 232   m_gameServices.reset();
 233   m_peripherals->Clear();
 234
 235   m_Platform->DeinitStageThree();
 236 }
 237
 238 void CServiceManager::DeinitStageTwo()
 239 {
 240   init_level = 1;
 241
 242 #if defined(HAS_FILESYSTEM_SMB)
 243   m_WSDiscovery.reset();
 244 #endif
 245
 246   m_weatherManager.reset();
 247   m_powerManager.reset();
 248   m_fileExtensionProvider.reset();
 249   m_gameRenderManager.reset();
 250   m_peripherals.reset();
 251   m_inputManager.reset();
 252   m_gameControllerManager.reset();
 253   m_contextMenuManager.reset();
 254   m_serviceAddons.reset();
 255   m_favouritesService.reset();
 256   m_binaryAddonCache.reset();
 257   m_dataCacheCore.reset();
 258   m_PVRManager.reset();
 259   m_extsMimeSupportList.reset();
 260   m_vfsAddonCache.reset();
 261   m_repositoryUpdater.reset();
 262   m_binaryAddonManager.reset();
 263   m_addonMgr.reset();
 264   m_databaseManager.reset();
 265
 266   m_mediaManager->Stop();
 267   m_mediaManager.reset();
 268
 269   m_Platform->DeinitStageTwo();
 270 }
 271
 272 void CServiceManager::DeinitStageOne()
 273 {
 274   init_level = 0;
 275
 276   m_network.reset();
 277   m_playlistPlayer.reset();
 278   m_slideShowDelegator.reset();
 279 #ifdef HAS_PYTHON
 280   CScriptInvocationManager::GetInstance().UnregisterLanguageInvocationHandler(m_XBPython.get());
 281   m_XBPython.reset();
 282 #endif
 283
 284   m_Platform->DeinitStageOne();
 285   m_Platform.reset();
 286 }
 287
 288 #if defined(HAS_FILESYSTEM_SMB)
 289 WSDiscovery::IWSDiscovery& CServiceManager::GetWSDiscovery()
 290 {
 291   return *m_WSDiscovery;
 292 }
 293 #endif
 294
 295 ADDON::CAddonMgr& CServiceManager::GetAddonMgr()
 296 {
 297   return *m_addonMgr;
 298 }
 299
 300 ADDONS::CExtsMimeSupportList& CServiceManager::GetExtsMimeSupportList()
 301 {
 302   return *m_extsMimeSupportList;
 303 }
 304
 305 ADDON::CBinaryAddonCache& CServiceManager::GetBinaryAddonCache()
 306 {
 307   return *m_binaryAddonCache;
 308 }
 309
 310 ADDON::CBinaryAddonManager& CServiceManager::GetBinaryAddonManager()
 311 {
 312   return *m_binaryAddonManager;
 313 }
 314
 315 ADDON::CVFSAddonCache& CServiceManager::GetVFSAddonCache()
 316 {
 317   return *m_vfsAddonCache;
 318 }
 319
 320 ADDON::CServiceAddonManager& CServiceManager::GetServiceAddons()
 321 {
 322   return *m_serviceAddons;
 323 }
 324
 325 ADDON::CRepositoryUpdater& CServiceManager::GetRepositoryUpdater()
 326 {
 327   return *m_repositoryUpdater;
 328 }
 329
 330 #ifdef HAS_PYTHON
 331 XBPython& CServiceManager::GetXBPython()
 332 {
 333   return *m_XBPython;
 334 }
 335 #endif
 336
 337 #if !defined(TARGET_WINDOWS) && defined(HAS_OPTICAL_DRIVE)
 338 MEDIA_DETECT::CDetectDVDMedia& CServiceManager::GetDetectDVDMedia()
 339 {
 340   return *m_DetectDVDType;
 341 }
 342 #endif
 343
 344 PVR::CPVRManager& CServiceManager::GetPVRManager()
 345 {
 346   return *m_PVRManager;
 347 }
 348
 349 CContextMenuManager& CServiceManager::GetContextMenuManager()
 350 {
 351   return *m_contextMenuManager;
 352 }
 353
 354 CDataCacheCore& CServiceManager::GetDataCacheCore()
 355 {
 356   return *m_dataCacheCore;
 357 }
 358
 359 CPlatform& CServiceManager::GetPlatform()
 360 {
 361   return *m_Platform;
 362 }
 363
 364 PLAYLIST::CPlayListPlayer& CServiceManager::GetPlaylistPlayer()
 365 {
 366   return *m_playlistPlayer;
 367 }
 368
 369 GAME::CControllerManager& CServiceManager::GetGameControllerManager()
 370 {
 371   return *m_gameControllerManager;
 372 }
 373
 374 GAME::CGameServices& CServiceManager::GetGameServices()
 375 {
 376   return *m_gameServices;
 377 }
 378
 379 KODI::RETRO::CGUIGameRenderManager& CServiceManager::GetGameRenderManager()
 380 {
 381   return *m_gameRenderManager;
 382 }
 383
 384 PERIPHERALS::CPeripherals& CServiceManager::GetPeripherals()
 385 {
 386   return *m_peripherals;
 387 }
 388
 389 CFavouritesService& CServiceManager::GetFavouritesService()
 390 {
 391   return *m_favouritesService;
 392 }
 393
 394 CInputManager& CServiceManager::GetInputManager()
 395 {
 396   return *m_inputManager;
 397 }
 398
 399 CFileExtensionProvider& CServiceManager::GetFileExtensionProvider()
 400 {
 401   return *m_fileExtensionProvider;
 402 }
 403
 404 CPowerManager& CServiceManager::GetPowerManager()
 405 {
 406   return *m_powerManager;
 407 }
 408
 409 CNetworkBase& CServiceManager::GetNetwork()
 410 {
 411   return *m_network;
 412 }
 413
 414 CWeatherManager& CServiceManager::GetWeatherManager()
 415 {
 416   return *m_weatherManager;
 417 }
 418
 419 CPlayerCoreFactory& CServiceManager::GetPlayerCoreFactory()
 420 {
 421   return *m_playerCoreFactory;
 422 }
 423
 424 CDatabaseManager& CServiceManager::GetDatabaseManager()
 425 {
 426   return *m_databaseManager;
 427 }
 428
 429 CMediaManager& CServiceManager::GetMediaManager()
 430 {
 431   return *m_mediaManager;
 432 }
 433
 434 CSlideShowDelegator& CServiceManager::GetSlideShowDelegator()
 435 {
 436   return *m_slideShowDelegator;
 437 }