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