lib/service/iservice.h

   1 #ifndef __lib_dvb_iservice_h
   2 #define __lib_dvb_iservice_h
   3
   4 #include <lib/python/swig.h>
   5 #include <lib/base/object.h>
   6 #include <string>
   7 #include <connection.h>
   8 #include <list>
   9
  10 class eServiceReference
  11 {
  12 public:
  13         enum
  14         {
  15                 idInvalid=-1,
  16                 idStructure,    // service_id == 0 is root
  17                 idDVB,
  18                 idFile,
  19                 idUser=0x1000
  20         };
  21         int type;
  22
  23         int flags; // flags will NOT be compared.
  24         enum
  25         {
  26                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
  27                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
  28                 /*
  29                         for example:
  30                                 normal services have none of them - they can be fed directly into the "play"-handler.
  31                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
  32                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
  33                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
  34                 */
  35                 canDescent=4,                   // supports enterDirectory/leaveDirectory
  36                 flagDirectory=isDirectory|mustDescent|canDescent,
  37                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
  38                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
  39                 sort1=32                                        // sort key is 1 instead of 0
  40         };
  41
  42         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
  43
  44         int data[8];
  45         std::string path;
  46
  47         eServiceReference()
  48                 : type(idInvalid), flags(0)
  49         {
  50         }
  51
  52         eServiceReference(int type, int flags)
  53                 : type(type), flags(flags)
  54         {
  55                 memset(data, 0, sizeof(data));
  56         }
  57         eServiceReference(int type, int flags, int data0)
  58                 : type(type), flags(flags)
  59         {
  60                 memset(data, 0, sizeof(data));
  61                 data[0]=data0;
  62         }
  63         eServiceReference(int type, int flags, int data0, int data1)
  64                 : type(type), flags(flags)
  65         {
  66                 memset(data, 0, sizeof(data));
  67                 data[0]=data0;
  68                 data[1]=data1;
  69         }
  70         eServiceReference(int type, int flags, int data0, int data1, int data2)
  71                 : type(type), flags(flags)
  72         {
  73                 memset(data, 0, sizeof(data));
  74                 data[0]=data0;
  75                 data[1]=data1;
  76                 data[2]=data2;
  77         }
  78         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
  79                 : type(type), flags(flags)
  80         {
  81                 memset(data, 0, sizeof(data));
  82                 data[0]=data0;
  83                 data[1]=data1;
  84                 data[2]=data2;
  85                 data[3]=data3;
  86         }
  87         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
  88                 : type(type), flags(flags)
  89         {
  90                 memset(data, 0, sizeof(data));
  91                 data[0]=data0;
  92                 data[1]=data1;
  93                 data[2]=data2;
  94                 data[3]=data3;
  95                 data[4]=data4;
  96         }
  97         eServiceReference(int type, int flags, const std::string &path)
  98                 : type(type), flags(flags), path(path)
  99         {
 100                 memset(data, 0, sizeof(data));
 101         }
 102         eServiceReference(const std::string &string);
 103         std::string toString() const;
 104         bool operator==(const eServiceReference &c) const
 105         {
 106                 if (type != c.type)
 107                         return 0;
 108                 return /* (flags == c.flags) && */ (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
 109         }
 110         bool operator!=(const eServiceReference &c) const
 111         {
 112                 return !(*this == c);
 113         }
 114         bool operator<(const eServiceReference &c) const
 115         {
 116                 if (type < c.type)
 117                         return 1;
 118
 119                 if (type > c.type)
 120                         return 0;
 121
 122 /*              if (flags < c.flags)
 123                         return 1;
 124                 if (flags > c.flags)
 125                         return 0; */
 126
 127                 int r=memcmp(data, c.data, sizeof(int)*8);
 128                 if (r)
 129                         return r < 0;
 130                 return path < c.path;
 131         }
 132         operator bool() const
 133         {
 134                 return type != idInvalid;
 135         }
 136 };
 137
 138 typedef unsigned long long pts_t;
 139
 140         /* the reason we have the servicereference as additional argument is
 141            that we don't have to create one object for every entry in a possibly
 142            large list, provided that no state information is nessesary to deliver
 143            the required information. Anyway - ref *must* be the same as the argument
 144            to the info() or getIServiceInformation call! */
 145 class iStaticServiceInformation: public iObject
 146 {
 147 public:
 148         virtual RESULT getName(const eServiceReference &ref, std::string &name)=0;
 149
 150                 // doesn't need to be implemented, should return -1 then.
 151         virtual int getLength(const eServiceReference &ref)=0;
 152
 153                 // FOR SWIG
 154         std::string getName(const eServiceReference &ref) { std::string temp; getName(ref, temp); return temp; }
 155 };
 156
 157 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
 158
 159 class eServiceEvent;
 160
 161 class iServiceInformation: public iObject
 162 {
 163 public:
 164         virtual RESULT getName(std::string &name)=0;
 165                 // FOR SWIG
 166         std::string getName() { std::string temp; getName(temp); return temp; }
 167         virtual RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
 168 };
 169
 170 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 171
 172 class iPauseableService: public iObject
 173 {
 174 public:
 175         virtual RESULT pause()=0;
 176         virtual RESULT unpause()=0;
 177 };
 178
 179 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 180
 181 class iSeekableService: public iObject
 182 {
 183 public:
 184         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 185         virtual RESULT seekTo(pts_t to)=0;
 186         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 187 };
 188
 189 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 190
 191 class iPlayableService: public iObject
 192 {
 193         friend class iServiceHandler;
 194 public:
 195         enum
 196         {
 197                 evStart,
 198                 evEnd,
 199
 200                 // when iServiceInformation is implemented:
 201                 evUpdatedEventInfo
 202         };
 203         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 204         virtual RESULT start()=0;
 205         virtual RESULT stop()=0;
 206         virtual RESULT seek(ePtr<iSeekableService> &ptr)=0;
 207         virtual RESULT pause(ePtr<iPauseableService> &ptr)=0;
 208         virtual RESULT info(ePtr<iServiceInformation> &ptr)=0;
 209 };
 210
 211 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 212
 213 class iRecordableService: public iObject
 214 {
 215 public:
 216         virtual RESULT prepare()=0;
 217         virtual RESULT start()=0;
 218         virtual RESULT stop()=0;
 219 };
 220
 221 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 222
 223 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
 224
 225 class iListableService: public iObject
 226 {
 227 public:
 228                 /* legacy interface: get a list */
 229         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
 230
 231                 /* new, shiny interface: streaming. */
 232         virtual RESULT getNext(eServiceReference &ptr)=0;
 233 };
 234
 235 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 236
 237 class iServiceHandler: public iObject
 238 {
 239 public:
 240         virtual RESULT play(const eServiceReference &, ePtr<iPlayableService> &ptr)=0;
 241         virtual RESULT record(const eServiceReference &, ePtr<iRecordableService> &ptr)=0;
 242         virtual RESULT list(const eServiceReference &, ePtr<iListableService> &ptr)=0;
 243         virtual RESULT info(const eServiceReference &, ePtr<iStaticServiceInformation> &ptr);
 244 };
 245
 246 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 247
 248 #endif