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