<map context="ChannelSelectActions">
<key id="m" mapto="mark" flags="m" />
<!-- yes, this is flexible as hell. -->
- <key id="p" mapto="bouquet:(provider == PREMIERE)" flags="m" />
- <key id="d" mapto="bouquet:(provider == ARD)" flags="m" />
+ <key id="p" mapto="bouquet:(provider == PREMIERE) && (type == 1)" flags="m" />
+ <key id="d" mapto="bouquet:(provider == ARD) && (type == 1)" flags="m" />
<key id="a" mapto="bouquet:" flags="m" />
<key id="KEY_C" mapto="contextMenu" flags="m" />
<key id="KEY_M" mapto="mark" flags="m" />
<key id="KEY_D" mapto="bouquet:(provider == ARD)" flags="m" />
<key id="KEY_A" mapto="bouquet:" flags="m" />
-
<key id="KEY_RED" mapto="bouquet:" flags="m" />
<key id="KEY_GREEN" mapto="bouquet:(provider == ARD) && (type == 1)" flags="m" />
<key id="KEY_YELLOW" mapto="bouquet:(provider == ZDF) && (type == 1)" flags="m" />
- <key id="KEY_BLUE" mapto="showFavourites" flags="m" />
+ <key id="KEY_BLUE" mapto="bouquet:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet" flags="m" />
</map>
<map context="OkCancelActions">
<key id="\x0a" mapto="ok" flags="m" />
RESULT eDVBService::getName(const eServiceReference &ref, std::string &name)
{
- name = m_service_name;
+ if ( ref.name.length() )
+ name = ref.name;
+ else
+ name = m_service_name;
return 0;
}
fclose(f);
}
+void eDVBDB::loadBouquet(const char *path)
+{
+ std::string bouquet_name = path;
+ if (!bouquet_name.length())
+ {
+ eDebug("Bouquet load failed.. no path given..");
+ return;
+ }
+ unsigned int pos = bouquet_name.rfind('/');
+ if ( pos != std::string::npos )
+ bouquet_name.erase(0, pos+1);
+ if (bouquet_name.empty())
+ {
+ eDebug("Bouquet load failed.. no filename given..");
+ return;
+ }
+ eBouquet &bouquet = m_bouquets[bouquet_name];
+ bouquet.m_path = path;
+ std::list<eServiceReference> &list = bouquet.m_services;
+ list.clear();
+
+ eDebug("loading bouquet... %s", path);
+ FILE *fp=fopen(path, "rt");
+ int entries=0;
+ if (!fp)
+ {
+ eDebug("failed to open.");
+ return;
+ }
+ char line[256];
+ bool read_descr=false;
+ eServiceReference *e = NULL;
+ while (1)
+ {
+ if (!fgets(line, 256, fp))
+ break;
+ line[strlen(line)-1]=0;
+ if (strlen(line) && line[strlen(line)-1]=='\r')
+ line[strlen(line)-1]=0;
+ if (!line[0])
+ break;
+ if (line[0]=='#')
+ {
+ if (!strncmp(line, "#SERVICE ", 9) || !strncmp(line, "#SERVICE: ", 10))
+ {
+ int offs = line[8] == ':' ? 10 : 9;
+ eServiceReference tmp(line+offs);
+ if (tmp.type != eServiceReference::idDVB)
+ {
+ eDebug("only DVB Bouquets supported");
+ continue;
+ }
+ if ( (tmp.flags&eServiceReference::flagDirectory) == eServiceReference::flagDirectory )
+ {
+ std::string str = tmp.path;
+ unsigned int pos = str.rfind('/');
+ if ( pos != std::string::npos )
+ str.erase(0, pos+1);
+ if (str.empty())
+ {
+ eDebug("Bouquet load failed.. no filename given..");
+ continue;
+ }
+ loadBouquet(tmp.path.c_str());
+ char buf[256];
+ snprintf(buf, 256, "(type == %d) FROM BOUQUET \"%s\" ORDER BY bouquet", tmp.data[0], str.c_str());
+ tmp.path = buf;
+ eDebug("read bouquet %s", tmp.toString().c_str());
+ }
+ list.push_back(tmp);
+ e = &list.back();
+ read_descr=true;
+ ++entries;
+ }
+ else if (read_descr && !strncmp(line, "#DESCRIPTION ", 13))
+ {
+ e->name = line+13;
+ read_descr=false;
+ }
+ else if (!strncmp(line, "#NAME ", 6))
+ bouquet.m_bouquet_name=line+6;
+ continue;
+ }
+ }
+ fclose(fp);
+ eDebug("%d entries in Bouquet %s", entries, bouquet_name.c_str());
+}
+
+void eDVBDB::saveBouquet(const char *path)
+{
+
+}
+
+void eDVBDB::loadBouquets()
+{
+ loadBouquet("bouquets.tv");
+ loadBouquet("bouquets.radio");
+}
+
+void eDVBDB::saveBouquets()
+{
+
+}
+
eDVBDB::eDVBDB()
{
load();
+ loadBouquets();
}
eDVBDB::~eDVBDB()
return 0;
}
-RESULT eDVBDB::startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *q)
+RESULT eDVBDB::getBouquet(const eServiceReference &ref, const eBouquet* &bouquet)
{
- query = new eDVBDBQuery(this, eServiceReference(), q);
+ std::string str = ref.path;
+ if (str.empty())
+ {
+ eDebug("getBouquet failed.. no path given!");
+ return -1;
+ }
+ unsigned int pos = str.find("FROM BOUQUET \"");
+ if ( pos != std::string::npos )
+ {
+ str.erase(0, pos+14);
+ eDebug("str now %s", str.c_str());
+ pos = str.find('"');
+ if ( pos != std::string::npos )
+ str.erase(pos);
+ else
+ str.clear();
+ eDebug("str now %s", str.c_str());
+ }
+ if (str.empty())
+ {
+ eDebug("getBouquet failed.. couldn't parse bouquet name");
+ return -1;
+ }
+ std::map<std::string, eBouquet>::iterator i =
+ m_bouquets.find(str);
+ if (i == m_bouquets.end())
+ {
+ bouquet = 0;
+ return -ENOENT;
+ }
+ bouquet = &i->second;
return 0;
}
-DEFINE_REF(eDVBDBQuery);
-
-eDVBDBQuery::eDVBDBQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query): m_db(db), m_query(query)
+RESULT eDVBDB::startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *q, const eServiceReference &source)
{
- // TODO: use SOURCE ...
- m_cursor = m_db->m_services.begin();
+ if ( q && q->m_bouquet_name.length() )
+ {
+ eDebug("bouquet");
+ query = new eDVBDBBouquetQuery(this, source, q);
+ }
+ else
+ query = new eDVBDBQuery(this, source, q);
+ return 0;
}
-RESULT eDVBDBQuery::getNextResult(eServiceReferenceDVB &ref)
-{
- while (m_cursor != m_db->m_services.end())
- {
- ref = m_cursor->first;
-
- int res = (!m_query) || m_cursor->second->checkFilter(ref, *m_query);
+DEFINE_REF(eDVBDBQueryBase);
- ++m_cursor;
-
- if (res)
- return 0;
- }
-
- ref = eServiceReferenceDVB();
- return 1;
+eDVBDBQueryBase::eDVBDBQueryBase(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
+ :m_db(db), m_query(query), m_source(source)
+{
}
-int eDVBDBQuery::compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)
+int eDVBDBQueryBase::compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)
{
ePtr<eDVBService> a_service, b_service;
case eDVBChannelQuery::tType:
return a.getServiceType() < b.getServiceType();
case eDVBChannelQuery::tBouquet:
- return 1;
+ return 0;
case eDVBChannelQuery::tSatellitePosition:
return (a.getDVBNamespace().get() >> 16) < (b.getDVBNamespace().get() >> 16);
default:
return 0;
}
+eDVBDBQuery::eDVBDBQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
+ :eDVBDBQueryBase(db, source, query)
+{
+ m_cursor = m_db->m_services.begin();
+}
+
+RESULT eDVBDBQuery::getNextResult(eServiceReferenceDVB &ref)
+{
+ while (m_cursor != m_db->m_services.end())
+ {
+ ref = m_cursor->first;
+
+ int res = (!m_query) || m_cursor->second->checkFilter(ref, *m_query);
+
+ ++m_cursor;
+
+ if (res)
+ return 0;
+ }
+
+ ref = eServiceReferenceDVB();
+ return 1;
+}
+
+eDVBDBBouquetQuery::eDVBDBBouquetQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
+ :eDVBDBQueryBase(db, source, query), m_cursor(db->m_bouquets[query->m_bouquet_name].m_services.begin())
+{
+}
+
+RESULT eDVBDBBouquetQuery::getNextResult(eServiceReferenceDVB &ref)
+{
+ eBouquet &bouquet = m_db->m_bouquets[m_query->m_bouquet_name];
+ std::list<eServiceReference> &list = bouquet.m_services;
+ while (m_cursor != list.end())
+ {
+ ref = *((eServiceReferenceDVB*)&(*m_cursor));
+
+ std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it =
+ m_db->m_services.find(ref);
+
+ int res = (!m_query) || it == m_db->m_services.end() || it->second->checkFilter(ref, *m_query);
+
+ ++m_cursor;
+
+ if (res)
+ return 0;
+ }
+
+ ref = eServiceReferenceDVB();
+
+ return 1;
+}
+
/* (<name|provider|type|bouquet|satpos|chid> <==|...> <"string"|int>)[||,&& (..)] */
static int decodeType(const std::string &type)
std::list<std::string> tokens;
std::string current_token;
-
+ std::string bouquet_name;
+
eDebug("splitting %s....", query.c_str());
unsigned int i = 0;
const char *splitchars="()";
int sort = eDVBChannelQuery::tName;
/* check for "ORDER BY ..." */
- if (tokens.size() > 2)
+
+ while (tokens.size() > 2)
{
- std::list<std::string>::iterator i = tokens.end();
- --i; --i; --i;
- if (*i == "ORDER")
+ std::list<std::string>::iterator it = tokens.end();
+ --it; --it; --it;
+ if (*it == "ORDER")
{
- ++i;
- if (*i == "BY")
+ ++it;
+ if (*it == "BY")
{
- ++i;
- sort = decodeType(*i);
+ ++it;
+ sort = decodeType(*it);
tokens.pop_back(); // ...
tokens.pop_back(); // BY
tokens.pop_back(); // ORDER
} else
sort = -1;
}
+ else if (*it == "FROM")
+ {
+ ++it;
+ if (*it == "BOUQUET")
+ {
+ ++it;
+ bouquet_name = *it;
+ tokens.pop_back(); // ...
+ tokens.pop_back(); // FROM
+ tokens.pop_back(); // BOUQUET
+ }
+ }
+ else
+ break;
}
-
+
if (sort == -1)
- {
+ {
eWarning("ORDER BY .. string invalid.");
res = 0;
return -1;
int r = parseExpression(res, tokens.begin(), tokens.end());
if (res)
+ {
res->m_sort = sort;
+ res->m_bouquet_name = bouquet_name;
+ }
eDebug("return: %d", r);
return r;
#ifndef __db_h
#define __db_h
+#include <lib/base/eptrlist.h>
#include <lib/dvb/idvb.h>
#include <set>
class ServiceDescriptionSection;
-struct eDVBBouquet
-{
- std::vector<eServiceReferenceDVB> m_services;
- int lookupService(eServiceReferenceDVB &ref);
-};
-
class eDVBDB: public iDVBChannelList
{
DECLARE_REF(eDVBDB);
friend class eDVBDBQuery;
+ friend class eDVBDBBouquetQuery;
private:
struct channel
{
std::map<eServiceReferenceDVB, ePtr<eDVBService> > m_services;
- std::map<eServiceReference, eDVBBouquet> m_bouquets;
+ std::map<std::string, eBouquet> m_bouquets;
public:
void load();
void save();
+
+ void loadBouquet(const char *path);
+ void saveBouquet(const char *path);
+ void loadBouquets();
+ void saveBouquets();
+
eDVBDB();
virtual ~eDVBDB();
RESULT addService(const eServiceReferenceDVB &service, eDVBService *service);
RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service);
-
- RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query);
+
+ RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source);
+
+ RESULT getBouquet(const eServiceReference &ref, const eBouquet* &bouquet);
};
// we have to add a possibility to invalidate here.
-class eDVBDBQuery: public iDVBChannelListQuery
+class eDVBDBQueryBase: public iDVBChannelListQuery
{
-DECLARE_REF(eDVBDBQuery);
-private:
+DECLARE_REF(eDVBDBQueryBase);
+protected:
std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator m_cursor;
ePtr<eDVBDB> m_db;
ePtr<eDVBChannelQuery> m_query;
eServiceReference m_source;
public:
- eDVBDBQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query);
- virtual RESULT getNextResult(eServiceReferenceDVB &ref);
-
+ eDVBDBQueryBase(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query);
int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b);
};
+class eDVBDBQuery: public eDVBDBQueryBase
+{
+ std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator m_cursor;
+public:
+ eDVBDBQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query);
+ RESULT getNextResult(eServiceReferenceDVB &ref);
+};
+
+class eDVBDBBouquetQuery: public eDVBDBQueryBase
+{
+ std::list<eServiceReference>::iterator m_cursor;
+public:
+ eDVBDBBouquetQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query);
+ RESULT getNextResult(eServiceReferenceDVB &ref);
+};
+
#endif
#include <fcntl.h>
#include <sys/ioctl.h>
+#ifndef I2C_SLAVE_FORCE
+#define I2C_SLAVE_FORCE 0x0706
+#endif
+
#if HAVE_DVB_API_VERSION < 3
#include <ost/frontend.h>
#include <ost/sec.h>
#include <libsig_comp.h>
#include <connection.h>
+struct eBouquet
+{
+ std::string m_bouquet_name;
+ std::string m_path;
+ std::list<eServiceReference> m_services;
+};
+
// bitte KEINE operator int() definieren, sonst bringt das ganze nix!
struct eTransportStreamID
{
/* sort is only valid in root, and must be from the enum above. */
int m_sort;
+ std::string m_bouquet_name;
static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
- virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query)=0;
+ virtual RESULT getBouquet(const eServiceReference &ref, const eBouquet* &bouquet)=0;
+
+ virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
};
class SatelliteDeliverySystemDescriptor;
# ...
def channelSelected(self):
- if not (self.movemode):
- self.session.nav.playService(self["list"].getCurrent())
- print "current: " + self["list"].getCurrent().toString()
- self.close()
- else:
+ ref = self["list"].getCurrent()
+ if self.movemode:
if self.entry_marked:
self["list"].setCurrentMarked(False)
self.entry_marked = False
else:
self["list"].setCurrentMarked(True)
self.entry_marked = True
+ elif (ref.flags & 7) == 7:
+ l = self["list"]
+ l.setMode(l.MODE_NORMAL)
+ l.setRoot(ref)
+ else:
+ self.session.nav.playService(ref)
+ print "current: " + ref.toString()
+ self.close()
#called from infoBar
def zap(self):
int data[8];
std::string path;
+// only for override service names in bouquets or to give servicerefs a name which not have a
+// real existing service ( for dvb eServiceDVB )
+ std::string name;
+
eServiceReference()
: type(idInvalid), flags(0)
{
#include <lib/dvb/metaparser.h>
#include <lib/dvb/tstools.h>
+class eStaticServiceDVBInformation: public iStaticServiceInformation
+{
+ DECLARE_REF(eStaticServiceDVBInformation);
+public:
+ RESULT getName(const eServiceReference &ref, std::string &name);
+ int getLength(const eServiceReference &ref);
+};
+
+DEFINE_REF(eStaticServiceDVBInformation);
+
+RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
+{
+ if ( ref.name.length() )
+ {
+ name = ref.name;
+ return 0;
+ }
+ else
+ return -1;
+}
+
+int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
+{
+ return -1;
+}
+
+class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
+{
+ DECLARE_REF(eStaticServiceDVBBouquetInformation);
+public:
+ RESULT getName(const eServiceReference &ref, std::string &name);
+ int getLength(const eServiceReference &ref);
+};
+
+DEFINE_REF(eStaticServiceDVBBouquetInformation);
+
+RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
+{
+ ePtr<iDVBChannelList> db;
+ ePtr<eDVBResourceManager> res;
+
+ int err;
+ if ((err = eDVBResourceManager::getInstance(res)) != 0)
+ {
+ eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
+ return err;
+ }
+ if ((err = res->getChannelList(db)) != 0)
+ {
+ eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
+ return err;
+ }
+
+ const eBouquet *bouquet=0;
+ if ((err = db->getBouquet(ref, bouquet)) != 0)
+ {
+ eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
+ return -1;
+ }
+
+ if ( bouquet && bouquet->m_bouquet_name.length() )
+ {
+ name = "[Bouquet] " + bouquet->m_bouquet_name;
+ return 0;
+ }
+ else
+ return -1;
+}
+
+int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
+{
+ return -1;
+}
+
class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
{
DECLARE_REF(eStaticServiceDVBPVRInformation);
}
}
- if ((err = db->startQuery(m_query, q)) != 0)
+ if ((err = db->startQuery(m_query, q, m_parent)) != 0)
{
eDebug("startQuery failed");
return err;
RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
{
/* do we have a PVR service? */
- if (ref.path.size())
+ if (ref.flags & eServiceReference::flagDirectory) // bouquet
+ {
+ ptr = new eStaticServiceDVBBouquetInformation;
+ return 0;
+ }
+ else if (ref.path.size())
{
ptr = new eStaticServiceDVBPVRInformation(ref);
return 0;
- } else
+ }
+ else
{
ePtr<eDVBService> service;
int r = lookupService(service, ref);
if (r)
- return r;
+ ptr = new eStaticServiceDVBInformation;
+ else
/* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
- ptr = service;
+ ptr = service;
return 0;
}
}
projects / vuplus_dvbapp / commitdiff