implemented epg2vdr support

extensions/globaltimers.c

@@ -0,0 +1,233 @@
+#include "globaltimers.h"
+#include "../services/epgsearch.h"
+#include "../services/remotetimers.h"
+#include "../services/epgtimer.h"
+
+static int CompareTimers(const void *a, const void *b) {
+    return (*(const cTimer **)a)->Compare(**(const cTimer **)b);
+}
+
+bool cGlobalTimers::initial = true;
+cRemoteTimerRefresh *cGlobalTimers::remoteTimerRefresh = NULL;
+
+cGlobalTimers::cGlobalTimers(void) : cVector<const cTimer*>(0) {
+    pEpg2Vdr = cPluginManager::GetPlugin("epg2vdr");
+    pRemoteTimers = cPluginManager::GetPlugin("remotetimers");
+    pEpgSearch = cPluginManager::GetPlugin("epgsearch");
+    localTimer = NULL;
+    isEpg2VdrTimers = false;
+}
+
+cGlobalTimers::~cGlobalTimers(void) {
+    if (localTimer) {
+        delete[] localTimer;
+    }
+    ClearTimers();
+}
+
+void cGlobalTimers::LoadTimers(void) {
+    uint64_t start = cTimeMs::Now();
+    isEpg2VdrTimers = false;
+    bool epg2vdrOk = false;
+    if (pEpg2Vdr) {
+        epg2vdrOk = SetEpg2VdrTimers();
+    }
+    if (!epg2vdrOk) {
+        SetLocalTimers();    
+        if (pRemoteTimers) {
+            SetRemoteTimers(initial);
+        }        
+    }
+    esyslog("skindesigner: loaded %d timers, needed %d ms", Size(), cTimeMs::Now() - start);
+    initial = false;
+}
+
+void cGlobalTimers::SortTimers(void) {
+    Sort(CompareTimers);
+}
+
+void cGlobalTimers::MarkLocalTimers(void) {
+    if (isEpg2VdrTimers)
+        return;
+
+    if (localTimer) {
+        delete[] localTimer;
+        localTimer = NULL;
+    }
+#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
+    LOCK_TIMERS_READ;
+    const cTimers* timers = Timers;
+#else
+    const cTimers* timers = &Timers;
+#endif
+    int numTimers = Size();
+    if (numTimers > 0) {
+        localTimer = new bool[numTimers];
+        for (int i=0; i < numTimers; i++) {
+            if (!pRemoteTimers) {
+                localTimer[i] = true;
+            } else {
+                localTimer[i] = false;
+                for (const cTimer *Timer = timers->First(); Timer; Timer = timers->Next(Timer)) {
+                    if (Timer == At(i)) {
+                        localTimer[i] = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void cGlobalTimers::SetLocalTimers(void) {
+#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
+    LOCK_TIMERS_READ;
+    const cTimers* timers = Timers;
+#else
+    const cTimers* timers = &Timers;
+#endif
+    for (const cTimer *Timer = timers->First(); Timer; Timer = timers->Next(Timer)) {
+        if (Timer->HasFlags(tfActive))
+            Append(Timer);
+    }    
+}
+
+void cGlobalTimers::SetRemoteTimers(bool initial) {
+    if (initial) {
+        cString errorMsg;
+        pRemoteTimers->Service("RemoteTimers::RefreshTimers-v1.0", &errorMsg);
+    }
+#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
+    LOCK_SCHEDULES_READ;
+    const cSchedules* schedules = Schedules;
+#else
+    cSchedulesLock schedulesLock;
+    const cSchedules* schedules = (cSchedules*)cSchedules::Schedules(schedulesLock);
+#endif
+    cTimer* remoteTimer = NULL;
+    while (pRemoteTimers->Service("RemoteTimers::ForEach-v1.0", &remoteTimer) && remoteTimer != NULL) {
+        remoteTimer->SetEventFromSchedule(schedules); // make sure the event is current
+        if (remoteTimer->HasFlags(tfActive))
+            Append(remoteTimer);
+    }
+}
+
+bool cGlobalTimers::SetEpg2VdrTimers(void) {
+    bool ok = false;
+    cEpgTimer_Service_V1 data;
+    if (pEpg2Vdr->Service(EPG2VDR_TIMER_SERVICE, &data)) {
+        for (std::list<cEpgTimer_Interface_V1*>::iterator it = data.epgTimers.begin(); it != data.epgTimers.end(); ++it) {
+            ok = true;
+            isEpg2VdrTimers = true;
+            if ((*it)->HasFlags(tfActive)) {
+                Append(*it);
+            }
+        }
+    }
+    return ok;
+}
+
+int cGlobalTimers::NumTimerConfilicts(void) {
+    int numConflicts = 0;
+    if (pEpgSearch) {
+        Epgsearch_lastconflictinfo_v1_0 *serviceData = new Epgsearch_lastconflictinfo_v1_0;
+        if (serviceData) {
+            serviceData->nextConflict = 0;
+            serviceData->relevantConflicts = 0;
+            serviceData->totalConflicts = 0;
+            pEpgSearch->Service("Epgsearch-lastconflictinfo-v1.0", serviceData);
+            if (serviceData->relevantConflicts > 0) {
+                numConflicts = serviceData->relevantConflicts;
+            }
+            delete serviceData;
+        }
+    }
+    return numConflicts;
+}
+
+bool cGlobalTimers::IsRemoteTimer(int i) {
+    if (isEpg2VdrTimers) {
+        cEpgTimer_Interface_V1* epgTimer;
+        if (epgTimer = dynamic_cast<cEpgTimer_Interface_V1*>((cTimer*)At(i)))
+            return !epgTimer->isLocal();
+        else
+            return false;
+    }
+    if (!localTimer)
+        return true;
+    if (i >= Size())
+        return true;
+    return !(localTimer[i]);
+}
+
+const char* cGlobalTimers::RemoteHost(int i) {
+    if (isEpg2VdrTimers) {
+        cEpgTimer_Interface_V1* epgTimer;
+        if (epgTimer = dynamic_cast<cEpgTimer_Interface_V1*>((cTimer*)At(i)))
+            return epgTimer->VdrName();
+    }
+    return "";
+}
+
+void cGlobalTimers::ClearTimers(void) {
+    if (isEpg2VdrTimers) {
+        int size = Size();
+        for (int i=0; i<size; i++) {
+            delete At(i);
+        }
+    }
+    Clear();
+}
+
+void cGlobalTimers::StartRefreshThread(void) {
+    if (remoteTimerRefresh == NULL) {
+        remoteTimerRefresh = new cRemoteTimerRefresh();
+    }
+}
+
+void cGlobalTimers::StopRefreshThread(void) {
+    if (!remoteTimerRefresh)
+        return;
+    delete remoteTimerRefresh;
+    remoteTimerRefresh = NULL;
+    initial = true;
+}
+
+/*************************************************************************
+* cRemoteTimerRefresh
+*************************************************************************/
+cRemoteTimerRefresh::cRemoteTimerRefresh(): cThread("skindesigner: RemoteTimers::RefreshTimers") {
+    pRemoteTimers = cPluginManager::GetPlugin("remotetimers");
+    if (pRemoteTimers)
+        Start();
+}
+
+cRemoteTimerRefresh::~cRemoteTimerRefresh(void) {
+    Cancel(-1);
+    while (Active())
+        cCondWait::SleepMs(10);
+}
+
+void cRemoteTimerRefresh::Action(void) {    
+#define REFESH_INTERVALL_MS 30000
+    int sleepSlice = 1000;
+    int slept = 0;
+    while (Running()) {
+        while (Running() && slept < REFESH_INTERVALL_MS) {
+            cCondWait::SleepMs(sleepSlice);
+            slept += sleepSlice;
+        }
+        slept = 0;
+        // make sure that no timer is currently being edited
+        if (!cOsd::IsOpen() && Running()) {
+            cString errorMsg;
+            pRemoteTimers->Service("RemoteTimers::RefreshTimers-v1.0", &errorMsg);
+#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
+            LOCK_TIMERS_WRITE;
+            Timers->SetModified();
+#else
+            Timers.SetModified();
+#endif
+        }
+    }
+}

extensions/globaltimers.h

@@ -0,0 +1,44 @@
+#ifndef __GLOBALTIMERS_H
+#define __GLOBALTIMERS_H
+
+#include <vdr/timers.h>
+#include <vdr/plugin.h>
+
+class cRemoteTimerRefresh;
+
+class cGlobalTimers : public cVector<const cTimer *> {
+    private:
+        static bool initial;
+        static cRemoteTimerRefresh *remoteTimerRefresh;
+        bool *localTimer;
+        cPlugin *pEpg2Vdr;
+        cPlugin *pRemoteTimers;
+        cPlugin *pEpgSearch;
+        bool isEpg2VdrTimers;
+        void SetLocalTimers(void);
+        void SetRemoteTimers(bool initial);
+        bool SetEpg2VdrTimers(void);
+    public:
+        cGlobalTimers(void);
+        virtual ~cGlobalTimers(void);
+        void LoadTimers(void);
+        void SortTimers(void);
+        void MarkLocalTimers(void);
+        int NumTimerConfilicts(void);
+        bool IsRemoteTimer(int i);
+        const char* RemoteHost(int i);
+        void ClearTimers(void);
+        static void StartRefreshThread(void);
+        static void StopRefreshThread(void);
+};
+
+class cRemoteTimerRefresh: public cThread {
+    private:
+        cPlugin* pRemoteTimers;
+    protected:
+        virtual void Action(void);
+    public:
+        cRemoteTimerRefresh(void);
+        virtual ~cRemoteTimerRefresh(void);
+};
+#endif //__GLOBALTIMERS_H

extensions/timers.c

@@ -1,134 +0,0 @@
-#include "timers.h"
-#include "../services/epgsearch.h"
-#include "../services/remotetimers.h"
-
-static int CompareTimers(const void *a, const void *b) {
-    return (*(const cTimer **)a)->Compare(**(const cTimer **)b);
-}
-
-cGlobalSortedTimers::cGlobalSortedTimers(int timerCount, bool forceRefresh) : cVector<const cTimer*>(timerCount) {
-    static bool initial = true;
-    static cRemoteTimerRefresh *remoteTimerRefresh = NULL;
-    localTimer = NULL;
-
-    if (forceRefresh)
-        initial = true;
-    //check if remotetimers plugin is available
-    static cPlugin* pRemoteTimers = cPluginManager::GetPlugin("remotetimers");
-
-#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
-    LOCK_TIMERS_READ;
-    LOCK_SCHEDULES_READ;
-    const cTimers* timers = Timers;
-    const cSchedules* schedules = Schedules;
-#else
-    const cTimers* timers = &Timers;
-    cSchedulesLock schedulesLock;
-    const cSchedules* schedules = (cSchedules*)cSchedules::Schedules(schedulesLock);
-#endif
-    
-    if (pRemoteTimers && initial) {
-        cString errorMsg;
-        pRemoteTimers->Service("RemoteTimers::RefreshTimers-v1.0", &errorMsg);
-        initial = false;
-    }
-
-    for (const cTimer *Timer = timers->First(); Timer; Timer = timers->Next(Timer)) {
-        if (Timer->HasFlags(tfActive))
-            Append(Timer);
-    }
-
-    //if remotetimers plugin is available, take timers also from him
-    if (pRemoteTimers) {
-        cTimer* remoteTimer = NULL;
-        while (pRemoteTimers->Service("RemoteTimers::ForEach-v1.0", &remoteTimer) && remoteTimer != NULL) {
-            remoteTimer->SetEventFromSchedule(schedules); // make sure the event is current
-            if (remoteTimer->HasFlags(tfActive))
-                Append(remoteTimer);
-        }
-    }
-  
-    Sort(CompareTimers);
-    
-    int numTimers = Size();
-    if (numTimers > 0) {
-        localTimer = new bool[numTimers];
-        for (int i=0; i < numTimers; i++) {
-            if (!pRemoteTimers) {
-                localTimer[i] = true;
-            } else {
-                localTimer[i] = false;
-                for (const cTimer *Timer = timers->First(); Timer; Timer = timers->Next(Timer)) {
-                    if (Timer == At(i)) {
-                        localTimer[i] = true;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    if (pRemoteTimers && (remoteTimerRefresh == NULL))
-        remoteTimerRefresh = new cRemoteTimerRefresh();
-}
-
-cGlobalSortedTimers::~cGlobalSortedTimers(void) {
-    if (localTimer) {
-        delete[] localTimer;
-    }
-}
-
-bool cGlobalSortedTimers::IsRemoteTimer(int i) {
-    if (!localTimer)
-        return true;
-    if (i >= Size())
-        return true;
-    return !(localTimer[i]);
-}
-
-
-int cGlobalSortedTimers::NumTimerConfilicts(void) {
-    int numConflicts = 0;
-    cPlugin *p = cPluginManager::GetPlugin("epgsearch");
-    if (p) {
-        Epgsearch_lastconflictinfo_v1_0 *serviceData = new Epgsearch_lastconflictinfo_v1_0;
-        if (serviceData) {
-            serviceData->nextConflict = 0;
-            serviceData->relevantConflicts = 0;
-            serviceData->totalConflicts = 0;
-            p->Service("Epgsearch-lastconflictinfo-v1.0", serviceData);
-            if (serviceData->relevantConflicts > 0) {
-                numConflicts = serviceData->relevantConflicts;
-            }
-            delete serviceData;
-        }
-    }
-    return numConflicts;
-}
-
-cRemoteTimerRefresh::cRemoteTimerRefresh(): cThread("skindesigner: RemoteTimers::RefreshTimers") {
-    Start();
-}
-
-cRemoteTimerRefresh::~cRemoteTimerRefresh(void) {
-    Cancel(-1);
-    while (Active())
-        cCondWait::SleepMs(10);
-}
-
-void cRemoteTimerRefresh::Action(void) {    
-#define REFESH_INTERVALL_MS 30000
-    while (Running()) {
-        cCondWait::SleepMs(REFESH_INTERVALL_MS);
-        // make sure that no timer is currently being edited
-        if (!cOsd::IsOpen()) {
-            cGlobalSortedTimers(true);
-#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
-            LOCK_TIMERS_WRITE;
-            Timers->SetModified();
-#else
-            Timers.SetModified();
-#endif
-        }
-    }
-}

extensions/timers.h

@@ -1,24 +0,0 @@
-#ifndef __NOPACITY_TIMERS_H
-#define __NOPACITY_TIMERS_H
-
-#include <vdr/timers.h>
-#include <vdr/plugin.h>
-
-class cGlobalSortedTimers : public cVector<const cTimer *> {
-    private:
-        bool *localTimer;
-    public:
-        cGlobalSortedTimers(int timerCount, bool forceRefresh = false);
-        virtual ~cGlobalSortedTimers(void);
-        bool IsRemoteTimer(int i);
-        int NumTimerConfilicts(void);
-};
-
-class cRemoteTimerRefresh: public cThread {
-    protected:
-        virtual void Action(void);
-    public:
-        cRemoteTimerRefresh(void);
-        virtual ~cRemoteTimerRefresh(void);
-};
-#endif //__NOPACITY_TIMERS_H