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