mirrors/neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-neutrino/neutrino.git synced 2025-08-30 17:01:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix initializers and shadows

Browse Source 
git-svn-id: file:///home/bas/coolstream_public_svn/THIRDPARTY/applications/neutrino-experimental@124 e54a6e83-5905-42d5-8d5c-058d10e6a962
This commit is contained in:
mws
2009-12-29 13:56:52 +00:00
parent 00353cf75d
commit 474790557f
10 changed files with 196 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/timerd/timerd.cpp
View File

@@ -141,58 +141,58 @@ bool timerd_parse_command(CBasicMessage::Header &rmsg, int connfd)
if (CBasicServer::send_data(connfd, &responseInteger, sizeof(responseInteger)) == true)
{
for(CTimerEventMap::iterator pos = events.begin();pos != events.end();pos++)
for(CTimerEventMap::iterator lpos = events.begin();lpos != events.end();++lpos)
{
CTimerd::responseGetTimer resp;
CTimerd::responseGetTimer lresp;
CTimerEvent *event = pos->second;
CTimerEvent *event = lpos->second;
resp.eventID = event->eventID;
resp.eventState = event->eventState;
resp.eventType = event->eventType;
resp.eventRepeat = event->eventRepeat;
resp.announceTime = event->announceTime;
resp.alarmTime = event->alarmTime;
resp.stopTime = event->stopTime;
resp.repeatCount = event->repeatCount;
lresp.eventID = event->eventID;
lresp.eventState = event->eventState;
lresp.eventType = event->eventType;
lresp.eventRepeat = event->eventRepeat;
lresp.announceTime = event->announceTime;
lresp.alarmTime = event->alarmTime;
lresp.stopTime = event->stopTime;
lresp.repeatCount = event->repeatCount;
if(event->eventType == CTimerd::TIMER_STANDBY)
resp.standby_on = static_cast<CTimerEvent_Standby*>(event)->standby_on;
lresp.standby_on = static_cast<CTimerEvent_Standby*>(event)->standby_on;
else if(event->eventType == CTimerd::TIMER_NEXTPROGRAM)
{
resp.epgID = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.epgID;
resp.epg_starttime = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.epg_starttime;
resp.channel_id = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.channel_id;
resp.apids = static_cast<CTimerEvent_Record*>(event)->eventInfo.apids;
lresp.epgID = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.epgID;
lresp.epg_starttime = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.epg_starttime;
lresp.channel_id = static_cast<CTimerEvent_NextProgram*>(event)->eventInfo.channel_id;
lresp.apids = static_cast<CTimerEvent_Record*>(event)->eventInfo.apids;
}
else if(event->eventType == CTimerd::TIMER_RECORD)
{
CTimerEvent_Record* ev= static_cast<CTimerEvent_Record*>(event);
resp.epgID = ev->eventInfo.epgID;
resp.epg_starttime = ev->eventInfo.epg_starttime;
resp.channel_id = ev->eventInfo.channel_id;
resp.apids = ev->eventInfo.apids;
strcpy(resp.recordingDir, ev->recordingDir.substr(0,sizeof(resp.recordingDir)-1).c_str());
strcpy(resp.epgTitle, ev->epgTitle.substr(0,sizeof(resp.epgTitle)-1).c_str());
lresp.epgID = ev->eventInfo.epgID;
lresp.epg_starttime = ev->eventInfo.epg_starttime;
lresp.channel_id = ev->eventInfo.channel_id;
lresp.apids = ev->eventInfo.apids;
strcpy(lresp.recordingDir, ev->recordingDir.substr(0,sizeof(lresp.recordingDir)-1).c_str());
strcpy(lresp.epgTitle, ev->epgTitle.substr(0,sizeof(lresp.epgTitle)-1).c_str());
}
else if(event->eventType == CTimerd::TIMER_ZAPTO)
{
CTimerEvent_Zapto* ev= static_cast<CTimerEvent_Zapto*>(event);
resp.epgID = ev->eventInfo.epgID;
resp.epg_starttime = ev->eventInfo.epg_starttime;
resp.channel_id = ev->eventInfo.channel_id;
resp.apids = ev->eventInfo.apids;
strcpy(resp.epgTitle, ev->epgTitle.substr(0,sizeof(resp.epgTitle)-1).c_str());
lresp.epgID = ev->eventInfo.epgID;
lresp.epg_starttime = ev->eventInfo.epg_starttime;
lresp.channel_id = ev->eventInfo.channel_id;
lresp.apids = ev->eventInfo.apids;
strcpy(lresp.epgTitle, ev->epgTitle.substr(0,sizeof(lresp.epgTitle)-1).c_str());
}
else if(event->eventType == CTimerd::TIMER_REMIND)
{
strcpy(resp.message, static_cast<CTimerEvent_Remind*>(event)->message);
strcpy(lresp.message, static_cast<CTimerEvent_Remind*>(event)->message);
}
else if(event->eventType == CTimerd::TIMER_EXEC_PLUGIN)
{
strcpy(resp.pluginName, static_cast<CTimerEvent_ExecPlugin*>(event)->name);
strcpy(lresp.pluginName, static_cast<CTimerEvent_ExecPlugin*>(event)->name);
}
CBasicServer::send_data(connfd, &resp, sizeof(CTimerd::responseGetTimer));
CBasicServer::send_data(connfd, &lresp, sizeof(CTimerd::responseGetTimer));
}
}
break;

138
src/timerd/timermanager.cpp
View File

@@ -157,7 +157,7 @@ void* CTimerManager::timerThread(void *arg)
{
dprintf("stopping event\n");
event->stopEvent(); // event specific stop handler
event->setState(CTimerd::TIMERSTATE_HASFINISHED);
event->setState(CTimerd::TIMERSTATE_HASFINISHED);
timerManager->m_saveEvents = true;
}
@@ -173,7 +173,7 @@ void* CTimerManager::timerThread(void *arg)
}
timerManager->m_saveEvents = true;
}
if(event->eventState == CTimerd::TIMERSTATE_TERMINATED) // event is terminated, so delete it
{
dprintf("deleting event\n");
@@ -241,16 +241,16 @@ int CTimerManager::addEvent(CTimerEvent* evt, bool save)
}
//------------------------------------------------------------
bool CTimerManager::removeEvent(int eventID)
bool CTimerManager::removeEvent(int peventID)
{
bool res = false;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end()) // if i have a event with this id
if(events.find(peventID)!=events.end()) // if i have a event with this id
{
if( (events[eventID]->eventState == CTimerd::TIMERSTATE_ISRUNNING) && (events[eventID]->stopTime > 0) )
events[eventID]->stopEvent(); // if event is running an has stopTime
if( (events[peventID]->eventState == CTimerd::TIMERSTATE_ISRUNNING) && (events[peventID]->stopTime > 0) )
events[peventID]->stopEvent(); // if event is running an has stopTime
events[eventID]->eventState = CTimerd::TIMERSTATE_TERMINATED; // set the state to terminated
events[peventID]->eventState = CTimerd::TIMERSTATE_TERMINATED; // set the state to terminated
res = true; // so timerthread will do the rest for us
}
else
@@ -259,15 +259,15 @@ bool CTimerManager::removeEvent(int eventID)
return res;
}
//------------------------------------------------------------
bool CTimerManager::stopEvent(int eventID)
bool CTimerManager::stopEvent(int peventID)
{
bool res = false;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end()) // if i have a event with this id
if(events.find(peventID)!=events.end()) // if i have a event with this id
{
if( (events[eventID]->eventState == CTimerd::TIMERSTATE_ISRUNNING) && (events[eventID]->stopTime > 0) )
events[eventID]->stopEvent(); // if event is running an has stopTime
events[eventID]->eventState = CTimerd::TIMERSTATE_HASFINISHED; // set the state to finished
if( (events[peventID]->eventState == CTimerd::TIMERSTATE_ISRUNNING) && (events[peventID]->stopTime > 0) )
events[peventID]->stopEvent(); // if event is running an has stopTime
events[peventID]->eventState = CTimerd::TIMERSTATE_HASFINISHED; // set the state to finished
res = true; // so timerthread will do the rest for us
}
else
@@ -295,13 +295,13 @@ bool CTimerManager::listEvents(CTimerEventMap &Events)
}
//------------------------------------------------------------
CTimerd::CTimerEventTypes* CTimerManager::getEventType(int eventID)
CTimerd::CTimerEventTypes* CTimerManager::getEventType(int peventID)
{
CTimerd::CTimerEventTypes *res = NULL;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end())
if(events.find(peventID)!=events.end())
{
res = &(events[eventID]->eventType);
res = &(events[peventID]->eventType);
}
else
res = NULL;
@@ -310,13 +310,13 @@ CTimerd::CTimerEventTypes* CTimerManager::getEventType(int eventID)
}
//------------------------------------------------------------
int CTimerManager::modifyEvent(int eventID, time_t announceTime, time_t alarmTime, time_t stopTime, uint32_t repeatCount, CTimerd::CTimerEventRepeat evrepeat, CTimerd::responseGetTimer& data)
int CTimerManager::modifyEvent(int peventID, time_t announceTime, time_t alarmTime, time_t stopTime, uint32_t repeatCount, CTimerd::CTimerEventRepeat evrepeat, CTimerd::responseGetTimer& data)
{
int res = 0;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end())
if(events.find(peventID)!=events.end())
{
CTimerEvent *event = events[eventID];
CTimerEvent *event = events[peventID];
event->announceTime = announceTime;
event->alarmTime = alarmTime;
event->stopTime = stopTime;
@@ -329,7 +329,7 @@ int CTimerManager::modifyEvent(int eventID, time_t announceTime, time_t alarmTim
event->repeatCount = repeatCount;
switch (event->eventType)
{
case CTimerd::TIMER_SHUTDOWN:
case CTimerd::TIMER_SHUTDOWN:
case CTimerd::TIMER_NEXTPROGRAM:
case CTimerd::TIMER_ZAPTO:
case CTimerd::TIMER_STANDBY:
@@ -341,15 +341,15 @@ int CTimerManager::modifyEvent(int eventID, time_t announceTime, time_t alarmTim
case CTimerd::TIMER_RECORD:
{
(static_cast<CTimerEvent_Record*>(event))->recordingDir = data.recordingDir;
(static_cast<CTimerEvent_Record*>(event))->getEpgId();
(static_cast<CTimerEvent_Record*>(event))->getEpgId();
break;
}
default:
break;
}
m_saveEvents=true;
res = eventID;
res = peventID;
}
else
res = 0;
@@ -357,14 +357,14 @@ int CTimerManager::modifyEvent(int eventID, time_t announceTime, time_t alarmTim
return res;
}
int CTimerManager::modifyEvent(int eventID, unsigned char apids)
int CTimerManager::modifyEvent(int peventID, unsigned char apids)
{
dprintf("Modify Event %d apid 0x%X\n",eventID,apids);
dprintf("Modify Event %d apid 0x%X\n",peventID,apids);
int res = 0;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end())
if(events.find(peventID)!=events.end())
{
CTimerEvent *event = events[eventID];
CTimerEvent *event = events[peventID];
if(event->eventType == CTimerd::TIMER_RECORD)
{
((CTimerEvent_Record*) (event))->eventInfo.apids = apids;
@@ -375,21 +375,21 @@ int CTimerManager::modifyEvent(int eventID, unsigned char apids)
{
((CTimerEvent_Zapto*) (event))->eventInfo.apids = apids;
m_saveEvents=true;
res = eventID;
res = peventID;
}
}
pthread_mutex_unlock(&tm_eventsMutex);
return res;
}
int CTimerManager::rescheduleEvent(int eventID, time_t announceTime, time_t alarmTime, time_t stopTime)
int CTimerManager::rescheduleEvent(int peventID, time_t announceTime, time_t alarmTime, time_t stopTime)
{
int res = 0;
pthread_mutex_lock(&tm_eventsMutex);
if(events.find(eventID)!=events.end())
if(events.find(peventID)!=events.end())
{
CTimerEvent *event = events[eventID];
CTimerEvent *event = events[peventID];
if(event->announceTime > 0)
event->announceTime += announceTime;
if(event->alarmTime > 0)
@@ -398,7 +398,7 @@ int CTimerManager::rescheduleEvent(int eventID, time_t announceTime, time_t alar
event->stopTime += stopTime;
event->eventState = CTimerd::TIMERSTATE_SCHEDULED;
m_saveEvents=true;
res = eventID;
res = peventID;
}
else
res = 0;
@@ -451,7 +451,7 @@ void CTimerManager::loadEventsFromConfig()
delete event;
}
break;
}
}
case CTimerd::TIMER_NEXTPROGRAM :
{
CTimerEvent_NextProgram *event=
@@ -473,7 +473,7 @@ void CTimerManager::loadEventsFromConfig()
delete event;
}
break;
}
}
case CTimerd::TIMER_ZAPTO :
{
CTimerEvent_Zapto *event=
@@ -495,7 +495,7 @@ void CTimerManager::loadEventsFromConfig()
delete event;
}
break;
}
}
case CTimerd::TIMER_STANDBY :
{
CTimerEvent_Standby *event=
@@ -517,7 +517,7 @@ void CTimerManager::loadEventsFromConfig()
delete event;
}
break;
}
}
case CTimerd::TIMER_RECORD :
{
CTimerEvent_Record *event=
@@ -539,7 +539,7 @@ void CTimerManager::loadEventsFromConfig()
delete event;
}
break;
}
}
case CTimerd::TIMER_SLEEPTIMER :
{
CTimerEvent_Sleeptimer *event=
@@ -633,7 +633,7 @@ void CTimerManager::loadRecordingSafety()
void CTimerManager::saveEventsToConfig()
{
pthread_mutex_lock(&tm_eventsMutex);
// Sperren !!!
CConfigFile config(',');
config.clear();
@@ -653,7 +653,7 @@ void CTimerManager::saveEventsToConfig()
dprintf("now saving config to %s...\n",CONFIGFILE);
config.saveConfig(CONFIGFILE);
dprintf("config saved!\n");
m_saveEvents=false;
m_saveEvents=false;
// Freigeben !!!
pthread_mutex_unlock(&tm_eventsMutex);
@@ -665,7 +665,7 @@ bool CTimerManager::shutdown()
time_t nextAnnounceTime=0;
bool status=false;
dprintf("stopping timermanager thread ...\n");
dprintf("Waiting for timermanager thread to terminate ...\n");
pthread_cancel(thrTimer);
pthread_join(thrTimer,NULL);
@@ -677,7 +677,7 @@ bool CTimerManager::shutdown()
saveEventsToConfig();
dprintf("shutdown: saved config\n");
}
if (pthread_mutex_trylock(&tm_eventsMutex) == EBUSY)
if (pthread_mutex_trylock(&tm_eventsMutex) == EBUSY)
{
dprintf("error: mutex is still LOCKED\n");
return false;
@@ -719,7 +719,7 @@ void CTimerManager::shutdownOnWakeup(int currEventID)
wakeup = 0;
pthread_mutex_lock(&tm_eventsMutex);
CTimerEventMap::iterator pos = events.begin();
for(;pos != events.end();pos++)
{
@@ -761,7 +761,7 @@ void CTimerManager::setRecordingSafety(int pre, int post)
CTimerEvent::CTimerEvent( CTimerd::CTimerEventTypes evtype, time_t announcetime, time_t alarmtime, time_t stoptime, CTimerd::CTimerEventRepeat evrepeat, uint32_t repeatcount)
{
eventRepeat = evrepeat;
eventState = CTimerd::TIMERSTATE_SCHEDULED;
eventState = CTimerd::TIMERSTATE_SCHEDULED;
eventType = evtype;
announceTime = announcetime;
alarmTime = alarmtime;
@@ -772,7 +772,7 @@ CTimerEvent::CTimerEvent( CTimerd::CTimerEventTypes evtype, time_t announcetime,
//------------------------------------------------------------
CTimerEvent::CTimerEvent( CTimerd::CTimerEventTypes evtype, int mon, int day, int hour, int min, CTimerd::CTimerEventRepeat evrepeat, uint32_t repeatcount)
{
{
time_t mtime = time(NULL);
struct tm *tmtime = localtime(&mtime);
@@ -805,7 +805,7 @@ CTimerEvent::CTimerEvent(CTimerd::CTimerEventTypes evtype,CConfigFile *config, i
uint32_t repeatcount = config->getInt32("REPEAT_COUNT_"+id);
dprintf("read REPEAT_COUNT_%s %d\n",id.c_str(),repeatcount);
eventRepeat = evrepeat;
eventState = CTimerd::TIMERSTATE_SCHEDULED;
eventState = CTimerd::TIMERSTATE_SCHEDULED;
eventType = evtype;
announceTime = announcetime;
alarmTime = alarmtime;
@@ -840,16 +840,16 @@ void CTimerEvent::Reschedule()
case CTimerd::TIMERREPEAT_DAILY:
t->tm_mday++;
break;
case CTimerd::TIMERREPEAT_WEEKLY:
case CTimerd::TIMERREPEAT_WEEKLY:
t->tm_mday+=7;
break;
case CTimerd::TIMERREPEAT_BIWEEKLY:
case CTimerd::TIMERREPEAT_BIWEEKLY:
t->tm_mday+=14;
break;
case CTimerd::TIMERREPEAT_FOURWEEKLY:
case CTimerd::TIMERREPEAT_FOURWEEKLY:
t->tm_mday+=28;
break;
case CTimerd::TIMERREPEAT_MONTHLY:
case CTimerd::TIMERREPEAT_MONTHLY:
t->tm_mon++;
break;
case CTimerd::TIMERREPEAT_BYEVENTDESCRIPTION :
@@ -869,10 +869,10 @@ void CTimerEvent::Reschedule()
weekday_arr[4]=((weekdays & 0x8) > 0); //Do
weekday_arr[5]=((weekdays & 0x10) > 0); //Fr
weekday_arr[6]=((weekdays & 0x20) > 0); //Sa
struct tm *t= localtime(&alarmTime);
struct tm *lt= localtime(&alarmTime);
int day;
for(day=1 ; !weekday_arr[(t->tm_wday+day)%7] ; day++){}
t->tm_mday+=day;
for(day=1 ; !weekday_arr[(lt->tm_wday+day)%7] ; day++){}
lt->tm_mday+=day;
}
}
else
@@ -1025,10 +1025,10 @@ void CTimerEvent_Sleeptimer::fireEvent()
//=============================================================
// Standby Event
//=============================================================
CTimerEvent_Standby::CTimerEvent_Standby( time_t announceTime, time_t alarmTime,
bool sb_on,
CTimerEvent_Standby::CTimerEvent_Standby( time_t announceTime, time_t alarmTime,
bool sb_on,
CTimerd::CTimerEventRepeat evrepeat,
uint32_t repeatcount):
uint32_t repeatcount):
CTimerEvent(CTimerd::TIMER_STANDBY, announceTime, alarmTime, (time_t) 0, evrepeat,repeatcount)
{
standby_on = sb_on;
@@ -1064,9 +1064,9 @@ void CTimerEvent_Standby::saveToConfig(CConfigFile *config)
//=============================================================
// Record Event
//=============================================================
CTimerEvent_Record::CTimerEvent_Record(time_t announceTime, time_t alarmTime, time_t stopTime,
CTimerEvent_Record::CTimerEvent_Record(time_t announceTime, time_t alarmTime, time_t stopTime,
t_channel_id channel_id,
event_id_t epgID,
event_id_t epgID,
time_t epg_starttime, unsigned char apids,
CTimerd::CTimerEventRepeat evrepeat,
uint32_t repeatcount, const std::string recDir) :
@@ -1081,7 +1081,7 @@ CTimerEvent_Record::CTimerEvent_Record(time_t announceTime, time_t alarmTime, ti
epgTitle="";
CShortEPGData epgdata;
if (sdc.getEPGidShort(epgID, &epgdata))
epgTitle=epgdata.title;
epgTitle=epgdata.title;
}
//------------------------------------------------------------
CTimerEvent_Record::CTimerEvent_Record(CConfigFile *config, int iId):
@@ -1113,13 +1113,13 @@ void CTimerEvent_Record::fireEvent()
{
CTimerd::RecordingInfo ri=eventInfo;
ri.eventID=eventID;
strcpy(ri.recordingDir, recordingDir.substr(0,sizeof(ri.recordingDir)-1).c_str());
strcpy(ri.epgTitle, epgTitle.substr(0,sizeof(ri.epgTitle)-1).c_str());
strcpy(ri.recordingDir, recordingDir.substr(0,sizeof(ri.recordingDir)-1).c_str());
strcpy(ri.epgTitle, epgTitle.substr(0,sizeof(ri.epgTitle)-1).c_str());
CTimerManager::getInstance()->getEventServer()->sendEvent(CTimerdClient::EVT_RECORD_START,
CEventServer::INITID_TIMERD,
&ri,
sizeof(CTimerd::RecordingInfo));
dprintf("Record Timer fired\n");
dprintf("Record Timer fired\n");
}
//------------------------------------------------------------
void CTimerEvent_Record::announceEvent()
@@ -1127,11 +1127,11 @@ void CTimerEvent_Record::announceEvent()
Refresh();
CTimerd::RecordingInfo ri=eventInfo;
ri.eventID=eventID;
strcpy(ri.recordingDir, recordingDir.substr(0,sizeof(ri.recordingDir)-1).c_str());
strcpy(ri.epgTitle, epgTitle.substr(0,sizeof(ri.epgTitle)-1).c_str());
strcpy(ri.recordingDir, recordingDir.substr(0,sizeof(ri.recordingDir)-1).c_str());
strcpy(ri.epgTitle, epgTitle.substr(0,sizeof(ri.epgTitle)-1).c_str());
CTimerManager::getInstance()->getEventServer()->sendEvent(CTimerdClient::EVT_ANNOUNCE_RECORD, CEventServer::INITID_TIMERD,
&ri,sizeof(CTimerd::RecordingInfo));
dprintf("Record announcement\n");
dprintf("Record announcement\n");
}
//------------------------------------------------------------
void CTimerEvent_Record::stopEvent()
@@ -1145,7 +1145,7 @@ void CTimerEvent_Record::stopEvent()
sizeof(CTimerd::RecordingStopInfo));
// Programmiere shutdown timer, wenn in wakeup state und kein record/zapto timer in 10 min
CTimerManager::getInstance()->shutdownOnWakeup(eventID);
dprintf("Recording stopped\n");
dprintf("Recording stopped\n");
}
//------------------------------------------------------------
void CTimerEvent_Record::saveToConfig(CConfigFile *config)
@@ -1202,7 +1202,7 @@ void CTimerEvent_Record::getEpgId()
{
CShortEPGData epgdata;
if (sdc.getEPGidShort(eventInfo.epgID, &epgdata))
epgTitle=epgdata.title;
epgTitle=epgdata.title;
}
}
//------------------------------------------------------------
@@ -1249,9 +1249,9 @@ void CTimerEvent_Zapto::getEpgId()
//=============================================================
// NextProgram Event
//=============================================================
CTimerEvent_NextProgram::CTimerEvent_NextProgram(time_t announceTime, time_t alarmTime, time_t stopTime,
CTimerEvent_NextProgram::CTimerEvent_NextProgram(time_t announceTime, time_t alarmTime, time_t stopTime,
t_channel_id channel_id,
event_id_t epgID,
event_id_t epgID,
time_t epg_starttime, CTimerd::CTimerEventRepeat evrepeat,
uint32_t repeatcount) :
CTimerEvent(CTimerd::TIMER_NEXTPROGRAM, announceTime, alarmTime, stopTime, evrepeat,repeatcount)
@@ -1329,7 +1329,7 @@ void CTimerEvent_NextProgram::Reschedule()
// Remind Event
//=============================================================
CTimerEvent_Remind::CTimerEvent_Remind(time_t announceTime,
time_t alarmTime,
time_t alarmTime,
const char * const msg,
CTimerd::CTimerEventRepeat evrepeat,
uint32_t repeatcount) :
@@ -1372,7 +1372,7 @@ void CTimerEvent_Remind::saveToConfig(CConfigFile *config)
// ExecPlugin Event
//=============================================================
CTimerEvent_ExecPlugin::CTimerEvent_ExecPlugin(time_t announceTime,
time_t alarmTime,
time_t alarmTime,
const char * const plugin,
CTimerd::CTimerEventRepeat evrepeat,
uint32_t repeatcount) :

38
src/timerd/timermanager.h
View File

@@ -56,7 +56,7 @@ class CTimerEvent
CTimerEvent( CTimerd::CTimerEventTypes evtype, int mon = 0, int day = 0, int hour = 0, int min = 0, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1);
CTimerEvent( CTimerd::CTimerEventTypes evtype, time_t announcetime, time_t alarmtime, time_t stoptime, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1);
CTimerEvent( CTimerd::CTimerEventTypes evtype, CConfigFile *config, int iId);
void setState(CTimerd::CTimerEventStates newstate){previousState = eventState; eventState = newstate;};
static int remain_min(const time_t t) {return (t - time(NULL)) / 60;};
@@ -76,8 +76,8 @@ typedef std::map<int, CTimerEvent*> CTimerEventMap;
class CTimerEvent_Shutdown : public CTimerEvent
{
public:
CTimerEvent_Shutdown( time_t announceTime, time_t alarmTime, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1) :
CTimerEvent(CTimerd::TIMER_SHUTDOWN, announceTime, alarmTime, (time_t) 0, evrepeat, repeatcount ){};
CTimerEvent_Shutdown( time_t lannounceTime, time_t lalarmTime, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1) :
CTimerEvent(CTimerd::TIMER_SHUTDOWN, lannounceTime, lalarmTime, (time_t) 0, evrepeat, repeatcount ){};
CTimerEvent_Shutdown(CConfigFile *config, int iId):
CTimerEvent(CTimerd::TIMER_SHUTDOWN, config, iId){};
virtual void fireEvent();
@@ -87,8 +87,8 @@ class CTimerEvent_Shutdown : public CTimerEvent
class CTimerEvent_Sleeptimer : public CTimerEvent
{
public:
CTimerEvent_Sleeptimer( time_t announceTime, time_t alarmTime, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1) :
CTimerEvent(CTimerd::TIMER_SLEEPTIMER, announceTime, alarmTime, (time_t) 0,evrepeat,repeatcount ){};
CTimerEvent_Sleeptimer( time_t lannounceTime, time_t lalarmTime, CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE, uint32_t repeatcount = 1) :
CTimerEvent(CTimerd::TIMER_SLEEPTIMER, lannounceTime, lalarmTime, (time_t) 0,evrepeat,repeatcount ){};
CTimerEvent_Sleeptimer(CConfigFile *config, int iId):
CTimerEvent(CTimerd::TIMER_SLEEPTIMER, config, iId){};
virtual void fireEvent();
@@ -102,7 +102,7 @@ class CTimerEvent_Standby : public CTimerEvent
bool standby_on;
CTimerEvent_Standby(time_t announceTime,
time_t alarmTime,
time_t alarmTime,
bool sb_on,
CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE,
uint32_t repeatcount = 1);
@@ -117,10 +117,10 @@ class CTimerEvent_Record : public CTimerEvent
CTimerd::EventInfo eventInfo;
std::string recordingDir;
std::string epgTitle;
CTimerEvent_Record(time_t announceTime, time_t alarmTime, time_t stopTime,
CTimerEvent_Record(time_t announceTime, time_t alarmTime, time_t stopTime,
t_channel_id channel_id,
event_id_t epgID = 0,
time_t epg_starttime = 0,
time_t epg_starttime = 0,
unsigned char apids = TIMERD_APIDS_STD,
CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE,
uint32_t repeatcount = 1, const std::string recDir = "");
@@ -139,13 +139,13 @@ class CTimerEvent_Record : public CTimerEvent
class CTimerEvent_Zapto : public CTimerEvent_Record
{
public:
CTimerEvent_Zapto(time_t announceTime, time_t alarmTime,
CTimerEvent_Zapto(time_t lannounceTime, time_t lalarmTime,
t_channel_id channel_id,
event_id_t epgID = 0,
time_t epg_starttime = 0,
time_t epg_starttime = 0,
CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE,
uint32_t repeatcount = 1):
CTimerEvent_Record(announceTime, alarmTime, (time_t) 0, channel_id, epgID, epg_starttime, 0, evrepeat,repeatcount)
CTimerEvent_Record(lannounceTime, lalarmTime, (time_t) 0, channel_id, epgID, epg_starttime, 0, evrepeat,repeatcount)
{eventType = getEventType();};
CTimerEvent_Zapto(CConfigFile *config, int iId):
CTimerEvent_Record(config, iId)
@@ -162,7 +162,7 @@ class CTimerEvent_NextProgram : public CTimerEvent
public:
CTimerd::EventInfo eventInfo;
CTimerEvent_NextProgram(time_t announceTime, time_t alarmTime, time_t stopTime,
CTimerEvent_NextProgram(time_t announceTime, time_t alarmTime, time_t stopTime,
t_channel_id channel_id,
event_id_t epgID = 0,
time_t epg_starttime = 0,
@@ -182,7 +182,7 @@ class CTimerEvent_Remind : public CTimerEvent
char message[REMINDER_MESSAGE_MAXLEN];
CTimerEvent_Remind(time_t announceTime,
time_t alarmTime,
time_t alarmTime,
const char * const msg,
CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE,
uint32_t repeatcount = 1);
@@ -197,7 +197,7 @@ class CTimerEvent_ExecPlugin : public CTimerEvent
char name[EXEC_PLUGIN_NAME_MAXLEN];
CTimerEvent_ExecPlugin(time_t announceTime,
time_t alarmTime,
time_t alarmTime,
const char * const plugin,
CTimerd::CTimerEventRepeat evrepeat = CTimerd::TIMERREPEAT_ONCE,
uint32_t repeatcount = 1);
@@ -220,15 +220,15 @@ private:
int m_extraTimeStart;
int m_extraTimeEnd;
char wakeup;
CTimerManager();
static void* timerThread(void *arg);
CTimerEvent *nextEvent();
public:
static CTimerManager* getInstance();
CEventServer* getEventServer() {return eventServer;};
int addEvent(CTimerEvent*,bool save = true);
bool removeEvent(int eventID);
@@ -245,7 +245,7 @@ public:
bool shutdown();
void shutdownOnWakeup(int currEventId);
void getRecordingSafety(int &pre, int &post){pre=m_extraTimeStart;post=m_extraTimeEnd;}
void setRecordingSafety(int pre, int post);
void setRecordingSafety(int pre, int post);
void loadRecordingSafety();
};