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         enum { resNA = -1, resIsString = -2, resIsPyObject = -3 };
 306
 307         virtual int getInfo(int w);
 308         virtual std::string getInfoString(int w);
 309         virtual PyObject *getInfoObject(int w);
 310
 311         virtual int setInfo(int w, int v);
 312         virtual int setInfoString(int w, const char *v);
 313 };
 314
 315 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 316
 317 class iFrontendInformation: public iObject
 318 {
 319 #ifdef SWIG
 320         iFrontendInformation();
 321         ~iFrontendInformation();
 322 #endif
 323 public:
 324         enum {
 325                 bitErrorRate,
 326                 signalPower,
 327                 signalQuality,
 328                 lockState,
 329                 syncState,
 330                 frontendNumber
 331         };
 332         virtual int getFrontendInfo(int w)=0;
 333         virtual PyObject *getFrontendData(bool original=false)=0;
 334 };
 335
 336 TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
 337
 338 class iPauseableService: public iObject
 339 {
 340 #ifdef SWIG
 341         iPausableService();
 342         ~iPausableService();
 343 #endif
 344 public:
 345         virtual RESULT pause()=0;
 346         virtual RESULT unpause()=0;
 347
 348                 /* hm. */
 349         virtual RESULT setSlowMotion(int ratio=0)=0;
 350         virtual RESULT setFastForward(int ratio=0)=0;
 351 };
 352
 353 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 354
 355 class iSeekableService: public iObject
 356 {
 357 #ifdef SWIG
 358         iSeekableService();
 359         ~iSeekableService();
 360 #endif
 361 public:
 362         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 363         virtual RESULT seekTo(pts_t to)=0;
 364         enum { dirForward = +1, dirBackward = -1 };
 365         virtual RESULT seekRelative(int direction, pts_t to)=0;
 366         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 367                 /* if you want to do several seeks in a row, you can enable the trickmode.
 368                    audio will be switched off, sync will be disabled etc. */
 369         virtual RESULT setTrickmode(int trick=0)=0;
 370         virtual RESULT isCurrentlySeekable()=0;
 371 };
 372
 373 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 374
 375 struct iAudioTrackInfo
 376 {
 377 #ifndef SWIG
 378         std::string m_description;
 379         std::string m_language; /* iso639 */
 380 #endif
 381         std::string getDescription() { return m_description; }
 382         std::string getLanguage() { return m_language; }
 383 };
 384
 385 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 386
 387 class iAudioTrackSelection: public iObject
 388 {
 389 #ifdef SWIG
 390         iAudioTrackSelection();
 391         ~iAudioTrackSelection();
 392 #endif
 393 public:
 394         virtual int getNumberOfTracks()=0;
 395         virtual RESULT selectTrack(unsigned int i)=0;
 396         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 397 };
 398
 399 TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 400
 401 class iAudioChannelSelection: public iObject
 402 {
 403 #ifdef SWIG
 404         iAudioChannelSelection();
 405         ~iAudioChannelSelection();
 406 #endif
 407 public:
 408         enum { LEFT, STEREO, RIGHT };
 409         virtual int getCurrentChannel()=0;
 410         virtual RESULT selectChannel(int i)=0;
 411 };
 412
 413 TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
 414
 415 class iAudioDelay: public iObject
 416 {
 417 #ifdef SWIG
 418         iAudioDelay();
 419         ~iAudioDelay();
 420 #endif
 421 public:
 422         virtual int getAC3Delay()=0;
 423         virtual int getPCMDelay()=0;
 424         virtual void setAC3Delay(int)=0;
 425         virtual void setPCMDelay(int)=0;
 426 };
 427
 428 TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
 429
 430 class iRadioText: public iObject
 431 {
 432 #ifdef SWIG
 433         iRadioText();
 434         ~iRadioText();
 435 #endif
 436 public:
 437         virtual std::string getRadioText(int x=0)=0;
 438 };
 439
 440 TEMPLATE_TYPEDEF(ePtr<iRadioText>, iRadioTextPtr);
 441
 442 class iSubserviceList: public iObject
 443 {
 444 #ifdef SWIG
 445         iSubserviceList();
 446         ~iSubserviceList();
 447 #endif
 448 public:
 449         virtual int getNumberOfSubservices()=0;
 450         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
 451 };
 452
 453 TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
 454
 455 class iTimeshiftService: public iObject
 456 {
 457 #ifdef SWIG
 458         iTimeshiftService();
 459         ~iTimeshiftService();
 460 #endif
 461 public:
 462         virtual RESULT startTimeshift()=0;
 463         virtual RESULT stopTimeshift()=0;
 464
 465         virtual int isTimeshiftActive()=0;
 466                         /* this essentially seeks to the relative end of the timeshift buffer */
 467         virtual RESULT activateTimeshift()=0;
 468 };
 469
 470 TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
 471
 472         /* not related to eCueSheet */
 473 class iCueSheet: public iObject
 474 {
 475 #ifdef SWIG
 476         iCueSheet();
 477         ~iCueSheet();
 478 #endif
 479 public:
 480                         /* returns a list of (pts, what)-tuples */
 481         virtual PyObject *getCutList() = 0;
 482         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
 483         virtual void setCutListEnable(int enable) = 0;
 484         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
 485 };
 486
 487 TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
 488
 489 class eWidget;
 490 class PyList;
 491
 492 class iSubtitleOutput: public iObject
 493 {
 494 public:
 495         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
 496         virtual RESULT disableSubtitles(eWidget *parent)=0;
 497         virtual PyObject *getSubtitleList()=0;
 498         virtual PyObject *getCachedSubtitle()=0;
 499 };
 500
 501 TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
 502
 503 class iPlayableService: public iObject
 504 {
 505 #ifdef SWIG
 506         iPlayableService();
 507         ~iPlaybleService();
 508 #endif
 509         friend class iServiceHandler;
 510 public:
 511         enum
 512         {
 513                         /* these first two events are magical, and should only
 514                            be generated if you know what you're doing. */
 515                 evStart,
 516                 evEnd,
 517
 518                 evTuneFailed,
 519                         // when iServiceInformation is implemented:
 520                 evUpdatedEventInfo,
 521                 evUpdatedInfo,
 522
 523                         /* when seek() is implemented: */
 524                 evSeekableStatusChanged, /* for example when timeshifting */
 525
 526                 evEOF,
 527                 evSOF, /* bounced against start of file (when seeking backwards) */
 528
 529                         /* only when cueSheet is implemented */
 530                 evCuesheetChanged,
 531
 532                 evUpdatedRadioText
 533         };
 534 #ifndef SWIG
 535         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 536 #endif
 537         virtual RESULT start()=0;
 538         virtual RESULT stop()=0;
 539                         /* might have to be changed... */
 540         virtual RESULT setTarget(int target)=0;
 541         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 542         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 543         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 544         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 545         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
 546         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 547         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 548         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
 549         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
 550         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
 551         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
 552         virtual SWIG_VOID(RESULT) radioText(ePtr<iRadioText> &SWIG_OUTPUT)=0;
 553 };
 554
 555 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 556
 557 class iRecordableService: public iObject
 558 {
 559 #ifdef SWIG
 560         iRecordableService();
 561         ~iRecordableService();
 562 #endif
 563 public:
 564         enum
 565         {
 566                 evStart,
 567                 evStop,
 568                 evTunedIn,
 569                 evTuneFailed,
 570                 evRecordRunning,
 571                 evRecordStopped,
 572                 evNewProgramInfo,
 573                 evRecordFailed
 574 //              evDiskFull
 575         };
 576         enum
 577         {
 578                 NoError=0,
 579                 errOpenRecordFile=-1,
 580                 errNoDemuxAvailable=-2,
 581                 errNoTsRecorderAvailable=-3,
 582                 errDiskFull=-4,
 583                 errTuneFailed=-255
 584         };
 585 #ifndef SWIG
 586         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
 587 #endif
 588         virtual RESULT getError(int &)=0;
 589         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
 590         virtual RESULT start()=0;
 591         virtual RESULT stop()=0;
 592         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 593 };
 594
 595 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 596
 597 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
 598
 599 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
 600 {
 601         return New_iRecordableServicePtr(c);
 602 }
 603
 604 #ifndef SWIG
 605 #ifdef PYTHON_REFCOUNT_DEBUG
 606 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
 607 {
 608         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
 609 }
 610 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
 611 #else
 612 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
 613 {
 614         return New_iRecordableServicePtr(ptr);
 615 }
 616 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
 617 #endif
 618 #endif // SWIG
 619
 620 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
 621
 622 class iMutableServiceList: public iObject
 623 {
 624 #ifdef SWIG
 625         iMutableServiceList();
 626         ~iMutableServiceList();
 627 #endif
 628 public:
 629                 /* flush changes */
 630         virtual RESULT flushChanges()=0;
 631                 /* adds a service to a list */
 632         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
 633                 /* removes a service from a list */
 634         virtual RESULT removeService(eServiceReference &ref)=0;
 635                 /* moves a service in a list, only if list suppports a specific sort method. */
 636                 /* pos is the new, absolute position from 0..size-1 */
 637         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 638                 /* set name of list, for bouquets this is the visible bouquet name */
 639         virtual RESULT setListName(const std::string &name)=0;
 640 };
 641
 642 TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 643
 644 class iListableService: public iObject
 645 {
 646 #ifdef SWIG
 647         iListableService();
 648         ~iListableService();
 649 #endif
 650 public:
 651                 /* legacy interface: get a list */
 652         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
 653         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
 654
 655                 /* new, shiny interface: streaming. */
 656         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 657
 658                 /* use this for sorting. output is not sorted because of either
 659                  - performance reasons: the whole list must be buffered or
 660                  - the interface would be restricted to a list. streaming
 661                    (as well as a future "active" extension) won't be possible.
 662                 */
 663         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 664
 665         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 666 };
 667
 668 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 669
 670 #ifndef SWIG
 671         /* a helper class which can be used as argument to stl's sort(). */
 672 class iListableServiceCompare
 673 {
 674         ePtr<iListableService> m_list;
 675 public:
 676         iListableServiceCompare(iListableService *list): m_list(list) { }
 677         bool operator()(const eServiceReference &a, const eServiceReference &b)
 678         {
 679                 return m_list->compareLessEqual(a, b);
 680         }
 681 };
 682 #endif
 683
 684 class iServiceOfflineOperations: public iObject
 685 {
 686 #ifdef SWIG
 687         iServiceOfflineOperations();
 688         ~iServiceOfflineOperations();
 689 #endif
 690 public:
 691                 /* to delete a service, forever. */
 692         virtual RESULT deleteFromDisk(int simulate=1)=0;
 693
 694                 /* for transferring a service... */
 695         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 696
 697                 // TODO: additional stuff, like a conversion interface?
 698 };
 699
 700 TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 701
 702 class iServiceHandler: public iObject
 703 {
 704 #ifdef SWIG
 705         iServiceHandler();
 706         ~iServiceHandler();
 707 #endif
 708 public:
 709         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 710         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 711         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 712         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 713         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 714 };
 715
 716 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 717
 718 #endif