CTimerd::TimerList CTimerdClient::getOverlappingTimers(time_t& startTime, time_t& stopTime)
{
CTimerd::TimerList timerlist;
CTimerd::TimerList overlapping;
int timerPre;
int timerPost;
getTimerList(timerlist);
getRecordingSafety(timerPre,timerPost);
for (CTimerd::TimerList::iterator it = timerlist.begin();
it != timerlist.end();++it)
{
if(it->stopTime != 0 && stopTime != 0)
{
// Check if both timers have start and end. In this case do not show conflict, if endtime is the same than the starttime of the following timer
if ((stopTime+timerPost > it->alarmTime) && (startTime-timerPre < it->stopTime))
{
overlapping.push_back(*it);
}
}
else
{
if (!((stopTime < it->announceTime) || (startTime > it->stopTime)))
{
overlapping.push_back(*it);
}
}
}
return overlapping;
}
/*
int CTimerdClient::addTimerEvent( CTimerEventTypes evType, void* data , int min, int hour, int day, int month, CTimerd::CTimerEventRepeat evrepeat)
{
time_t actTime_t;
time(&actTime_t);
struct tm* actTime = localtime(&actTime_t);
actTime->tm_min = min;
actTime->tm_hour = hour;
if (day > 0)
actTime->tm_mday = day;
if (month > 0)
actTime->tm_mon = month -1;
addTimerEvent(evType,true,data,0,mktime(actTime),0);
}
*/
bool CTimerdClient::checkDouble(CTimerd::CTimerEventTypes evType, void* data, time_t announcetime, time_t alarmtime,time_t stoptime,
CTimerd::CTimerEventRepeat evrepeat, uint32_t repeatcount)
{
if (evType != CTimerd::TIMER_RECORD && evType != CTimerd::TIMER_ZAPTO)
return false;//skip check not zap and record timer
CTimerd::TimerList timerlist;
getTimerList(timerlist);
for (CTimerd::TimerList::iterator it = timerlist.begin(); it != timerlist.end();++it)
{
if ( (it->eventType == CTimerd::TIMER_RECORD || it->eventType == CTimerd::TIMER_ZAPTO ) &&
(it->alarmTime == alarmtime && it->announceTime == announcetime && it->stopTime == stoptime && it->eventRepeat == evrepeat && it->repeatCount == repeatcount ) )
{
if( it->eventType == CTimerd::TIMER_ZAPTO )
{
CTimerd::EventInfo *ei=static_cast<CTimerd::EventInfo*>(data);
if( ei->channel_id == it->channel_id )
{
if(( ei->epgID != 0 && ei->epgID != it->epgID ) || ( ei->epg_starttime != 0 && it->epg_starttime != ei->epg_starttime) )
{
return false;//not double
}
return true;
}
}
else if(it->eventType == CTimerd::TIMER_RECORD)
{
CTimerd::RecordingInfo *ri=static_cast<CTimerd::RecordingInfo*>(data);
if(ri->channel_id == it->channel_id && ri->apids == it->apids && !strncmp(ri->recordingDir, it->recordingDir, RECORD_DIR_MAXLEN-1) )
{
if( ( ri->epgID != 0 && ri->epgID != it->epgID ) || ( ri->epg_starttime != 0 && it->epg_starttime != ri->epg_starttime) )
{
return false;//not double
}
return true;
}
}
}
}
return false;//not double
}
void deviceTimerHandleRawData(char commandHeader, InputStream* inputStream, OutputStream* outputStream) {
if (commandHeader == COMMAND_TIMER_LIST) {
printTimerList(getInfoOutputStreamLogger(), getTimerList());
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_LIST);
}
else if (commandHeader == COMMAND_TIMER_COUNT) {
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_COUNT);
unsigned timerCount = getTimerCount();
appendHex2(outputStream, timerCount);
}
else if (commandHeader == COMMAND_TIMER_READ) {
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_READ);
unsigned char timerIndex = readHex2(inputStream);
Timer* timer = getTimerByIndex(timerIndex);
appendHex2(outputStream, timerIndex);
appendSeparator(outputStream);
appendHex2(outputStream, timer->timerCode);
appendSeparator(outputStream);
appendHex4(outputStream, timer->timeDiviser);
appendSeparator(outputStream);
appendHex4(outputStream, timer->timeInternalCounter);
appendSeparator(outputStream);
appendHex6(outputStream, timer->time);
appendSeparator(outputStream);
appendHex6(outputStream, timer->markTime);
appendSeparator(outputStream);
appendBool(outputStream, timer->enabled);
}
// Enable / Tisable
else if (commandHeader == COMMAND_TIMER_ENABLE_DISABLE) {
unsigned char timerIndex = readHex2(inputStream);
Timer* timer = getTimerByIndex(timerIndex);
checkIsSeparator(inputStream);
unsigned enableAsChar = readHex(inputStream);
bool enabled = enableAsChar != 0;
timer->enabled = enabled;
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_ENABLE_DISABLE);
}
// Mark
else if (commandHeader == COMMAND_TIMER_MARK) {
unsigned char timerIndex = readHex2(inputStream);
Timer* timer = getTimerByIndex(timerIndex);
unsigned long time = markTimer(timer);
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_MARK);
appendHex6(outputStream, time);
}
else if (commandHeader == COMMAND_TIMER_TIME_SINCE_LAST_MARK) {
unsigned char timerIndex = readHex2(inputStream);
Timer* timer = getTimerByIndex(timerIndex);
unsigned long value = getTimeSinceLastMark(timer);
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_TIME_SINCE_LAST_MARK);
appendHex6(outputStream, value);
}
else if (commandHeader == COMMAND_TIMER_TIMEOUT) {
unsigned char timerIndex = readHex2(inputStream);
checkIsSeparator(inputStream);
unsigned long timeToCheck = (unsigned long) readHex6(inputStream);
Timer* timer = getTimerByIndex(timerIndex);
bool value = timeout(timer, timeToCheck);
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_TIMEOUT);
appendHex2(outputStream, timerIndex);
appendSeparator(outputStream);
appendBool(outputStream, value);
}
// Demo
else if (commandHeader == COMMAND_TIMER_DEMO) {
Timer* timer = getTimerByCode(DEMO_TIMER_INDEX);
if (timer == NULL) {
timer = addTimerDemo();
}
// Timer could be null when adding the timerDemo because of limit, we don't want any crash !
if (timer != NULL) {
unsigned enableAsChar = readHex(inputStream);
bool enabled = enableAsChar != 0;
timer->enabled = enabled;
}
ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_DEMO);
}
}
