xbmc/pvr/PVRChannelNumberInputHandler.cpp

   1 /*
   2  *  Copyright (C) 2012-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 "PVRChannelNumberInputHandler.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "settings/AdvancedSettings.h"
  13 #include "settings/SettingsComponent.h"
  14 #include "utils/StringUtils.h"
  15
  16 #include <algorithm>
  17 #include <cstdlib>
  18 #include <mutex>
  19 #include <string>
  20
  21 using namespace PVR;
  22 using namespace std::chrono_literals;
  23
  24 CPVRChannelNumberInputHandler::CPVRChannelNumberInputHandler()
  25   : CPVRChannelNumberInputHandler(CServiceBroker::GetSettingsComponent()
  26                                       ->GetAdvancedSettings()
  27                                       ->m_iPVRNumericChannelSwitchTimeout,
  28                                   CHANNEL_NUMBER_INPUT_MAX_DIGITS)
  29 {
  30 }
  31
  32 CPVRChannelNumberInputHandler::CPVRChannelNumberInputHandler(
  33     int iDelay, int iMaxDigits /* = CHANNEL_NUMBER_INPUT_MAX_DIGITS */)
  34   : m_iDelay(iDelay), m_iMaxDigits(iMaxDigits), m_timer(this)
  35 {
  36 }
  37
  38 void CPVRChannelNumberInputHandler::OnTimeout()
  39 {
  40   if (m_inputBuffer.empty())
  41   {
  42     std::unique_lock<CCriticalSection> lock(m_mutex);
  43     SetLabel("");
  44   }
  45   else
  46   {
  47     // call the overridden worker method
  48     OnInputDone();
  49
  50     std::unique_lock<CCriticalSection> lock(m_mutex);
  51
  52     // erase input buffer immediately , but...
  53     m_inputBuffer.erase();
  54
  55     // ... display the label for another .5 secs if we stopped the timer before regular timeout.
  56     if (m_timer.IsRunning())
  57       SetLabel("");
  58     else
  59       m_timer.Start(500ms);
  60   }
  61 }
  62
  63 void CPVRChannelNumberInputHandler::ExecuteAction()
  64 {
  65   m_timer.Stop(true /* wait until worker thread ended */);
  66   OnTimeout();
  67 }
  68
  69 bool CPVRChannelNumberInputHandler::CheckInputAndExecuteAction()
  70 {
  71   const CPVRChannelNumber channelNumber = GetChannelNumber();
  72   if (channelNumber.IsValid())
  73   {
  74     // we have a valid channel number; execute the associated action now.
  75     ExecuteAction();
  76     return true;
  77   }
  78   return false;
  79 }
  80
  81 void CPVRChannelNumberInputHandler::AppendChannelNumberCharacter(char cCharacter)
  82 {
  83   if (cCharacter != CPVRChannelNumber::SEPARATOR && (cCharacter < '0' || cCharacter > '9'))
  84     return;
  85
  86   std::unique_lock<CCriticalSection> lock(m_mutex);
  87
  88   if (cCharacter == CPVRChannelNumber::SEPARATOR)
  89   {
  90     // no leading separator
  91     if (m_inputBuffer.empty())
  92       return;
  93
  94     // max one separator
  95     if (m_inputBuffer.find(CPVRChannelNumber::SEPARATOR) != std::string::npos)
  96       return;
  97   }
  98
  99   if (m_inputBuffer.size() == static_cast<size_t>(m_iMaxDigits))
 100   {
 101     m_inputBuffer.erase(m_inputBuffer.begin());
 102     SetLabel(m_inputBuffer);
 103   }
 104   else if (m_inputBuffer.empty())
 105   {
 106     m_sortedChannelNumbers.clear();
 107     GetChannelNumbers(m_sortedChannelNumbers);
 108
 109     std::sort(m_sortedChannelNumbers.begin(), m_sortedChannelNumbers.end());
 110   }
 111
 112   m_inputBuffer.append(&cCharacter, 1);
 113   SetLabel(m_inputBuffer);
 114
 115   for (auto it = m_sortedChannelNumbers.begin(); it != m_sortedChannelNumbers.end();)
 116   {
 117     const std::string channel = *it;
 118     ++it;
 119
 120     if (StringUtils::StartsWith(channel, m_inputBuffer))
 121     {
 122       if (it != m_sortedChannelNumbers.end() && StringUtils::StartsWith(*it, m_inputBuffer))
 123       {
 124         // there are alternative numbers; wait for more input
 125         break;
 126       }
 127
 128       // no alternatives; complete the number and fire immediately
 129       m_inputBuffer = channel;
 130       SetLabel(m_inputBuffer);
 131       ExecuteAction();
 132       return;
 133     }
 134   }
 135
 136   if (!m_timer.IsRunning())
 137     m_timer.Start(std::chrono::milliseconds(m_iDelay));
 138   else
 139     m_timer.Restart();
 140 }
 141
 142 CPVRChannelNumber CPVRChannelNumberInputHandler::GetChannelNumber() const
 143 {
 144   int iChannelNumber = 0;
 145   int iSubChannelNumber = 0;
 146
 147   std::unique_lock<CCriticalSection> lock(m_mutex);
 148
 149   size_t pos = m_inputBuffer.find(CPVRChannelNumber::SEPARATOR);
 150   if (pos != std::string::npos)
 151   {
 152     // main + sub
 153     if (pos != 0)
 154     {
 155       iChannelNumber = std::atoi(m_inputBuffer.substr(0, pos).c_str());
 156       if (pos != m_inputBuffer.size() - 1)
 157         iSubChannelNumber = std::atoi(m_inputBuffer.substr(pos + 1).c_str());
 158     }
 159   }
 160   else
 161   {
 162     // only main
 163     iChannelNumber = std::atoi(m_inputBuffer.c_str());
 164   }
 165
 166   return CPVRChannelNumber(iChannelNumber, iSubChannelNumber);
 167 }
 168
 169 bool CPVRChannelNumberInputHandler::HasChannelNumber() const
 170 {
 171   return !m_inputBuffer.empty();
 172 }
 173
 174 std::string CPVRChannelNumberInputHandler::GetChannelNumberLabel() const
 175 {
 176   std::unique_lock<CCriticalSection> lock(m_mutex);
 177   return m_label;
 178 }
 179
 180 void CPVRChannelNumberInputHandler::SetLabel(const std::string& label)
 181 {
 182   std::unique_lock<CCriticalSection> lock(m_mutex);
 183   if (label != m_label)
 184   {
 185     m_label = label;
 186
 187     // inform subscribers
 188     m_events.Publish(PVRChannelNumberInputChangedEvent(m_label));
 189   }
 190 }