//------------------------------------------------------------
bool CTimerManager::shutdown()
{
timerd_debug = 1; //FIXME
time_t nextAnnounceTime=0;
bool status=false;
timer_is_rec = false;
dprintf("stopping timermanager thread ...\n");
dprintf("Waiting for timermanager thread to terminate ...\n");
pthread_cancel(thrTimer);
pthread_join(thrTimer,NULL);
dprintf("Timermanager thread terminated\n");
if(m_saveEvents)
{
dprintf("shutdown: saving config\n");
saveEventsToConfig();
dprintf("shutdown: saved config\n");
}
setWakeupTime();
if (pthread_mutex_trylock(&tm_eventsMutex) == EBUSY)
{
dprintf("error: mutex is still LOCKED\n");
return false;
}
CTimerEventMap::iterator pos = events.begin();
for(;pos != events.end();++pos)
{
CTimerEvent *event = pos->second;
dprintf("shutdown: timer type %d state %d announceTime: %ld\n", event->eventType, event->eventState, event->announceTime);
if((event->eventType == CTimerd::TIMER_RECORD ||
event->eventType == CTimerd::TIMER_ZAPTO ) &&
event->eventState < CTimerd::TIMERSTATE_ISRUNNING)
{
// Wir wachen nur für Records und Zaptos wieder auf
if(event->announceTime < nextAnnounceTime || nextAnnounceTime==0)
{
nextAnnounceTime=event->announceTime;
dprintf("shutdown: nextAnnounceTime %ld\n", nextAnnounceTime);
if ( event->eventType == CTimerd::TIMER_RECORD )
timer_is_rec = true;
else
timer_is_rec = false;
}
}
}
timer_minutes = 0;
if(nextAnnounceTime != 0)
{
timer_minutes = (nextAnnounceTime - 3*60)/60;
}
dprintf("shutdown: timeset: %d timer_minutes %ld\n", timeset, timer_minutes);
pthread_mutex_unlock(&tm_eventsMutex);
return status;
}
//------------------------------------------------------------
int CTimerManager::addEvent(CTimerEvent* evt, bool save)
{
eventID++; // increase unique event id
evt->eventID = eventID;
events[eventID] = evt; // insert into events
if(save)
{
saveEventsToConfig();
}
return eventID; // return unique id
}
int CTimerManager::modifyEvent(int eventID, uint apid)
{
dprintf("Modify Event %d apid %u\n",eventID,apid);
if(events.find(eventID)!=events.end())
{
CTimerEvent *event = events[eventID];
if(event->eventType == CTimerd::TIMER_RECORD)
{
((CTimerEvent_Record*) (event))->eventInfo.apid = apid;
saveEventsToConfig();
return eventID;
}
}
return 0;
}
int CTimerManager::modifyEvent(int eventID, time_t announceTime, time_t alarmTime, time_t stopTime, CTimerd::CTimerEventRepeat evrepeat)
{
if(events.find(eventID)!=events.end())
{
CTimerEvent *event = events[eventID];
event->announceTime = announceTime;
event->alarmTime = alarmTime;
event->stopTime = stopTime;
event->eventState = CTimerd::TIMERSTATE_SCHEDULED;
event->eventRepeat = evrepeat;
saveEventsToConfig();
return eventID;
}
else
return 0;
}
int CTimerManager::rescheduleEvent(int eventID, time_t announceTime, time_t alarmTime, time_t stopTime)
{
if(events.find(eventID)!=events.end())
{
CTimerEvent *event = events[eventID];
if(event->announceTime > 0)
event->announceTime += announceTime;
if(event->alarmTime > 0)
event->alarmTime += alarmTime;
if(event->stopTime > 0)
event->stopTime += stopTime;
event->eventState = CTimerd::TIMERSTATE_SCHEDULED;
saveEventsToConfig();
return eventID;
}
else
return 0;
}
// ---------------------------------------------------------------------------------
void CTimerManager::loadEventsFromConfig()
{
CConfigFile config(',');
if(!config.loadConfig(CONFIGFILE))
{
/* set defaults if no configuration file exists */
dprintf("%s not found\n", CONFIGFILE);
}
else
{
std::vector<int> savedIDs;
savedIDs = config.getInt32Vector ("IDS");
dprintf("%d timer(s) in config\n", (int)savedIDs.size());
for(unsigned int i=0; i < savedIDs.size(); i++)
{
std::stringstream ostr;
ostr << savedIDs[i];
std::string id=ostr.str();
CTimerd::CTimerEventTypes type=(CTimerd::CTimerEventTypes)config.getInt32 ("EVENT_TYPE_"+id,0);
dprintf("loading timer %d, id %s, EVENT_TYPE %d\n",i,id.c_str(),type);
time_t now = time(NULL);
switch(type)
{
case CTimerd::TIMER_SHUTDOWN :
{
CTimerEvent_Shutdown *event=
new CTimerEvent_Shutdown(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("shutdown timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_NEXTPROGRAM :
{
CTimerEvent_NextProgram *event=
new CTimerEvent_NextProgram(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("next program timer (%d) too old %d/%d\n",i,
(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_ZAPTO :
{
CTimerEvent_Zapto *event=
new CTimerEvent_Zapto(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("zapto timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_STANDBY :
{
CTimerEvent_Standby *event=
new CTimerEvent_Standby(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("standby timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_RECORD :
{
CTimerEvent_Record *event=
new CTimerEvent_Record(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("record timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_SLEEPTIMER :
{
CTimerEvent_Sleeptimer *event=
new CTimerEvent_Sleeptimer(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("sleep timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_REMIND :
{
CTimerEvent_Remind *event=
new CTimerEvent_Remind(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("remind timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
case CTimerd::TIMER_EXEC_PLUGIN :
{
CTimerEvent_ExecPlugin *event=
new CTimerEvent_ExecPlugin(&config, savedIDs[i]);
if((event->alarmTime >= now) || (event->stopTime > now))
{
addEvent(event,false);
}
else if(event->eventRepeat != CTimerd::TIMERREPEAT_ONCE)
{
// old periodic timers need to be rescheduled
event->eventState = CTimerd::TIMERSTATE_HASFINISHED;
addEvent(event,false);
}
else
{
dprintf("exec plugin timer (%d) too old %d/%d\n",
i,(int)now,(int) event->alarmTime);
delete event;
}
break;
}
default:
printf("Unknown timer on load %d\n",type);
}
}
}
saveEventsToConfig();
}
