code.vuplus.com Git - vuplus_dvbapp/blob - lib/nav/core.cpp

   1 #include <lib/nav/core.h>
   2 #include <lib/base/eerror.h>
   3 #include <lib/python/python.h>
   4 #include <lib/dvb/fcc.h>
   5
   6 void eNavigation::serviceEvent(iPlayableService* service, int event)
   7 {
   8         if (m_runningService && service != m_runningService)
   9         {
  10                 eDebug("nav: event %d for other service", event);
  11                 return;
  12         }
  13         m_event(event);
  14 }
  15
  16 void eNavigation::recordEvent(iRecordableService* service, int event)
  17 {
  18         if (m_recordings.find(service) == m_recordings.end())
  19         {
  20                 eDebug("nav: event for non registered recording service");
  21                 return;
  22         }
  23         m_record_event(service, event);
  24 }
  25
  26 RESULT eNavigation::playService(const eServiceReference &service)
  27 {
  28         RESULT res = -1;
  29
  30         if (m_fccmgr->tryFCCService(service, m_runningService) == -1)
  31         {
  32                 stopService();
  33                 ASSERT(m_servicehandler);
  34                 res = m_servicehandler->play(service, m_runningService);
  35         }
  36
  37         if (m_runningService)
  38         {
  39                 m_runningService->setTarget(m_decoder);
  40                 m_runningService->connectEvent(slot(*this, &eNavigation::serviceEvent), m_service_event_conn);
  41                 res = m_runningService->start();
  42         }
  43         return res;
  44 }
  45
  46 RESULT eNavigation::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &connection)
  47 {
  48         connection = new eConnection(this, m_event.connect(event));
  49         return 0;
  50 }
  51
  52 RESULT eNavigation::connectRecordEvent(const Slot2<void,ePtr<iRecordableService>,int> &event, ePtr<eConnection> &connection)
  53 {
  54         connection = new eConnection(this, m_record_event.connect(event));
  55         return 0;
  56 }
  57
  58 RESULT eNavigation::getCurrentService(ePtr<iPlayableService> &service)
  59 {
  60         service = m_runningService;
  61         return 0;
  62 }
  63
  64 RESULT eNavigation::stopService(void)
  65 {
  66                 /* check if there is a running service... */
  67         if (!m_runningService)
  68                 return 1;
  69
  70         ePtr<iPlayableService> tmp = m_runningService;
  71         m_runningService=0;
  72         tmp->stop();
  73
  74         /* send stop event */
  75         m_event(iPlayableService::evEnd);
  76
  77                 /* kill service. */
  78         m_service_event_conn = 0;
  79
  80         m_fccmgr->cleanupFCCService();
  81         return 0;
  82 }
  83
  84 RESULT eNavigation::recordService(const eServiceReference &ref, ePtr<iRecordableService> &service, bool simulate)
  85 {
  86         ASSERT(m_servicehandler);
  87         RESULT res = m_servicehandler->record(ref, service);
  88         eDebug("record: %d", res);
  89         if (res)
  90                 service = 0;
  91         else
  92         {
  93                 if (simulate)
  94                         m_simulate_recordings.insert(service);
  95                 else
  96                 {
  97                         ePtr<eConnection> conn;
  98                         service->connectEvent(slot(*this, &eNavigation::recordEvent), conn);
  99                         m_recordings[service]=conn;
 100                 }
 101         }
 102         return res;
 103 }
 104
 105 RESULT eNavigation::stopRecordService(ePtr<iRecordableService> &service)
 106 {
 107         service->stop();
 108         std::set<ePtr<iRecordableService> >::iterator it =
 109                 m_simulate_recordings.find(service);
 110         if (it != m_simulate_recordings.end())
 111         {
 112                 m_simulate_recordings.erase(it);
 113                 return 0;
 114         }
 115         else
 116         {
 117                 std::map<ePtr<iRecordableService>, ePtr<eConnection> >::iterator it =
 118                         m_recordings.find(service);
 119                 if (it != m_recordings.end())
 120                 {
 121                         m_recordings.erase(it);
 122                         /* send stop event */
 123                         m_record_event(service, iRecordableService::evEnd);
 124                         return 0;
 125                 }
 126         }
 127
 128         eDebug("try to stop non running recording!!");  // this should not happen
 129         return -1;
 130 }
 131
 132 PyObject *eNavigation::getRecordings(bool simulate)
 133 {
 134         ePyObject result = PyList_New(simulate ? m_simulate_recordings.size() : m_recordings.size());
 135         int pos=0;
 136         if (simulate)
 137                 for (std::set<ePtr<iRecordableService> >::iterator it(m_simulate_recordings.begin()); it != m_simulate_recordings.end(); ++it)
 138                         PyList_SET_ITEM(result, pos++, NEW_iRecordableServicePtr(*it));
 139         else
 140                 for (std::map<ePtr<iRecordableService>, ePtr<eConnection> >::iterator it(m_recordings.begin()); it != m_recordings.end(); ++it)
 141                         PyList_SET_ITEM(result, pos++, NEW_iRecordableServicePtr(it->first));
 142         return result;
 143 }
 144
 145 RESULT eNavigation::pause(int dop)
 146 {
 147         if (!m_runningService)
 148                 return -1;
 149         ePtr<iPauseableService> p;
 150         if (m_runningService->pause(p))
 151                 return -2;
 152         if (dop)
 153                 return p->pause();
 154         else
 155                 return p->unpause();
 156 }
 157
 158 eNavigation::eNavigation(iServiceHandler *serviceHandler, int decoder)
 159 {
 160         ASSERT(serviceHandler);
 161         m_servicehandler = serviceHandler;
 162         m_decoder = decoder;
 163         m_fccmgr = new eFCCServiceManager(this);
 164 }
 165
 166 eNavigation::~eNavigation()
 167 {
 168         stopService();
 169 }
 170
 171 DEFINE_REF(eNavigation);