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