code.vuplus.com Git - vuplus_dvbapp/blob - 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/python/python.h>
   6 #include <lib/base/object.h>
   7 #include <string>
   8 #include <connection.h>
   9 #include <list>
  10
  11 class eServiceEvent;
  12
  13 class eServiceReference
  14 {
  15 public:
  16         enum
  17         {
  18                 idInvalid=-1,
  19                 idStructure,    // service_id == 0 is root
  20                 idDVB,
  21                 idFile,
  22                 idUser=0x1000
  23         };
  24         int type;
  25
  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                 isMarker=64                     // Marker
  43         };
  44         int flags; // flags will NOT be compared.
  45
  46         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
  47
  48 #ifndef SWIG
  49         int data[8];
  50         std::string path;
  51 #endif
  52         std::string getPath() { return path; }
  53         void setPath( const std::string &n ) { path=n; }
  54
  55         unsigned int getUnsignedData(unsigned int num) const
  56         {
  57                 if ( num < sizeof(data)/sizeof(int) )
  58                         return data[num];
  59                 return 0;
  60         }
  61
  62         int getData(unsigned int num) const
  63         {
  64                 if ( num < sizeof(data)/sizeof(int) )
  65                         return data[num];
  66                 return 0;
  67         }
  68
  69         void setUnsignedData(unsigned int num, unsigned int val)
  70         {
  71                 if ( num < sizeof(data)/sizeof(int) )
  72                         data[num] = val;
  73         }
  74
  75         void setData(unsigned int num, int val)
  76         {
  77                 if ( num < sizeof(data)/sizeof(int) )
  78                         data[num] = val;
  79         }
  80
  81 // only for override service names in bouquets or to give servicerefs a name which not have a
  82 // real existing service ( for dvb eServiceDVB )
  83 #ifndef SWIG
  84         std::string name;
  85 #endif
  86         std::string getName() { return name; }
  87         void setName( const std::string &n ) { name=n; }
  88
  89         eServiceReference()
  90                 : type(idInvalid), flags(0)
  91         {
  92                 memset(data, 0, sizeof(data));
  93         }
  94 #ifndef SWIG
  95         eServiceReference(int type, int flags)
  96                 : type(type), flags(flags)
  97         {
  98                 memset(data, 0, sizeof(data));
  99         }
 100         eServiceReference(int type, int flags, int data0)
 101                 : type(type), flags(flags)
 102         {
 103                 memset(data, 0, sizeof(data));
 104                 data[0]=data0;
 105         }
 106         eServiceReference(int type, int flags, int data0, int data1)
 107                 : type(type), flags(flags)
 108         {
 109                 memset(data, 0, sizeof(data));
 110                 data[0]=data0;
 111                 data[1]=data1;
 112         }
 113         eServiceReference(int type, int flags, int data0, int data1, int data2)
 114                 : type(type), flags(flags)
 115         {
 116                 memset(data, 0, sizeof(data));
 117                 data[0]=data0;
 118                 data[1]=data1;
 119                 data[2]=data2;
 120         }
 121         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
 122                 : type(type), flags(flags)
 123         {
 124                 memset(data, 0, sizeof(data));
 125                 data[0]=data0;
 126                 data[1]=data1;
 127                 data[2]=data2;
 128                 data[3]=data3;
 129         }
 130         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
 131                 : type(type), flags(flags)
 132         {
 133                 memset(data, 0, sizeof(data));
 134                 data[0]=data0;
 135                 data[1]=data1;
 136                 data[2]=data2;
 137                 data[3]=data3;
 138                 data[4]=data4;
 139         }
 140         eServiceReference(int type, int flags, const std::string &path)
 141                 : type(type), flags(flags), path(path)
 142         {
 143                 memset(data, 0, sizeof(data));
 144         }
 145 #endif
 146         eServiceReference(const std::string &string);
 147         std::string toString() const;
 148         std::string toCompareString() const;
 149         bool operator==(const eServiceReference &c) const
 150         {
 151                 if (type != c.type)
 152                         return 0;
 153                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
 154         }
 155         bool operator!=(const eServiceReference &c) const
 156         {
 157                 return !(*this == c);
 158         }
 159         bool operator<(const eServiceReference &c) const
 160         {
 161                 if (type < c.type)
 162                         return 1;
 163
 164                 if (type > c.type)
 165                         return 0;
 166
 167                 int r=memcmp(data, c.data, sizeof(int)*8);
 168                 if (r)
 169                         return r < 0;
 170                 return path < c.path;
 171         }
 172         operator bool() const
 173         {
 174                 return valid();
 175         }
 176
 177         int valid() const
 178         {
 179                 return type != idInvalid;
 180         }
 181 };
 182
 183 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
 184
 185 extern PyObject *New_eServiceReference(const eServiceReference &ref); // defined in enigma_python.i
 186
 187 #ifndef SWIG
 188 #ifdef PYTHON_REFCOUNT_DEBUG
 189 inline ePyObject Impl_New_eServiceReference(const char* file, int line, const eServiceReference &ref)
 190 {
 191         return ePyObject(New_eServiceReference(ref), file, line);
 192 }
 193 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(__FILE__, __LINE__, ref)
 194 #else
 195 inline ePyObject Impl_New_eServiceReference(const eServiceReference &ref)
 196 {
 197         return New_eServiceReference(ref);
 198 }
 199 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(ref)
 200 #endif
 201 #endif // SWIG
 202
 203 typedef long long pts_t;
 204
 205         /* the reason we have the servicereference as additional argument is
 206            that we don't have to create one object for every entry in a possibly
 207            large list, provided that no state information is nessesary to deliver
 208            the required information. Anyway - ref *must* be the same as the argument
 209            to the info() or getIServiceInformation call! */
 210
 211         /* About the usage of SWIG_VOID:
 212            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
 213            the "superflouus" RESULT return values.
 214
 215            Python code has to check the returned pointer against 0. This works,
 216            as all functions returning instances in smartpointers AND having a
 217            RESULT have to BOTH return non-zero AND set the pointer to zero.
 218
 219            Python code thus can't check for the reason, but the reason isn't
 220            user-servicable anyway. If you want to return a real reason which
 221            goes beyong "it just doesn't work", use extra variables for this,
 222            not the RESULT.
 223
 224            Hide the result only if there is another way to check for failure! */
 225
 226 TEMPLATE_TYPEDEF(ePtr<eServiceEvent>, eServiceEventPtr);
 227
 228 class iStaticServiceInformation: public iObject
 229 {
 230 #ifdef SWIG
 231         iStaticServiceInformation();
 232         ~iStaticServiceInformation();
 233 #endif
 234 public:
 235         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
 236
 237                 // doesn't need to be implemented, should return -1 then.
 238         virtual int getLength(const eServiceReference &ref);
 239         virtual SWIG_VOID(RESULT) getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time=-1);
 240                 // returns true when not implemented
 241         virtual bool isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 242
 243         virtual int getInfo(const eServiceReference &ref, int w);
 244         virtual std::string getInfoString(const eServiceReference &ref,int w);
 245
 246         virtual int setInfo(const eServiceReference &ref, int w, int v);
 247         virtual int setInfoString(const eServiceReference &ref, int w, const char *v);
 248 };
 249
 250 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
 251
 252 class iServiceInformation: public iObject
 253 {
 254 #ifdef SWIG
 255         iServiceInformation();
 256         ~iServiceInformation();
 257 #endif
 258 public:
 259         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
 260         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
 261
 262         enum {
 263                 sIsCrypted,  /* is encrypted (no indication if decrypt was possible) */
 264                 sAspect,     /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
 265                 sIsMultichannel, /* multichannel *available* (probably not selected) */
 266
 267                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
 268                            that's also the reason why they are so globally defined.
 269
 270
 271                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
 272                            i will change this to return a user-readable text like "zero x zero three three" (and change the
 273                            exact spelling in every version) to stop that!
 274                         */
 275                 sVideoPID,
 276                 sAudioPID,
 277                 sPCRPID,
 278                 sPMTPID,
 279                 sTXTPID,
 280
 281                 sSID,
 282                 sONID,
 283                 sTSID,
 284                 sNamespace,
 285                 sProvider,
 286
 287                 sDescription,
 288                 sServiceref,
 289                 sTimeCreate,    // unix time or string
 290
 291                 sTitle,
 292                 sArtist,
 293                 sAlbum,
 294                 sComment,
 295                 sTracknumber,
 296                 sGenre,
 297                 sCAIDs,
 298                 sVideoType,  // MPEG2 MPEG4
 299
 300                 sTags,  /* space seperated list of tags */
 301         };
 302         enum { resNA = -1, resIsString = -2, resIsPyObject = -3 };
 303
 304         virtual int getInfo(int w);
 305         virtual std::string getInfoString(int w);
 306         virtual PyObject *getInfoObject(int w);
 307
 308         virtual int setInfo(int w, int v);
 309         virtual int setInfoString(int w, const char *v);
 310 };
 311
 312 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 313
 314 class iFrontendInformation: public iObject
 315 {
 316 #ifdef SWIG
 317         iFrontendInformation();
 318         ~iFrontendInformation();
 319 #endif
 320 public:
 321         enum {
 322                 bitErrorRate,
 323                 signalPower,
 324                 signalQuality,
 325                 lockState,
 326                 syncState,
 327                 frontendNumber
 328         };
 329         virtual int getFrontendInfo(int w)=0;
 330         virtual PyObject *getFrontendData(bool original=false)=0;
 331 };
 332
 333 TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
 334
 335 class iPauseableService: public iObject
 336 {
 337 #ifdef SWIG
 338         iPausableService();
 339         ~iPausableService();
 340 #endif
 341 public:
 342         virtual RESULT pause()=0;
 343         virtual RESULT unpause()=0;
 344
 345                 /* hm. */
 346         virtual RESULT setSlowMotion(int ratio=0)=0;
 347         virtual RESULT setFastForward(int ratio=0)=0;
 348 };
 349
 350 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 351
 352 class iSeekableService: public iObject
 353 {
 354 #ifdef SWIG
 355         iSeekableService();
 356         ~iSeekableService();
 357 #endif
 358 public:
 359         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 360         virtual RESULT seekTo(pts_t to)=0;
 361         enum { dirForward = +1, dirBackward = -1 };
 362         virtual RESULT seekRelative(int direction, pts_t to)=0;
 363         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 364                 /* if you want to do several seeks in a row, you can enable the trickmode.
 365                    audio will be switched off, sync will be disabled etc. */
 366         virtual RESULT setTrickmode(int trick=0)=0;
 367         virtual RESULT isCurrentlySeekable()=0;
 368 };
 369
 370 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 371
 372 struct iAudioTrackInfo
 373 {
 374 #ifndef SWIG
 375         std::string m_description;
 376         std::string m_language; /* iso639 */
 377 #endif
 378         std::string getDescription() { return m_description; }
 379         std::string getLanguage() { return m_language; }
 380 };
 381
 382 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 383
 384 class iAudioTrackSelection: public iObject
 385 {
 386 #ifdef SWIG
 387         iAudioTrackSelection();
 388         ~iAudioTrackSelection();
 389 #endif
 390 public:
 391         virtual int getNumberOfTracks()=0;
 392         virtual RESULT selectTrack(unsigned int i)=0;
 393         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 394 };
 395
 396 TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 397
 398 class iAudioChannelSelection: public iObject
 399 {
 400 #ifdef SWIG
 401         iAudioChannelSelection();
 402         ~iAudioChannelSelection();
 403 #endif
 404 public:
 405         enum { LEFT, STEREO, RIGHT };
 406         virtual int getCurrentChannel()=0;
 407         virtual RESULT selectChannel(int i)=0;
 408 };
 409
 410 TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
 411
 412 class iAudioDelay: public iObject
 413 {
 414 #ifdef SWIG
 415         iAudioDelay();
 416         ~iAudioDelay();
 417 #endif
 418 public:
 419         virtual int getAC3Delay()=0;
 420         virtual int getPCMDelay()=0;
 421         virtual void setAC3Delay(int)=0;
 422         virtual void setPCMDelay(int)=0;
 423 };
 424
 425 TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
 426
 427 class iRadioText: public iObject
 428 {
 429 #ifdef SWIG
 430         iRadioText();
 431         ~iRadioText();
 432 #endif
 433 public:
 434         virtual std::string getRadioText(int x=0)=0;
 435 };
 436
 437 TEMPLATE_TYPEDEF(ePtr<iRadioText>, iRadioTextPtr);
 438
 439 class iSubserviceList: public iObject
 440 {
 441 #ifdef SWIG
 442         iSubserviceList();
 443         ~iSubserviceList();
 444 #endif
 445 public:
 446         virtual int getNumberOfSubservices()=0;
 447         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
 448 };
 449
 450 TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
 451
 452 class iTimeshiftService: public iObject
 453 {
 454 #ifdef SWIG
 455         iTimeshiftService();
 456         ~iTimeshiftService();
 457 #endif
 458 public:
 459         virtual RESULT startTimeshift()=0;
 460         virtual RESULT stopTimeshift()=0;
 461
 462         virtual int isTimeshiftActive()=0;
 463                         /* this essentially seeks to the relative end of the timeshift buffer */
 464         virtual RESULT activateTimeshift()=0;
 465 };
 466
 467 TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
 468
 469         /* not related to eCueSheet */
 470 class iCueSheet: public iObject
 471 {
 472 #ifdef SWIG
 473         iCueSheet();
 474         ~iCueSheet();
 475 #endif
 476 public:
 477                         /* returns a list of (pts, what)-tuples */
 478         virtual PyObject *getCutList() = 0;
 479         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
 480         virtual void setCutListEnable(int enable) = 0;
 481         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
 482 };
 483
 484 TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
 485
 486 class eWidget;
 487 class PyList;
 488
 489 class iSubtitleOutput: public iObject
 490 {
 491 public:
 492         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
 493         virtual RESULT disableSubtitles(eWidget *parent)=0;
 494         virtual PyObject *getSubtitleList()=0;
 495         virtual PyObject *getCachedSubtitle()=0;
 496 };
 497
 498 TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
 499
 500 class iPlayableService: public iObject
 501 {
 502 #ifdef SWIG
 503         iPlayableService();
 504         ~iPlaybleService();
 505 #endif
 506         friend class iServiceHandler;
 507 public:
 508         enum
 509         {
 510                         /* these first two events are magical, and should only
 511                            be generated if you know what you're doing. */
 512                 evStart,
 513                 evEnd,
 514
 515                 evTuneFailed,
 516                         // when iServiceInformation is implemented:
 517                 evUpdatedEventInfo,
 518                 evUpdatedInfo,
 519
 520                         /* when seek() is implemented: */
 521                 evSeekableStatusChanged, /* for example when timeshifting */
 522
 523                 evEOF,
 524                 evSOF, /* bounced against start of file (when seeking backwards) */
 525
 526                         /* only when cueSheet is implemented */
 527                 evCuesheetChanged,
 528
 529                 evUpdatedRadioText
 530         };
 531 #ifndef SWIG
 532         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 533 #endif
 534         virtual RESULT start()=0;
 535         virtual RESULT stop()=0;
 536                         /* might have to be changed... */
 537         virtual RESULT setTarget(int target)=0;
 538         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 539         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 540         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 541         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 542         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
 543         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 544         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 545         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
 546         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
 547         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
 548         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
 549         virtual SWIG_VOID(RESULT) radioText(ePtr<iRadioText> &SWIG_OUTPUT)=0;
 550 };
 551
 552 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 553
 554 class iRecordableService: public iObject
 555 {
 556 #ifdef SWIG
 557         iRecordableService();
 558         ~iRecordableService();
 559 #endif
 560 public:
 561         enum
 562         {
 563                 evStart,
 564                 evStop,
 565                 evTunedIn,
 566                 evTuneFailed,
 567                 evRecordRunning,
 568                 evRecordStopped,
 569                 evNewProgramInfo,
 570                 evRecordFailed
 571 //              evDiskFull
 572         };
 573         enum
 574         {
 575                 NoError=0,
 576                 errOpenRecordFile=-1,
 577                 errNoDemuxAvailable=-2,
 578                 errNoTsRecorderAvailable=-3,
 579                 errDiskFull=-4,
 580                 errTuneFailed=-255
 581         };
 582 #ifndef SWIG
 583         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
 584 #endif
 585         virtual RESULT getError(int &)=0;
 586         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
 587         virtual RESULT start()=0;
 588         virtual RESULT stop()=0;
 589         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 590 };
 591
 592 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 593
 594 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
 595
 596 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
 597 {
 598         return New_iRecordableServicePtr(c);
 599 }
 600
 601 #ifndef SWIG
 602 #ifdef PYTHON_REFCOUNT_DEBUG
 603 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
 604 {
 605         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
 606 }
 607 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
 608 #else
 609 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
 610 {
 611         return New_iRecordableServicePtr(ptr);
 612 }
 613 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
 614 #endif
 615 #endif // SWIG
 616
 617 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
 618
 619 class iMutableServiceList: public iObject
 620 {
 621 #ifdef SWIG
 622         iMutableServiceList();
 623         ~iMutableServiceList();
 624 #endif
 625 public:
 626                 /* flush changes */
 627         virtual RESULT flushChanges()=0;
 628                 /* adds a service to a list */
 629         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
 630                 /* removes a service from a list */
 631         virtual RESULT removeService(eServiceReference &ref)=0;
 632                 /* moves a service in a list, only if list suppports a specific sort method. */
 633                 /* pos is the new, absolute position from 0..size-1 */
 634         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 635                 /* set name of list, for bouquets this is the visible bouquet name */
 636         virtual RESULT setListName(const std::string &name)=0;
 637 };
 638
 639 TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 640
 641 class iListableService: public iObject
 642 {
 643 #ifdef SWIG
 644         iListableService();
 645         ~iListableService();
 646 #endif
 647 public:
 648                 /* legacy interface: get a list */
 649         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
 650         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
 651
 652                 /* new, shiny interface: streaming. */
 653         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 654
 655                 /* use this for sorting. output is not sorted because of either
 656                  - performance reasons: the whole list must be buffered or
 657                  - the interface would be restricted to a list. streaming
 658                    (as well as a future "active" extension) won't be possible.
 659                 */
 660         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 661
 662         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 663 };
 664
 665 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 666
 667 #ifndef SWIG
 668         /* a helper class which can be used as argument to stl's sort(). */
 669 class iListableServiceCompare
 670 {
 671         ePtr<iListableService> m_list;
 672 public:
 673         iListableServiceCompare(iListableService *list): m_list(list) { }
 674         bool operator()(const eServiceReference &a, const eServiceReference &b)
 675         {
 676                 return m_list->compareLessEqual(a, b);
 677         }
 678 };
 679 #endif
 680
 681 class iServiceOfflineOperations: public iObject
 682 {
 683 #ifdef SWIG
 684         iServiceOfflineOperations();
 685         ~iServiceOfflineOperations();
 686 #endif
 687 public:
 688                 /* to delete a service, forever. */
 689         virtual RESULT deleteFromDisk(int simulate=1)=0;
 690
 691                 /* for transferring a service... */
 692         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 693
 694                 // TODO: additional stuff, like a conversion interface?
 695 };
 696
 697 TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 698
 699 class iServiceHandler: public iObject
 700 {
 701 #ifdef SWIG
 702         iServiceHandler();
 703         ~iServiceHandler();
 704 #endif
 705 public:
 706         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 707         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 708         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 709         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 710         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 711 };
 712
 713 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 714
 715 #endif