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