Line data    Source code

       1              : /*
       2              :  * If not stated otherwise in this file or this component's LICENSE file the
       3              :  * following copyright and licenses apply:
       4              :  *
       5              :  * Copyright 2022 Sky UK
       6              :  *
       7              :  * Licensed under the Apache License, Version 2.0 (the "License");
       8              :  * you may not use this file except in compliance with the License.
       9              :  * You may obtain a copy of the License at
      10              :  *
      11              :  * http://www.apache.org/licenses/LICENSE-2.0
      12              :  *
      13              :  * Unless required by applicable law or agreed to in writing, software
      14              :  * distributed under the License is distributed on an "AS IS" BASIS,
      15              :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      16              :  * See the License for the specific language governing permissions and
      17              :  * limitations under the License.
      18              :  */
      19              : 
      20              : #include <stdexcept>
      21              : 
      22              : #include "IMediaKeysCapabilitiesIpcFactory.h"
      23              : #include "MediaKeysCapabilities.h"
      24              : #include "RialtoClientLogging.h"
      25              : 
      26              : namespace firebolt::rialto
      27              : {
      28              : std::weak_ptr<IMediaKeysCapabilities> MediaKeysCapabilitiesFactory::m_mediaKeysCapabilities;
      29              : std::mutex MediaKeysCapabilitiesFactory::m_creationMutex;
      30              : 
      31            1 : std::shared_ptr<IMediaKeysCapabilitiesFactory> IMediaKeysCapabilitiesFactory::createFactory()
      32              : {
      33            1 :     std::shared_ptr<IMediaKeysCapabilitiesFactory> factory;
      34              : 
      35              :     try
      36              :     {
      37            1 :         factory = std::make_shared<MediaKeysCapabilitiesFactory>();
      38              :     }
      39            0 :     catch (const std::exception &e)
      40              :     {
      41            0 :         RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys capabilities factory, reason: %s", e.what());
      42              :     }
      43              : 
      44            1 :     return factory;
      45              : }
      46              : 
      47            1 : std::shared_ptr<IMediaKeysCapabilities> MediaKeysCapabilitiesFactory::getMediaKeysCapabilities() const
      48              : {
      49            1 :     std::lock_guard<std::mutex> lock{m_creationMutex};
      50              : 
      51              :     std::shared_ptr<IMediaKeysCapabilities> mediaKeysCapabilities =
      52            1 :         MediaKeysCapabilitiesFactory::m_mediaKeysCapabilities.lock();
      53              : 
      54            1 :     if (!mediaKeysCapabilities)
      55              :     {
      56              :         try
      57              :         {
      58            2 :             mediaKeysCapabilities = std::make_shared<client::MediaKeysCapabilities>(
      59            3 :                 client::IMediaKeysCapabilitiesIpcFactory::createFactory());
      60              :         }
      61            1 :         catch (const std::exception &e)
      62              :         {
      63            1 :             RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys capabilities, reason: %s", e.what());
      64              :         }
      65              : 
      66            1 :         MediaKeysCapabilitiesFactory::m_mediaKeysCapabilities = mediaKeysCapabilities;
      67              :     }
      68              : 
      69            2 :     return mediaKeysCapabilities;
      70            1 : }
      71              : 
      72              : }; // namespace firebolt::rialto
      73              : 
      74              : namespace firebolt::rialto::client
      75              : {
      76           11 : MediaKeysCapabilities::MediaKeysCapabilities(
      77           11 :     const std::shared_ptr<IMediaKeysCapabilitiesIpcFactory> &MediaKeysCapabilitiesIpcFactory)
      78              : {
      79           11 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
      80              : 
      81           11 :     m_mediaKeysCapabilitiesIpc = MediaKeysCapabilitiesIpcFactory->getMediaKeysCapabilitiesIpc();
      82           11 :     if (!m_mediaKeysCapabilitiesIpc)
      83              :     {
      84            2 :         throw std::runtime_error("Media keys capabilities ipc could not be created");
      85              :     }
      86           13 : }
      87              : 
      88            9 : MediaKeysCapabilities::~MediaKeysCapabilities()
      89              : {
      90            9 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
      91              : 
      92            9 :     m_mediaKeysCapabilitiesIpc.reset();
      93              : }
      94              : 
      95            2 : std::vector<std::string> MediaKeysCapabilities::getSupportedKeySystems()
      96              : {
      97            2 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
      98              : 
      99            2 :     return m_mediaKeysCapabilitiesIpc->getSupportedKeySystems();
     100              : }
     101              : 
     102            2 : bool MediaKeysCapabilities::supportsKeySystem(const std::string &keySystem)
     103              : {
     104            2 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
     105              : 
     106            2 :     return m_mediaKeysCapabilitiesIpc->supportsKeySystem(keySystem);
     107              : }
     108              : 
     109            2 : bool MediaKeysCapabilities::getSupportedKeySystemVersion(const std::string &keySystem, std::string &version)
     110              : {
     111            2 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
     112              : 
     113            2 :     return m_mediaKeysCapabilitiesIpc->getSupportedKeySystemVersion(keySystem, version);
     114              : }
     115              : 
     116            2 : bool MediaKeysCapabilities::isServerCertificateSupported(const std::string &keySystem)
     117              : {
     118            2 :     RIALTO_CLIENT_LOG_DEBUG("entry:");
     119              : 
     120            2 :     return m_mediaKeysCapabilitiesIpc->isServerCertificateSupported(keySystem);
     121              : }
     122              : 
     123              : }; // namespace firebolt::rialto::client