lib/dvb/service.cpp

   1 #include <lib/dvb/service.h>
   2
   3 #include <lib/base/i18n.h>
   4 #include <lib/dvb/dvb.h>
   5 #include <lib/system/init.h>
   6 #include <lib/system/init_num.h>
   7 #include <lib/system/econfig.h>
   8
   9 int eServiceHandler::flags=0;
  10
  11 eServiceHandler::eServiceHandler(int id): id(id)
  12 {
  13 }
  14
  15 eServiceHandler::~eServiceHandler()
  16 {
  17 }
  18
  19 eService *eServiceHandler::createService(const eServiceReference &node)
  20 {
  21         (void)node;
  22         return 0;
  23 }
  24
  25 int eServiceHandler::play(const eServiceReference &service, int workaround)
  26 {
  27         (void)service;
  28         return -1;
  29 }
  30
  31 int eServiceHandler::serviceCommand(const eServiceCommand &cmd)
  32 {
  33         (void)cmd;
  34         return -1;
  35 }
  36
  37 PMT *eServiceHandler::getPMT()
  38 {
  39         return 0;
  40 }
  41
  42 void eServiceHandler::setPID(const PMTEntry *)
  43 {
  44         return;
  45 }
  46
  47 SDT *eServiceHandler::getSDT()
  48 {
  49         return 0;
  50 }
  51
  52 EIT *eServiceHandler::getEIT()
  53 {
  54         return 0;
  55 }
  56
  57 int eServiceHandler::getFlags()
  58 {
  59         return flags;
  60 }
  61
  62 int eServiceHandler::getState()
  63 {
  64         return 0;
  65 }
  66
  67 int eServiceHandler::getAspectRatio()
  68 {
  69         return 0;
  70 }
  71
  72 int eServiceHandler::getErrorInfo()
  73 {
  74         return 0;
  75 }
  76
  77 int eServiceHandler::stop( int workaround )
  78 {
  79         return 0;
  80 }
  81
  82 int eServiceHandler::getPosition(int)
  83 {
  84         return -1;
  85 }
  86
  87 void eServiceHandler::setAudioStream( unsigned int )
  88 {
  89 }
  90
  91 void eServiceHandler::enterDirectory(const eServiceReference &dir, Signal1<void,const eServiceReference&> &callback)
  92 {
  93         (void)dir;
  94         (void)callback;
  95         return;
  96 }
  97
  98 void eServiceHandler::leaveDirectory(const eServiceReference &dir)
  99 {
 100         (void)dir;
 101         return;
 102 }
 103
 104 eService *eServiceHandler::addRef(const eServiceReference &service)
 105 {
 106         (void)service;
 107         return 0;
 108 }
 109
 110 void eServiceHandler::removeRef(const eServiceReference &service)
 111 {
 112         (void)service;
 113 }
 114
 115 eString eServiceHandler::getInfo(int id)
 116 {
 117         (void)id;
 118         return "";
 119 }
 120
 121 eServiceInterface *eServiceInterface::instance;
 122
 123 eServiceInterface *eServiceInterface::getInstance()
 124 {
 125         return instance;
 126 }
 127
 128 void eServiceInterface::handleServiceEvent(const eServiceEvent &evt)
 129 {
 130         serviceEvent(evt);
 131 }
 132
 133 int eServiceInterface::switchServiceHandler(int id, int workaround )
 134 {
 135         if (currentServiceHandler && (currentServiceHandler->getID() == id))
 136         {
 137                 currentServiceHandler->stop(workaround);
 138                 return 0;
 139         }
 140
 141         stop(workaround);
 142         eServiceHandler *handler=getServiceHandler(id);
 143         if (!handler)
 144                 return -1;
 145
 146         conn=CONNECT(handler->serviceEvent, eServiceInterface::handleServiceEvent);
 147         currentServiceHandler=handler;
 148         return 0;
 149 }
 150
 151 eServiceInterface::eServiceInterface()
 152 {
 153         currentServiceHandler = 0;
 154         if (!instance)
 155                 instance = this;
 156 }
 157
 158 eServiceInterface::~eServiceInterface()
 159 {
 160         if (instance == this)
 161                 instance = 0;
 162         stop();
 163 }
 164
 165 int eServiceInterface::registerHandler(int id, eServiceHandler *handler)
 166 {
 167         if (handlers.count(id))
 168                 return -1;
 169         handlers.insert(std::pair<int,eServiceHandler*>(id, handler));
 170         return 0;
 171 }
 172
 173 int eServiceInterface::unregisterHandler(int id)
 174 {
 175         std::map<int,eServiceHandler*>::iterator i=handlers.find(id);
 176         if (i == handlers.end())
 177                 return -1;
 178         if (i->second == currentServiceHandler)
 179                 stop();
 180         handlers.erase(i);
 181         return 0;
 182 }
 183
 184 eServiceHandler *eServiceInterface::getServiceHandler(int id)
 185 {
 186         std::map<int,eServiceHandler*>::iterator i=handlers.find(id);
 187         if (i == handlers.end())
 188                 return 0;
 189         return i->second;
 190 }
 191
 192 extern bool checkPin( int pin, const char * text );
 193
 194 int eServiceInterface::play(const eServiceReference &s)
 195 {
 196         return play(s,0);
 197 }
 198
 199 int eServiceInterface::play(const eServiceReference &s, int workaround )
 200 {
 201         int pLockActive = eConfig::getInstance()->pLockActive();
 202         if ( !workaround && s.isLocked() && pLockActive && !checkPin( eConfig::getInstance()->getParentalPin(), _("parental") ) )
 203         {
 204                 eWarning("service is parentallocked... don't play");
 205                 return -1;
 206         }
 207         if (switchServiceHandler(s.type, workaround))
 208         {
 209                 eWarning("couldn't play service type %d", s.type);
 210                 return -1;
 211         }
 212         service=s;
 213         return currentServiceHandler->play(s, workaround);
 214 }
 215
 216 int eServiceInterface::stop(int workaround)
 217 {
 218         if (!currentServiceHandler)
 219                 return -1;
 220         int res=currentServiceHandler->stop(workaround);
 221         conn.disconnect();
 222         currentServiceHandler=0;
 223         service=eServiceReference();
 224         return res;
 225 }
 226
 227 void eServiceInterface::enterDirectory(const eServiceReference &dir, Signal1<void,const eServiceReference&> &callback)
 228 {
 229         int pLockActive = eConfig::getInstance()->pLockActive();
 230         if ( dir.isLocked() && pLockActive && !checkPin( eConfig::getInstance()->getParentalPin(), _("parental") ) )
 231         {
 232                 eWarning("directory is parentallocked... don't enter");
 233                 return;
 234         }
 235         for (std::map<int,eServiceHandler*>::iterator i(handlers.begin()); i != handlers.end(); ++i)
 236                 i->second->enterDirectory(dir, callback);
 237 }
 238
 239 void eServiceInterface::leaveDirectory(const eServiceReference &dir)
 240 {
 241         for (std::map<int,eServiceHandler*>::iterator i(handlers.begin()); i != handlers.end(); ++i)
 242                 i->second->leaveDirectory(dir);
 243 }
 244
 245 eService *eServiceInterface::addRef(const eServiceReference &service)
 246 {
 247         eServiceHandler *handler=getServiceHandler(service.type);
 248         if (handler)
 249                 return handler->addRef(service);
 250         else
 251                 return 0;
 252 }
 253
 254 void eServiceInterface::removeRef(const eServiceReference &service)
 255 {
 256         eServiceHandler *handler=getServiceHandler(service.type);
 257         if (handler)
 258                 return handler->removeRef(service);
 259 }
 260
 261 eAutoInitP0<eServiceInterface> i_eServiceInteface(eAutoInitNumbers::service, "eServiceInterface");