void CControlAPI::SendTimers(CWebserverRequest* request)
{
CTimerd::TimerList timerlist; // List of bouquets
timerlist.clear();
Parent->Timerd->getTimerList(timerlist);
CZapitClient::BouquetChannelList channellist;
channellist.clear();
CTimerd::TimerList::iterator timer = timerlist.begin();
for(; timer != timerlist.end();timer++)
{
// Add Data
char zAddData[20+1]={0};
switch(timer->eventType)
{
case CTimerd::TIMER_NEXTPROGRAM :
case CTimerd::TIMER_ZAPTO :
case CTimerd::TIMER_RECORD :
{
if(channellist.size()==0)
{
Parent->Zapit->getChannels(channellist);
}
CZapitClient::BouquetChannelList::iterator channel = channellist.begin();
for(; channel != channellist.end();channel++)
{
if(channel->channel_id==timer->channel_id)
{
strncpy(zAddData, channel->name, 20);
zAddData[20]=0;
break;
}
}
if(channel == channellist.end())
strcpy(zAddData,"Unknown");
}
break;
case CTimerd::TIMER_STANDBY :
{
sprintf(zAddData,"Standby: %s",(timer->standby_on ? "ON" : "OFF"));
}
break;
default:{}
}
request->printf("%d %d %d %d %d %d %s\n",timer->eventID,(int)timer->eventType,
(int)timer->eventRepeat,(int)timer->announceTime,
(int)timer->alarmTime,(int)timer->stopTime,zAddData);
}
}
int CFollowScreenings::exec(CMenuTarget* /*parent*/, const std::string & actionKey)
{
unsigned long a;
if (1 == sscanf(actionKey.c_str(), "%lu", &a)) {
int ix = 0;
CChannelEventList::iterator e;
for (e = followlist.begin(); e != followlist.end(); e++, ix++)
if ((time_t)a == e->startTime) {
time_t start = e->startTime - (ANNOUNCETIME + 120);
time_t stop = e->startTime + e->duration;
CTimerd::TimerList overlappingTimers = Timer.getOverlappingTimers(start, stop);
CTimerd::TimerList::iterator i;
for (i = overlappingTimers.begin(); i != overlappingTimers.end(); i++)
if (i->eventType == CTimerd::TIMER_RECORD) {
if (channel_id == i->channel_id && e->startTime == i->epg_starttime) {
Timer.removeTimerEvent(i->eventID);
if (!forwarders.empty())
forwarders[ix]->iconName_Info_right = "";
#if 0
else
ShowMsg(LOCALE_TIMER_EVENTREMOVED_TITLE, LOCALE_TIMER_EVENTREMOVED_MSG,
CMessageBox::mbrBack, CMessageBox::mbBack, NEUTRINO_ICON_INFO);
#endif
return menu_return::RETURN_REPAINT;
}
if (!SAME_TRANSPONDER(channel_id, i->channel_id)) {
if (!askUserOnTimerConflict(start, stop, channel_id))
return menu_return::RETURN_REPAINT;
}
}
if (g_Timerd->addRecordTimerEvent(channel_id, e->startTime, e->startTime + e->duration, e->eventID,
e->startTime, e->startTime - (ANNOUNCETIME + 120 ), apids, true, e->startTime - (ANNOUNCETIME + 120) > time(NULL), recDir, true) == -1) {
//FIXME -- no error handling, but this shouldn't happen ...
} else {
if (!forwarders.empty())
forwarders[ix]->iconName_Info_right = NEUTRINO_ICON_REC;
#if 0
else
ShowMsg(LOCALE_TIMER_EVENTRECORD_TITLE, LOCALE_TIMER_EVENTRECORD_MSG,
CMessageBox::mbrBack, CMessageBox::mbBack, NEUTRINO_ICON_INFO);
#endif
return menu_return::RETURN_REPAINT;
}
break; // for
}
return menu_return::RETURN_EXIT_ALL;
}
show();
return menu_return::RETURN_EXIT_ALL;
}
void CFollowScreenings::updateRightIcon(int ix, time_t start, unsigned int duration) {
time_t stop = start + duration;
start -= (ANNOUNCETIME + 120);
CTimerd::TimerList overlappingTimers = Timer.getOverlappingTimers(start, stop);
start += (ANNOUNCETIME + 120);
CTimerd::TimerList::iterator i;
for (i = overlappingTimers.begin(); i != overlappingTimers.end(); i++)
if (i->eventType == CTimerd::TIMER_RECORD) {
if (channel_id == i->channel_id && start == i->epg_starttime) {
forwarders[ix]->iconName_Info_right = NEUTRINO_ICON_REC;
return;
}
if (!SAME_TRANSPONDER(channel_id, i->channel_id)) {
forwarders[ix]->iconName_Info_right = NEUTRINO_ICON_IMPORTANT;
return;
}
}
}
/*
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 CTimerdClient::getTimerList(CTimerd::TimerList &timerlist)
{
CTimerdMsg::generalInteger responseInteger;
CTimerd::responseGetTimer response;
send(CTimerdMsg::CMD_GETTIMERLIST);
timerlist.clear();
if (CBasicClient::receive_data((char* )&responseInteger, sizeof(responseInteger)))
{
while (responseInteger.number-- > 0)
{
if (CBasicClient::receive_data((char*)&response, sizeof(response)))
if (response.eventState != CTimerd::TIMERSTATE_TERMINATED)
timerlist.push_back(response);
};
}
close_connection();
}
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;
}
//-------------------------------------------------------------------------
// Template 1:classname, 2:zAlarmTime, 3: zStopTime, 4:zRep, 5:zRepCouunt
// 6:zType, 7:sAddData, 8:timer->eventID, 9:timer->eventID
//-------------------------------------------------------------------------
std::string CNeutrinoYParser::func_get_timer_list(CyhookHandler *, std::string para)
{
std::string yresult;
CTimerd::TimerList timerlist; // List of bouquets
timerlist.clear();
NeutrinoAPI->Timerd->getTimerList(timerlist);
sort(timerlist.begin(), timerlist.end());
CZapitClient::BouquetChannelList channellist_tv;
CZapitClient::BouquetChannelList channellist_radio;
channellist_tv.clear();
channellist_radio.clear();
int i = 1;
char classname= 'a';
CTimerd::TimerList::iterator timer = timerlist.begin();
for(; timer != timerlist.end();++timer)
{
classname = (i++&1)?'a':'b';
// build alarm/stoptime
char zAlarmTime[25] = {0};
struct tm *alarmTime = localtime(&(timer->alarmTime));
strftime(zAlarmTime,20,"%d.%m. %H:%M",alarmTime);
char zAnnounceTime[25] = {0};
struct tm *announceTime = localtime(&(timer->announceTime));
strftime(zAnnounceTime,20,"%d.%m. %H:%M",announceTime);
char zStopTime[25] = {0};
if(timer->stopTime > 0)
{
struct tm *stopTime = localtime(&(timer->stopTime));
strftime(zStopTime,20,"%d.%m. %H:%M",stopTime);
}
// repeat
std::string zRep = NeutrinoAPI->timerEventRepeat2Str(timer->eventRepeat);
std::string zRepCount;
if (timer->eventRepeat == CTimerd::TIMERREPEAT_ONCE)
zRepCount = "-";
else
zRepCount = (timer->repeatCount == 0) ? "∞" : string_printf("%dx",timer->repeatCount);
// timer type
std::string zType = NeutrinoAPI->timerEventType2Str(timer->eventType);
// Add Data
std::string sAddData="";
switch(timer->eventType)
{
//case CTimerd::TIMER_NEXTPROGRAM :
case CTimerd::TIMER_ZAPTO :
case CTimerd::TIMER_RECORD :
{
sAddData = NeutrinoAPI->GetServiceName(timer->channel_id);
if (sAddData.empty())
sAddData = CServiceManager::getInstance()->IsChannelTVChannel(timer->channel_id) ? "Unknown TV-Channel" : "Unknown Radio-Channel";
if( timer->apids != TIMERD_APIDS_CONF)
{
std::string separator = "";
sAddData += '(';
if( timer->apids & TIMERD_APIDS_STD )
{
sAddData += "STD";
separator = "/";
}
if( timer->apids & TIMERD_APIDS_ALT )
{
sAddData += separator;
sAddData += "ALT";
separator = "/";
}
if( timer->apids & TIMERD_APIDS_AC3 )
{
sAddData += separator;
sAddData += "AC3";
separator = "/";
}
sAddData += ')';
}
if(timer->epgID!=0)
{
CEPGData epgdata;
if (CEitManager::getInstance()->getEPGid(timer->epgID, timer->epg_starttime, &epgdata))
sAddData+="<br/>" + epgdata.title;
else
sAddData+=std::string("<br/>")+timer->epgTitle;
}
else
sAddData+=std::string("<br/>")+timer->epgTitle;
}
break;
case CTimerd::TIMER_STANDBY :
{
sAddData = "Standby: ";
if(timer->standby_on)
sAddData+= "An";
else
sAddData+="Aus";
}
break;
case CTimerd::TIMER_REMIND :
sAddData = std::string(timer->message).substr(0,20);
break;
case CTimerd::TIMER_EXEC_PLUGIN :
sAddData = std::string(timer->pluginName);
break;
default:{}
}
yresult += string_printf(para.c_str(), classname, zAlarmTime, zStopTime, zRep.c_str(), zRepCount.c_str(),
zType.c_str(), sAddData.c_str(),timer->eventID,timer->eventID);
}
//classname = (i++&1)?'a':'b';
return yresult;
}
//-------------------------------------------------------------------------
int CTimerdClient::addTimerEvent( CTimerd::CTimerEventTypes evType, void* data, time_t announcetime, time_t alarmtime,time_t stoptime,
CTimerd::CTimerEventRepeat evrepeat, uint32_t repeatcount,bool forceadd)
{
if(checkDouble(evType, data, announcetime, alarmtime, stoptime, evrepeat, repeatcount))//check if timer is add double
return -1;
if (!forceadd)
{
//printf("[CTimerdClient] checking for overlapping timers\n");
CTimerd::TimerList overlappingTimer;
overlappingTimer = getOverlappingTimers(alarmtime, stoptime);
if (!overlappingTimer.empty())
{
// timerd starts eventID at 0 so we can return -1
return -1;
}
}
bool adzaptimer = false;
if(evType == CTimerd::TIMER_ADZAP){
evType = CTimerd::TIMER_ZAPTO;
adzaptimer = true;
}
CTimerd::TransferEventInfo tei;
CTimerd::TransferRecordingInfo tri;
CTimerdMsg::commandAddTimer msgAddTimer;
VALGRIND_PARANOIA(tei);
VALGRIND_PARANOIA(tri);
VALGRIND_PARANOIA(msgAddTimer);
msgAddTimer.alarmTime = alarmtime;
msgAddTimer.announceTime = announcetime;
msgAddTimer.stopTime = stoptime;
msgAddTimer.eventType = evType;
msgAddTimer.eventRepeat = evrepeat;
msgAddTimer.repeatCount = repeatcount;
int length;
if( evType == CTimerd::TIMER_SHUTDOWN || evType == CTimerd::TIMER_SLEEPTIMER )
{
length = 0;
}
/* else if(evType == CTimerd::TIMER_NEXTPROGRAM || evType == CTimerd::TIMER_ZAPTO || */
else if (evType == CTimerd::TIMER_ZAPTO ||
evType == CTimerd::TIMER_IMMEDIATE_RECORD ||
evType == CTimerd::TIMER_ADZAP)
{
CTimerd::EventInfo *ei=static_cast<CTimerd::EventInfo*>(data);
tei.apids = ei->apids;
tei.channel_id = ei->channel_id;
tei.epg_starttime = ei->epg_starttime;
tei.epgID = ei->epgID;
tei.recordingSafety = ei->recordingSafety;
length = sizeof( CTimerd::TransferEventInfo);
data = &tei;
}
else if(evType == CTimerd::TIMER_RECORD)
{
CTimerd::RecordingInfo *ri=static_cast<CTimerd::RecordingInfo*>(data);
tri.apids = ri->apids;
tri.channel_id = ri->channel_id;
tri.epg_starttime = ri->epg_starttime;
tri.epgID = ri->epgID;
tri.recordingSafety = ri->recordingSafety;
strncpy(tri.recordingDir, ri->recordingDir, RECORD_DIR_MAXLEN-1);
length = sizeof( CTimerd::TransferRecordingInfo);
data = &tri;
}
else if(evType == CTimerd::TIMER_STANDBY)
{
length = sizeof(CTimerdMsg::commandSetStandby);
}
else if(evType == CTimerd::TIMER_REMIND)
{
length = sizeof(CTimerdMsg::commandRemind);
}
else if(evType == CTimerd::TIMER_EXEC_PLUGIN)
{
length = sizeof(CTimerdMsg::commandExecPlugin);
}
else
{
length = 0;
}
send(CTimerdMsg::CMD_ADDTIMER, (char*)&msgAddTimer, sizeof(msgAddTimer));
if((data != NULL) && (length > 0))
send_data((char*)data, length);
CTimerdMsg::responseAddTimer response;
receive_data((char*)&response, sizeof(response));
close_connection();
if(adzaptimer){
adzap_eventID = response.eventID;//set adzap flag
}
return( response.eventID);
}
