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 // only for override service names in bouquets or to give servicerefs a name which not have a
  48 // real existing service ( for dvb eServiceDVB )
  49         std::string name;
  50
  51         eServiceReference()
  52                 : type(idInvalid), flags(0)
  53         {
  54         }
  55
  56         eServiceReference(int type, int flags)
  57                 : type(type), flags(flags)
  58         {
  59                 memset(data, 0, sizeof(data));
  60         }
  61         eServiceReference(int type, int flags, int data0)
  62                 : type(type), flags(flags)
  63         {
  64                 memset(data, 0, sizeof(data));
  65                 data[0]=data0;
  66         }
  67         eServiceReference(int type, int flags, int data0, int data1)
  68                 : type(type), flags(flags)
  69         {
  70                 memset(data, 0, sizeof(data));
  71                 data[0]=data0;
  72                 data[1]=data1;
  73         }
  74         eServiceReference(int type, int flags, int data0, int data1, int data2)
  75                 : type(type), flags(flags)
  76         {
  77                 memset(data, 0, sizeof(data));
  78                 data[0]=data0;
  79                 data[1]=data1;
  80                 data[2]=data2;
  81         }
  82         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
  83                 : type(type), flags(flags)
  84         {
  85                 memset(data, 0, sizeof(data));
  86                 data[0]=data0;
  87                 data[1]=data1;
  88                 data[2]=data2;
  89                 data[3]=data3;
  90         }
  91         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
  92                 : type(type), flags(flags)
  93         {
  94                 memset(data, 0, sizeof(data));
  95                 data[0]=data0;
  96                 data[1]=data1;
  97                 data[2]=data2;
  98                 data[3]=data3;
  99                 data[4]=data4;
 100         }
 101         eServiceReference(int type, int flags, const std::string &path)
 102                 : type(type), flags(flags), path(path)
 103         {
 104                 memset(data, 0, sizeof(data));
 105         }
 106         eServiceReference(const std::string &string);
 107         std::string toString() const;
 108         bool operator==(const eServiceReference &c) const
 109         {
 110                 if (type != c.type)
 111                         return 0;
 112                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
 113         }
 114         bool operator!=(const eServiceReference &c) const
 115         {
 116                 return !(*this == c);
 117         }
 118         bool operator<(const eServiceReference &c) const
 119         {
 120                 if (type < c.type)
 121                         return 1;
 122
 123                 if (type > c.type)
 124                         return 0;
 125
 126                 int r=memcmp(data, c.data, sizeof(int)*8);
 127                 if (r)
 128                         return r < 0;
 129                 return path < c.path;
 130         }
 131         operator bool() const
 132         {
 133                 return valid();
 134         }
 135
 136         int valid() const
 137         {
 138                 return type != idInvalid;
 139         }
 140 };
 141
 142 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
 143
 144 typedef long long pts_t;
 145
 146         /* the reason we have the servicereference as additional argument is
 147            that we don't have to create one object for every entry in a possibly
 148            large list, provided that no state information is nessesary to deliver
 149            the required information. Anyway - ref *must* be the same as the argument
 150            to the info() or getIServiceInformation call! */
 151
 152         /* About the usage of SWIG_VOID:
 153            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
 154            the "superflouus" RESULT return values.
 155
 156            Python code has to check the returned pointer against 0. This works,
 157            as all functions returning instances in smartpointers AND having a
 158            RESULT have to BOTH return non-zero AND set the pointer to zero.
 159
 160            Python code thus can't check for the reason, but the reason isn't
 161            user-servicable anyway. If you want to return a real reason which
 162            goes beyong "it just doesn't work", use extra variables for this,
 163            not the RESULT.
 164
 165            Hide the result only if there is another way to check for failure! */
 166
 167 class iStaticServiceInformation: public iObject
 168 {
 169 public:
 170         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
 171
 172                 // doesn't need to be implemented, should return -1 then.
 173         virtual int getLength(const eServiceReference &ref)=0;
 174 };
 175
 176 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
 177
 178 class eServiceEvent;
 179
 180 TEMPLATE_TYPEDEF(ePtr<eServiceEvent>, eServiceEventPtr);
 181
 182 class iServiceInformation: public iObject
 183 {
 184 public:
 185         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
 186         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
 187
 188         enum {
 189                 sIsCrypted,  /* is encrypted (no indication if decrypt was possible) */
 190                 sAspect,     /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
 191                 sIsMultichannel, /* multichannel *available* (probably not selected) */
 192
 193                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
 194                            that's also the reason why they are so globally defined.
 195
 196
 197                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
 198                            i will change this to return a user-readable text like "zero x zero three three" (and change the
 199                            exact spelling in every version) to stop that!
 200                         */
 201                 sVideoPID,
 202                 sAudioPID,
 203                 sPCRPID,
 204                 sPMTPID,
 205                 sTXTPID,
 206
 207                 sSID,
 208                 sONID,
 209                 sTSID,
 210                 sNamespace,
 211                 sProvider,
 212         };
 213         enum { resNA = -1, resIsString = -2 };
 214
 215         virtual int getInfo(int w);
 216         virtual std::string getInfoString(int w);
 217 };
 218
 219 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 220
 221 class iPauseableService: public iObject
 222 {
 223 public:
 224         virtual RESULT pause()=0;
 225         virtual RESULT unpause()=0;
 226 };
 227
 228 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 229
 230 class iSeekableService: public iObject
 231 {
 232 public:
 233         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 234         virtual RESULT seekTo(pts_t to)=0;
 235         enum { dirForward = +1, dirBackward = -1 };
 236         virtual RESULT seekRelative(int direction, pts_t to)=0;
 237         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 238 };
 239
 240 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 241
 242 struct iAudioTrackInfo
 243 {
 244         std::string m_description;
 245         std::string m_language; /* iso639 */
 246
 247         std::string getDescription() { return m_description; }
 248         std::string getLanguage() { return m_language; }
 249 };
 250
 251 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 252
 253 class iAudioTrackSelection: public iObject
 254 {
 255 public:
 256         virtual int getNumberOfTracks()=0;
 257         virtual RESULT selectTrack(unsigned int i)=0;
 258         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 259 };
 260
 261 TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 262
 263
 264 class iPlayableService: public iObject
 265 {
 266         friend class iServiceHandler;
 267 public:
 268         enum
 269         {
 270                 evStart,
 271                 evEnd,
 272
 273                 evTuneFailed,
 274                         // when iServiceInformation is implemented:
 275                 evUpdatedEventInfo,
 276                 evUpdatedInfo,
 277         };
 278         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 279         virtual RESULT start()=0;
 280         virtual RESULT stop()=0;
 281         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 282         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 283         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 284         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 285 };
 286
 287 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 288
 289 class iRecordableService: public iObject
 290 {
 291 public:
 292         virtual RESULT prepare(const char *filename)=0;
 293         virtual RESULT start()=0;
 294         virtual RESULT stop()=0;
 295 };
 296
 297 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 298
 299 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
 300
 301 class iMutableServiceList: public iObject
 302 {
 303 public:
 304                 /* flush changes */
 305         virtual RESULT flushChanges()=0;
 306                 /* adds a service to a list */
 307         virtual RESULT addService(eServiceReference &ref)=0;
 308                 /* removes a service from a list */
 309         virtual RESULT removeService(eServiceReference &ref)=0;
 310                 /* moves a service in a list, only if list suppports a specific sort method. */
 311                 /* pos is the new, absolute position from 0..size-1 */
 312         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 313 };
 314
 315 TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 316
 317 class iListableService: public iObject
 318 {
 319 public:
 320                 /* legacy interface: get a list */
 321         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
 322
 323                 /* new, shiny interface: streaming. */
 324         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 325
 326                 /* use this for sorting. output is not sorted because of either
 327                  - performance reasons: the whole list must be buffered or
 328                  - the interface would be restricted to a list. streaming
 329                    (as well as a future "active" extension) won't be possible.
 330                 */
 331         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 332
 333         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 334 };
 335
 336 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 337
 338         /* a helper class which can be used as argument to stl's sort(). */
 339 class iListableServiceCompare
 340 {
 341         ePtr<iListableService> m_list;
 342 public:
 343         iListableServiceCompare(iListableService *list): m_list(list) { }
 344         bool operator()(const eServiceReference &a, const eServiceReference &b)
 345         {
 346                 return m_list->compareLessEqual(a, b);
 347         }
 348 };
 349
 350 class iServiceOfflineOperations: public iObject
 351 {
 352 public:
 353                 /* to delete a service, forever. */
 354         virtual RESULT deleteFromDisk(int simulate=1)=0;
 355
 356                 /* for transferring a service... */
 357         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 358
 359                 // TODO: additional stuff, like a conversion interface?
 360 };
 361
 362 TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 363
 364 class iServiceHandler: public iObject
 365 {
 366 public:
 367         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 368         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 369         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 370         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 371         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 372 };
 373
 374 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 375
 376 #endif