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