lib/nav/core.cpp

   1 #include <lib/nav/core.h>
   2 #include <lib/base/eerror.h>
   3
   4 void eNavigation::serviceEvent(iPlayableService* service, int event)
   5 {
   6         if (service != m_runningService)
   7         {
   8                 eDebug("nav: event for other service");
   9                 return;
  10         }
  11
  12         switch (event)
  13         {
  14         case iPlayableService::evEnd:
  15                 assert(m_playlist); /* we need to have a playlist */
  16
  17                 /* at first, kill the running service */
  18                 stopService();
  19
  20                 /* our running main service stopped. identify what to do next. */
  21
  22                         /* unless the playlist current position is invalid (because there was */
  23                         /* playlist, for example when the service was engaged with playService */
  24                 if (m_playlist->m_current != m_playlist->end())
  25                         ++m_playlist->m_current;
  26
  27                         /* was the current service the last one? */
  28                 if (m_playlist->m_current == m_playlist->end())
  29                 {
  30                         m_event(this, evPlaylistDone);
  31                         break;
  32                 }
  33
  34                         /* there is another service in the playlist. play it. */
  35                 RESULT res;
  36                 res = playService(*m_playlist->m_current);
  37                 if (res)
  38                         m_event(this, evPlayFailed);
  39                 break;
  40         case iPlayableService::evStart:
  41                 m_event(this, evNewService);
  42                 break;
  43         case iPlayableService::evUpdatedEventInfo:
  44                 m_event(this, evUpdatedEventInfo);
  45                 break;
  46         case iPlayableService::evUpdatedInfo:
  47                 m_event(this, evUpdatedInfo);
  48                 break;
  49         default:
  50                 break;
  51         }
  52 }
  53
  54 RESULT eNavigation::playService(const eServiceReference &service)
  55 {
  56         stopService();
  57
  58         assert(m_servicehandler);
  59         RESULT res = m_servicehandler->play(service, m_runningService);
  60         if (m_runningService)
  61         {
  62                 m_runningService->connectEvent(slot(*this, &eNavigation::serviceEvent), m_service_event_conn);
  63                 res = m_runningService->start();
  64         }
  65         return res;
  66 }
  67
  68 RESULT eNavigation::enqueueService(const eServiceReference &service)
  69 {
  70         assert(m_playlist);
  71                 /* check if we need to play after the service was enqueued. */
  72         int doplay = m_playlist->m_current == m_playlist->end();
  73
  74                 /* add the service to the playlist. the playlist's m_current */
  75                 /* points either to a service before the last or 'doplay' is set. */
  76         m_playlist->push_back(service);
  77
  78         if (doplay)
  79         {
  80                 m_playlist->m_current = m_playlist->end();
  81                 --m_playlist->m_current;
  82                 return playService(*m_playlist->m_current);
  83         }
  84         return 0;
  85 }
  86
  87 RESULT eNavigation::connectEvent(const Slot2<void,eNavigation*,int> &event, ePtr<eConnection> &connection)
  88 {
  89         connection = new eConnection(this, m_event.connect(event));
  90         return 0;
  91 }
  92
  93 RESULT eNavigation::getCurrentService(ePtr<iPlayableService> &service)
  94 {
  95         service = m_runningService;
  96         return 0;
  97 }
  98
  99 RESULT eNavigation::getPlaylist(ePtr<ePlaylist> &playlist)
 100 {
 101         if (!m_playlist)
 102                 return -1;
 103         playlist = m_playlist;
 104         return 0;
 105 }
 106
 107 RESULT eNavigation::stopService(void)
 108 {
 109                 /* check if there is a running service... */
 110         if (!m_runningService)
 111                 return 1;
 112                         /* send stop event */
 113         m_event(this, evStopService);
 114
 115                 /* kill service. */
 116         m_runningService = 0;
 117         m_service_event_conn = 0;
 118         return 0;
 119 }
 120
 121 RESULT eNavigation::recordService(const eServiceReference &ref, ePtr<iRecordableService> &service)
 122 {
 123         assert(m_servicehandler);
 124         RESULT res = m_servicehandler->record(ref, service);
 125         eDebug("record: %d", res);
 126         if (res)
 127                 service = 0;
 128         return res;
 129 }
 130
 131 RESULT eNavigation::pause(int dop)
 132 {
 133         if (!m_runningService)
 134                 return -1;
 135         ePtr<iPauseableService> p;
 136         if (m_runningService->pause(p))
 137                 return -2;
 138         if (dop)
 139                 return p->pause();
 140         else
 141                 return p->unpause();
 142 }
 143
 144 eNavigation::eNavigation(iServiceHandler *serviceHandler)
 145 {
 146         assert(serviceHandler);
 147         m_servicehandler = serviceHandler;
 148         m_playlist = new ePlaylist;
 149
 150                 /* start with no current selection */
 151         m_playlist->m_current = m_playlist->end();
 152 }
 153
 154 eNavigation::~eNavigation()
 155 {
 156 }
 157
 158 DEFINE_REF(eNavigation);