source: titan/titan/rectimer.h @ 31648

Last change on this file since 31648 was 31648, checked in by obi, 9 years ago

fix

File size: 41.2 KB
Line 
1#ifndef RECTIMER_H
2#define RECTIMER_H
3
4void debugrectimer()
5{
6        struct rectimer* node = rectimer;
7
8        while(node != NULL)
9        {
10                printf("--------------------------------\n");
11                printf("name: %s\n", node->name);
12                printf("start: %lu end: %lu\n", node->begin, node->end);
13                printf("currently time: %ld\n", time(NULL));
14                printf("channellist: %s\n", node->channellist);
15                printf("serviceid: %d transponderid: %llu\n", node->serviceid, node->transponderid);
16                printf("--------------------------------\n");
17                node = node->next;
18        }
19}
20
21void sortrectimer()
22{
23        struct rectimer *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
24        struct rectimer *nodetmp = NULL, *node = rectimer;
25
26        if(node != NULL)
27        {
28                while (noded != node->next)
29                {
30                        nodec = node;
31                        nodea = node;
32                        nodeb = nodea->next;
33
34                        while (nodea != noded)
35                        {
36                                if (nodea->begin >= nodeb->begin)
37                                {
38                                        if (nodea == node)
39                                        {
40                                                nodetmp = nodeb->next;
41                                                nodeb->next = nodea;
42                                                nodea->next = nodetmp;
43                                                node = nodeb;
44                                                nodec = nodeb;
45                                        }
46                                        else
47                                        {
48                                                nodetmp = nodeb->next;
49                                                nodeb->next = nodea;
50                                                nodea->next = nodetmp;
51                                                nodec->next = nodeb;
52                                                nodec = nodeb;
53                                        }
54                                }
55                                else
56                                {
57                                        nodec = nodea;
58                                        nodea = nodea->next;
59                                }
60                                nodeb = nodea->next;
61                                if (nodeb == noded)
62                                        noded = nodea;
63                        }
64                }
65        }
66
67        struct rectimer* prev = NULL;
68        nodetmp = node;
69        while(nodetmp != NULL)
70        {
71                nodetmp->prev = prev;
72                prev = nodetmp;
73
74                nodetmp = nodetmp->next;
75        }
76
77        rectimer = node;
78}
79
80int checkrectimerconflict(struct rectimer* recnode)
81{
82        struct dvbdev* dvbnode = dvbdev;
83        struct transponder* tpnode = NULL;
84        struct rectimer* node = rectimer;
85
86        if(recnode == NULL) return 0;
87
88        while(dvbnode != NULL)
89        {
90                if(dvbnode->type == FRONTENDDEV)
91                {
92                        adddvbdev(ostrcat(dvbnode->dev, NULL, 0, 0), dvbnode->adapter, dvbnode->devnr, dvbnode->fd, FRONTENDDEV, dvbnode->feinfo, NULL, dvbnode->fehyprid, 1);
93                }
94                dvbnode = dvbnode->next;
95        }
96        dvbnode = NULL;
97
98        if(dvbdevsim == NULL) return 0;
99
100        tpnode = gettransponder(recnode->transponderid);
101        dvbnode = fegetfree(tpnode, 3, dvbdevsim);
102        if(dvbnode != NULL)
103                dvbnode->felock = 1;
104
105        while(node != NULL)
106        {
107                if(recnode != node && node->status < 2)
108                {
109                        if((recnode->begin >= node->begin && recnode->begin < node->end) || (recnode->end >= node->begin && recnode->end < node->end))
110                        {
111                                tpnode = gettransponder(node->transponderid);
112                                dvbnode = fegetfree(tpnode, 3, dvbdevsim);
113                                if(dvbnode == NULL)
114                                {
115                                        freedvbdev(1);
116                                        dvbdevsim = NULL;
117                                        return 2;
118                                }
119                                else
120                                        dvbnode->felock = 1;
121                        }
122                }
123                node = node->next;
124        }
125
126        freedvbdev(1);
127        dvbdevsim = NULL;
128        return 0;
129}
130
131int checkrectimeradd(struct rectimer* recnode, char** ret)
132{
133        if(recnode == NULL)
134        {
135                *ret = _("undefined error");
136                return 1;
137        }
138        if(recnode->begin == 0 || recnode->end == 0)
139        {
140                *ret = _("Timer starttime or endtime not ok");
141                return 1;
142        }
143        if(recnode->end <= time(NULL))
144        {
145                *ret = _("Timer endtime shorter than aktual time");
146                return 1;
147        }
148        if(recnode->end <= recnode->begin)
149        {
150                *ret = _("Timer endtime shorter than start time");
151                return 1;
152        }
153        if(recnode->serviceid < 1)
154        {
155                *ret = _("Timer service ID not ok");
156                return 1;
157        }
158        if(recnode->transponderid < 1)
159        {
160                *ret = _("Timer transponder ID not ok");
161                return 1;
162        }
163
164        if(checkrectimerconflict(recnode) != 0)
165        {
166                *ret = _("Timer conflicts with other timer\nWould you add the timer?");
167                return 2;
168        }
169
170        return 0;
171}
172
173void recrepeatecalc(struct rectimer* node)
174{
175        time_t daysec = 24 * 60 * 60;
176        struct tm* loctime = NULL;
177        int rectimerday = -1, rep = 0, i = 0, daylight = 0;
178
179        if(node->repeate == 0) return;
180        status.writerectimer = 1;
181
182        //get rectimer start day
183        loctime = olocaltime(&node->begin);
184        if(loctime != NULL)
185        {
186                rectimerday = loctime->tm_wday - 1;
187                daylight = loctime->tm_isdst;
188        }
189        free(loctime); loctime = NULL;
190        if(rectimerday == -1) rectimerday = 6;
191
192        rep = (node->repeate & 0xff) | ((node->repeate  & 0xff) << 7);
193
194        for(i = 0; i < 7; i++)
195        {
196                node->begin = node->begin + daysec;
197                node->end = node->end + daysec;
198                rectimerday++;
199                if(rectimerday > 6) rectimerday = 0;
200                if(checkbit(rep, rectimerday) == 1)
201                        break;
202        }
203
204        //check if begin > akttime
205        while(node->begin < time(NULL))
206        {
207                for(i = 0; i < 7; i++)
208                {
209                        node->begin = node->begin + daysec;
210                        node->end = node->end + daysec;
211                        rectimerday++;
212                        if(rectimerday > 6) rectimerday = 0;
213                        if(checkbit(rep, rectimerday) == 1)
214                                break;
215                }
216        }
217
218        //calc daylight
219        loctime = olocaltime(&node->begin);
220        if(loctime != NULL)
221        {
222                if(loctime->tm_isdst > daylight)
223                {
224                        node->begin = node->begin - 3600;
225                        node->end = node->end - 3600;
226                }
227                else if(loctime->tm_isdst < daylight)
228                {
229                        node->begin = node->begin + 3600;
230                        node->end = node->end + 3600;
231                }
232        }
233}
234
235int checkrectimertime(struct rectimer* node)
236{
237        //don't load old timers
238        if(time(NULL) - node->end > 604800 && (node->status == 2 || node->status == 3 || node->status == 5))
239                return 1;
240
241        if(time(NULL) > node->end && node->repeate == 0 && node->status == 0)
242                return 1;
243
244        //recalc old repeat timer
245        if(time(NULL) > node->end && node->repeate != 0 && node->status == 0)
246                recrepeatecalc(node);
247
248        return 0;
249}
250
251void copyrectimer(struct rectimer* src, struct rectimer* dst)
252{
253        dst->timestamp = ostrcat(src->timestamp, NULL, 0, 0);
254        dst->name = ostrcat(src->name, NULL, 0, 0);
255        dst->begin = src->begin;
256        dst->end = src->end;
257        dst->repeate = src->repeate;
258        dst->afterevent = src->afterevent;
259        dst->disabled = src->disabled;
260        dst->justplay = src->justplay;
261        dst->recpath = ostrcat(src->recpath, NULL, 0, 0);
262        dst->servicetype = src->servicetype;
263        dst->channellist = ostrcat(src->channellist, NULL, 0, 0);
264        dst->serviceid = src->serviceid;
265        dst->transponderid = src->transponderid;
266}
267
268struct rectimer* addrectimernode(char* line, struct rectimer* last)
269{
270        char *ret = NULL;
271        struct rectimer *newnode = NULL, *prev = NULL, *node = rectimer;
272       
273        newnode = (struct rectimer*)calloc(1, sizeof(struct rectimer));
274        if(newnode == NULL)
275        {
276                err("no memory");
277                return NULL;
278        }
279
280        status.writerectimer = 1;
281        newnode->timestamp = NULL;
282
283        if(line != NULL)
284        {
285                ret = getxmlentry(line, " begin=");
286                if(ret != NULL)
287                {
288                        newnode->begin = atol(ret);
289                        free(ret);
290                }
291                ret = getxmlentry(line, " end=");
292                if(ret != NULL)
293                {
294                        newnode->end = atol(ret);
295                        free(ret);
296                }
297                ret = getxmlentry(line, " repeated=");
298                if(ret != NULL)
299                {
300                        newnode->repeate = atoi(ret);
301                        free(ret);
302                }
303                ret = getxmlentry(line, " afterevent=");
304                if(ret != NULL)
305                {
306                        newnode->afterevent = atoi(ret);
307                        free(ret);
308                }
309                ret = getxmlentry(line, " pincode=");
310                if(ret != NULL)
311                        newnode->pincode = ret;
312                ret = getxmlentry(line, " disabled=");
313                if(ret != NULL)
314                {
315                        newnode->disabled = atoi(ret);
316                        free(ret);
317                }
318                ret = getxmlentry(line, " justplay=");
319                if(ret != NULL)
320                {
321                        newnode->justplay = atoi(ret);
322                        free(ret);
323                }
324                ret = getxmlentry(line, " serviceid=");
325                if(ret != NULL)
326                {
327                        newnode->serviceid = atoi(ret);
328                        free(ret);
329                }
330                ret = getxmlentry(line, " transponderid=");
331                if(ret != NULL)
332                {
333                        newnode->transponderid = strtoull(ret, NULL, 10);
334                        free(ret);
335                }
336                ret = getxmlentry(line, " status=");
337                if(ret != NULL)
338                {
339                        newnode->status = atol(ret);
340                        if(newnode->status == 1) newnode->status = 0;
341                        free(ret);
342                }
343                ret = getxmlentry(line, " timestamp=");
344                if(ret != NULL)
345                {
346                        newnode->timestamp = ret;
347                }
348                ret = getxmlentry(line, " name=");
349                if(ret != NULL)
350                        newnode->name = ret;
351                ret = getxmlentry(line, " recpath=");
352                if(ret != NULL)
353                        newnode->recpath = ret;
354                ret = getxmlentry(line, " channellist=");
355                if(ret != NULL)
356                        newnode->channellist = ret;
357                ret = getxmlentry(line, " errstr=");
358                if(ret != NULL)
359                        newnode->errstr = ret;
360
361                if(checkrectimertime(newnode) == 1)
362                {
363                        free(newnode);
364                        return NULL;
365                }
366        }
367        else
368        {
369                newnode->disabled = 1;
370                newnode->afterevent = getconfigint("def_rectimer_after", NULL);
371        }
372       
373        if(newnode->timestamp == NULL)
374                newnode->timestamp = gettimestamp();
375       
376        if(last == NULL)
377        {
378                while(node != NULL && newnode->begin >= node->begin)
379                {
380                        prev = node;
381                        node = node->next;
382                }
383        }
384        else
385        {
386                prev = last;
387                node = last->next;
388        }
389
390        if(prev == NULL)
391                rectimer = newnode;
392        else
393        {
394                prev->next = newnode;
395                newnode->prev = prev;
396        }
397        newnode->next = node;
398        if(node != NULL) node->prev = newnode;
399
400        return newnode;
401}
402
403struct rectimer* getrectimerbytimediff(time_t timediff)
404{
405        struct rectimer* node = rectimer;       
406        time_t akttime = time(NULL);
407
408        while(node != NULL)
409        {
410                if(node->begin > akttime && node->begin <= akttime + timediff)
411                        return node;
412
413                node = node->next;
414        }
415
416        return NULL;
417}
418
419struct rectimer* getrectimerbytimestamp(char* timestamp)
420{
421        struct rectimer* node = rectimer;       
422
423        while(node != NULL)
424        {
425                if(ostrcmp(node->timestamp, timestamp) == 0)
426                        return node;
427
428                node = node->next;
429        }
430
431        return NULL;
432}
433
434struct rectimer* getrectimerbyservice(struct service* servicenode)
435{
436        struct rectimer* node = rectimer;       
437
438        while(node != NULL)
439        {
440                if(node->servicenode == servicenode)
441                        return node;
442
443                node = node->next;
444        }
445
446        return NULL;
447}
448
449void checkrectimer(struct stimerthread* self)
450{
451        int ret = 0;
452        struct rectimer* node = NULL, *newnode = NULL;
453        struct channel* chnode = NULL;
454        time_t t = 0, begin = 0, end = 0;
455printf("checkrectimer start\n");
456
457        if(self == NULL) return;
458
459        //wait for right time
460        while(self->aktion != STOP && time(NULL) < 1072224000) // 01.01.2004
461                usleep(1 * 1000000);
462       
463        //on first start read rectimer and set cec
464        if(self->delay == 1000)
465        {
466                ret = 5;
467                while(self->aktion != STOP && ret != 0)
468                {
469                        usleep(1 * 1000000);
470                        ret = ret - 1;
471                }
472                ret = 0;
473                readrectimer(getconfig("rectimerfile", NULL));
474                checkboxstart();
475        }
476               
477        //wait for start all programs
478        ret = 30;
479        while(self->aktion != STOP && ret != 0)
480        {
481                usleep(1 * 1000000);
482                ret = ret - 1;
483        }
484        ret = 0;
485       
486        //on first start read rectimer
487        if(self->delay == 1000)
488        {
489                self->delay = 10000;
490                //readrectimer(getconfig("rectimerfile", NULL));
491                epgscancreatetimer();
492                //checkboxstart();
493        }
494
495        m_lock(&status.rectimermutex, 1);
496        t = time(NULL);
497        node = rectimer;
498       
499        while(node != NULL)
500        {
501                if(node->disabled != 0)
502                {
503                        node = node->next;
504                        continue;
505                }
506               
507                if(node->justplay == 1)
508                {
509                        begin = node->begin;
510                        end = node->end + 180;
511                }
512                else
513                {
514                        begin = node->begin;
515                        end = node->end;
516                }
517
518                if(t >= begin && t < end && node->disabled == 0 && node->status == 0)
519                {
520                        if(node->repeate != 0)
521                        {
522                                //copy repeate timer
523                                newnode = addrectimernode(NULL, NULL);
524                                if(newnode != NULL)
525                                {
526                                        copyrectimer(node, newnode);
527                                        recrepeatecalc(newnode);
528                                }
529                                node->repeate = 0;
530                                status.writerectimer = 1;
531                        }
532                        chnode = getchannel(node->serviceid, node->transponderid);
533                        if(node->justplay == 1)
534                        {
535                                //ret = servicestart(chnode, NULL, node->channellist, 0);
536                                ret = servicestart(chnode, node->channellist, NULL, 0);
537                                if(ret == 20 || ret == 22) ret = 0;
538                        }
539                        else
540                        {
541                                //workaround for standby recording
542                                char* cmd = NULL;
543                                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
544//                              cmd = ostrcat(cmd, " >/dev/null", 1, 0);
545                                printf("cmd: %s\n", cmd);
546                                system(cmd);
547                                free(cmd), cmd = NULL;
548                                sleep(2);
549                                cmd = NULL;
550                                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
551//                              cmd = ostrcat(cmd, " >/dev/null", 1, 0);
552                                printf("cmd: %s\n", cmd);
553                                system(cmd);
554                                free(cmd), cmd = NULL;
555
556printf("fdisk -l\n");
557system("fdisk -l");
558
559printf("ls -al /media\n");
560system("ls -al /media");
561printf("ls -al /media/hdd/\n");
562system("ls -al /media/hdd/");
563printf("ls -al /media/hdd/movie\n");
564system("ls -al /media/hdd/movie");
565printf("sdparm -C START /dev/sda\n");
566system("sdparm -C START /dev/sda");
567printf("fdisk -l\n");
568system("fdisk -l");
569printf("ls -al /media\n");
570system("ls -al /media");
571printf("ls -al /media/hdd/\n");
572system("ls -al /media/hdd/");
573printf("ls -al /media/hdd/movie\n");
574system("ls -al /media/hdd/movie");
575
576                                // workaround end       
577                                ret = recordstart(chnode, -1, 0, RECTIMER, node->end, node);
578                                if(ret == 14) ret = 0;
579                        }
580
581                        if(ret != 0)
582                        {
583                                node->status = 3;
584                                status.writerectimer = 1;
585                                break;
586                        }
587                        else
588                        {
589                                if(node->justplay == 1)
590                                        node->status = 2;
591                                else
592                                        node->status = 1;
593                                status.writerectimer = 1;
594                        }
595                }
596                if(t > node->end && (node->status == 0 || node->status == 4) && node->end != 0)
597                {
598                        if(node->status == 4)
599                                node->status = 5;
600                        else
601                                node->status = 3;
602                        free(node->errstr);
603                        node->errstr = ostrcat(_("not started akttime higher than timer endtime"), NULL, 0, 0);
604                        status.writerectimer = 1;
605                }
606                //for epgscan
607                if(t >= begin && t < end && node->disabled == 0 && node->status == 4)
608                {
609                        node->status = 5;
610                        status.writerectimer = 1;
611
612                        if(status.standby == 0)
613                        {
614                                int tret = textbox(_("Message"), _("EPG Scan activate standby?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 20, 0);
615
616                                if(tret == 0 || tret == 1)
617                                {
618                                        status.standby = 2;
619                                        addtimer(&screenstandby, START, 1000, 1, NULL, NULL, NULL);
620                                }
621                        }
622                }
623                node = node->next;
624        }
625
626        m_unlock(&status.rectimermutex, 1);
627
628        if(node != NULL && node->disabled == 0 && node->status < 4)
629        {
630                if(node->justplay == 1)
631                {
632                        char* retstr = servicecheckret(ret, 1);
633                        free(node->errstr);
634                        node->errstr = ostrcat(retstr, NULL, 0, 0);
635                        stringreplacecharonce(node->errstr, '\n', '\0');
636                        free(retstr); retstr = NULL;
637                }
638                else
639                {
640                        char* retstr = recordcheckret(NULL, ret, 15);
641                        free(node->errstr);
642                        node->errstr = ostrcat(retstr, NULL, 0, 0);
643                        stringreplacecharonce(node->errstr, '\n', '\0');
644                        free(retstr); retstr = NULL;
645                }
646                status.writerectimer = 1;
647        }
648
649        writerectimer(getconfig("rectimerfile", NULL), 0);
650}
651
652int addrectimer(char *buf)
653{
654        struct rectimer* node = NULL;
655        char* buf1 = buf;
656        char* line = NULL;
657
658        line = malloc(MINMALLOC);
659        if(line == NULL)
660        {
661                err("no memory");
662                return 1;
663        }
664
665        while(*buf != '\0')
666        {
667                buf++;
668                if(*buf == '\n' || *buf == '\0')
669                {
670                        if(*buf == '\n')
671                        {
672                                buf++;
673                                snprintf(line, buf - buf1, "%s", buf1);
674                        }
675                        else
676                                snprintf(line, buf - buf1 + 1, "%s", buf1);
677                        buf1 = buf;
678
679                        if(ostrstr(line, "<timer ") != NULL || ostrstr(line, "<log ") != NULL || ostrstr(line, "<epgscan ") != NULL)
680                                node = addrectimernode(line, node);
681                }
682        }
683        free(line);
684        return 0;
685}
686
687int readrectimer(char *filename)
688{
689        char *buf = NULL;
690
691        buf = readfiletomem(filename, 1);
692
693        if(buf != NULL)
694        {
695                addrectimer(buf);
696                //timers can change on load, so we save it
697                writerectimer(getconfig("rectimerfile", NULL), 0);
698                free(buf);
699        }
700        return 0;
701}
702
703//flag 0 = set mutex
704//flag 1 = don't set mutex
705void delrectimer(struct rectimer* rectimernode, int write, int flag)
706{
707        if(flag == 0) m_lock(&status.rectimermutex, 1);
708        struct rectimer *node = rectimer, *prev = rectimer;
709
710        while(node != NULL)
711        {
712                if(node == rectimernode)
713                {
714                        status.writerectimer = 1;
715
716                        //record is aktiv (del from stopservice)
717                        if(node->servicenode != NULL)
718                        {
719                                node->status = 2;
720                                free(node->errstr);
721                                node->errstr = ostrcat(_("stopped from user"), NULL, 0, 0);
722                                //stop recording
723                                node->servicenode->recendtime = 2;
724                                if(flag == 0)
725                                        m_unlock(&status.rectimermutex, 1);
726                                return;
727                        }
728
729                        if(node == rectimer)
730                        {
731                                rectimer = node->next;
732                                if(rectimer != NULL)
733                                        rectimer->prev = NULL;
734                        }
735                        else
736                        {
737                                prev->next = node->next;
738                                if(node->next != NULL)
739                                        node->next->prev = prev;
740                        }
741
742                        free(node->name);
743                        node->name = NULL;
744                       
745                        free(node->timestamp);
746                        node->timestamp = NULL;
747
748                        free(node->recpath);
749                        node->recpath = NULL;
750
751                        free(node->channellist);
752                        node->channellist = NULL;
753
754                        free(node->errstr);
755                        node->errstr = NULL;
756                       
757                        free(node->pincode);
758                        node->pincode = NULL;
759
760                        free(node);
761                        node = NULL;
762                        break;
763                }
764
765                prev = node;
766                node = node->next;
767        }
768
769        if(write == 1)
770                writerectimer(getconfig("rectimerfile", NULL), 1);
771
772        if(flag == 0)
773                m_unlock(&status.rectimermutex, 1);
774}
775
776void deloldrectimer()
777{
778        struct rectimer *node = rectimer, *prev = rectimer;
779
780        while(node != NULL)
781        {
782                prev = node;
783                node = node->next;
784                if(prev != NULL && checkrectimertime(prev) == 1)
785                        delrectimer(prev, 1, 0);
786        }
787}
788
789void freerectimer()
790{
791        struct rectimer *node = rectimer, *prev = rectimer;
792
793        while(node != NULL)
794        {
795                prev = node;
796                node = node->next;
797                if(prev != NULL)
798                        delrectimer(prev, 0, 0);
799        }
800}
801
802//flag 0: lock
803//flag 1: don't lock
804int writerectimer(const char *filename, int flag)
805{
806        FILE *fd = NULL;
807        struct rectimer *node = NULL;
808        int ret = 0;
809        char* type = NULL;
810        time_t curtime = time(NULL), rectime = 0x7FFFFFFF;
811
812        if(status.writerectimer == 0) return 0;
813
814        //check if rectimer loadet
815        if(status.rectimerthread == NULL || (status.rectimerthread != NULL && status.rectimerthread->delay == 1000))
816        {
817                err("can't write rectimer, not loaded yet");
818                return 1;
819        }
820
821        if(flag == 0) m_lock(&status.rectimermutex, 1);
822        sortrectimer();
823        node = rectimer;
824
825        fd = fopen(filename, "w");
826        if(fd == NULL)
827        {
828                if(flag == 0) m_unlock(&status.rectimermutex, 1);
829                status.writerectimer = 0;
830                perr("can't open %s", filename);
831                return 1;
832        }
833
834        while(node != NULL)
835        {
836                //don't write for del marked or old timers
837                if(checkrectimertime(node) == 1)
838                {
839                        node = node->next;
840                        continue;
841                }
842
843                if(node->name == NULL) node->name = ostrcat(node->name, NULL, 1, 0);
844                if(node->channellist == NULL) node->channellist = ostrcat(node->channellist, NULL, 1, 0);
845                if(node->errstr == NULL) node->errstr = ostrcat(node->errstr, NULL, 1, 0);
846                if(node->pincode == NULL) node->pincode = ostrcat(node->pincode, "0000", 1, 0);
847                if(node->recpath == NULL) node->recpath = ostrcat(node->recpath, NULL, 1, 0);
848                if(node->status == 0 || node->status == 1)
849                        type = "timer";
850                else if(node->status == 4 || node->status == 5)
851                        type = "epgscan";
852                else
853                        type = "log";
854
855                ret = fprintf(fd, "<%s begin=\"%lu\" end=\"%lu\" serviceid=\"%d\" transponderid=\"%llu\" channellist=\"%s\" repeated=\"%d\" name=\"%s\" afterevent=\"%d\" pincode=\"%s\" disabled=\"%d\" justplay=\"%d\", recpath=\"%s\", timestamp=\"%s\", status=\"%d\" errstr=\"%s\">\n</%s>\n", type, node->begin, node->end, node->serviceid, node->transponderid, node->channellist, node->repeate, node->name, node->afterevent, node->pincode, node->disabled, node->justplay, node->recpath, node->timestamp, node->status, node->errstr, type);
856
857                if(ret < 0)
858                {
859                        perr("writting file %s", filename);
860                }
861
862                //get wakeup time
863                if(node->status == 0 || node->status == 1 || node->status == 4)
864                {
865                        if(node->begin < rectime && node->begin > curtime)
866                                rectime = node->begin;
867                }
868                node = node->next;
869        }
870
871        fclose(fd);
872        //write wakeup time to proc
873        setwakeuptimerdev(rectime);
874        debugrectimer();
875
876        if(flag == 0) m_unlock(&status.rectimermutex, 1);
877
878        status.writerectimer = 0;
879        return 0;
880}
881
882int recrepeateget(int newnode, struct skin* repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
883{
884        unsigned char ret = 0;
885        int aktday = rectimergetaktday();
886
887        if(repeate == NULL) return 0;
888        if(repeatetype == NULL) return 0;
889
890        if(ostrcmp(repeate->ret, "0") == 0) return 0;
891
892        if(ostrcmp(repeatetype->ret, "0") == 0) return 127;
893        if(ostrcmp(repeatetype->ret, "1") == 0)
894        {
895                if(day->ret == NULL) return aktday;
896                if(ostrcmp(day->ret, "0") == 0)
897                {
898                        if(newnode == 1)
899                                return aktday;
900                        else
901                                return 1;
902                }
903                if(ostrcmp(day->ret, "1") == 0) return 2;
904                if(ostrcmp(day->ret, "2") == 0) return 4;
905                if(ostrcmp(day->ret, "3") == 0) return 8;
906                if(ostrcmp(day->ret, "4") == 0) return 16;
907                if(ostrcmp(day->ret, "5") == 0) return 32;
908                if(ostrcmp(day->ret, "6") == 0) return 64;
909        }
910        if(ostrcmp(repeatetype->ret, "2") == 0) return 31;
911        if(ostrcmp(repeatetype->ret, "3") == 0)
912        {
913                if(mon == NULL || tue == NULL || wed == NULL || thur == NULL || fri == NULL || sat == NULL || sun == NULL) return aktday;
914                if(ostrcmp(mon->ret, "1") == 0) ret = setbit(ret, 0);
915                if(ostrcmp(tue->ret, "1") == 0) ret = setbit(ret, 1);
916                if(ostrcmp(wed->ret, "1") == 0) ret = setbit(ret, 2);
917                if(ostrcmp(thur->ret, "1") == 0) ret = setbit(ret, 3);
918                if(ostrcmp(fri->ret, "1") == 0) ret = setbit(ret, 4);
919                if(ostrcmp(sat->ret, "1") == 0) ret = setbit(ret, 5);
920                if(ostrcmp(sun->ret, "1") == 0) ret = setbit(ret, 6);
921                if(ret == 0) ret = aktday;
922                return ret;
923        }
924
925        return 127;
926}
927
928void recjustplayhidden(int justplay, struct skin* end, struct skin* path, struct skin* after)
929{
930        if(justplay == 0)
931        {
932                end->hidden = NO;
933                path->hidden = NO;
934                after->hidden = NO;
935        }
936        else
937        {
938                end->hidden = YES;
939                path->hidden = YES;
940                after->hidden = YES;
941        }
942}
943
944int rectimergetaktday()
945{
946        int ret = 1;
947        struct tm* loctime = NULL;
948
949        time_t akttime = time(NULL);
950        loctime = olocaltime(&akttime);
951        if(loctime != NULL)
952        {
953                if(loctime->tm_wday == 0) ret = 64;
954                if(loctime->tm_wday == 1) ret = 1;
955                if(loctime->tm_wday == 2) ret = 2;
956                if(loctime->tm_wday == 3) ret = 4;
957                if(loctime->tm_wday == 4) ret = 8;
958                if(loctime->tm_wday == 5) ret = 16;
959                if(loctime->tm_wday == 6) ret = 32;
960        }
961        free(loctime); loctime = NULL;
962
963        return ret;
964}
965
966void recrepeatehidden(int repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
967{
968        repeatetype->hidden = YES;
969        day->hidden = YES;
970        mon->hidden = YES;
971        tue->hidden = YES;
972        wed->hidden = YES;
973        thur->hidden = YES;
974        fri->hidden = YES;
975        sat->hidden = YES;
976        sun->hidden = YES;
977
978        if(repeate == 0) return;
979
980        if(repeate == 127 && ostrcmp(repeatetype->ret, "3") != 0) //dayly
981        {
982                repeatetype->hidden = NO;
983                setchoiceboxselection(repeatetype, "0");
984                return;
985        }
986        if(repeate == 31 && ostrcmp(repeatetype->ret, "3") != 0) //workday
987        {
988                repeatetype->hidden = NO;
989                setchoiceboxselection(repeatetype, "2");
990                return;
991        }
992        if((repeate == 1 || repeate == 2 || repeate == 4 || repeate == 8 || repeate == 16 || repeate == 32 || repeate == 64) && ostrcmp(repeatetype->ret, "3") != 0) //weekly
993        {
994                repeatetype->hidden = NO;
995                setchoiceboxselection(repeatetype, "1");
996                day->hidden = NO;
997                if(repeate == 1) setchoiceboxselection(day, "0");
998                else if(repeate == 2) setchoiceboxselection(day, "1");
999                else if(repeate == 4) setchoiceboxselection(day, "2");
1000                else if(repeate == 8) setchoiceboxselection(day, "3");
1001                else if(repeate == 16) setchoiceboxselection(day, "4");
1002                else if(repeate == 32) setchoiceboxselection(day, "5");
1003                else if(repeate == 64) setchoiceboxselection(day, "6");
1004                return;
1005        }
1006
1007        //user defined
1008        repeatetype->hidden = NO;
1009        setchoiceboxselection(repeatetype, "3");
1010        mon->hidden = NO;
1011        tue->hidden = NO;
1012        wed->hidden = NO;
1013        thur->hidden = NO;
1014        fri->hidden = NO;
1015        sat->hidden = NO;
1016        sun->hidden = NO;
1017        if(checkbit(repeate, 0) == 1) setchoiceboxselection(mon, "1");
1018        if(checkbit(repeate, 1) == 1) setchoiceboxselection(tue, "1");
1019        if(checkbit(repeate, 2) == 1) setchoiceboxselection(wed, "1");
1020        if(checkbit(repeate, 3) == 1) setchoiceboxselection(thur, "1");
1021        if(checkbit(repeate, 4) == 1) setchoiceboxselection(fri, "1");
1022        if(checkbit(repeate, 5) == 1) setchoiceboxselection(sat, "1");
1023        if(checkbit(repeate, 6) == 1) setchoiceboxselection(sun, "1");
1024}
1025
1026//flag 0: called from menu (manuel timer)
1027//flag 1: call from epg timer
1028void screenrectimerext(struct rectimer* node, int flag)
1029{
1030        int ret = 0, rcret = 0, edaylight = 0, bdaylight = 0, newnode = 0, tmpservicetype = 0, tmprepeate = 0;
1031        struct skin* rectimerext = getscreen("rectimerext");
1032        struct skin* listbox = getscreennode(rectimerext, "listbox");
1033        struct skin* name = getscreennode(rectimerext, "name");
1034        struct skin* justplay = getscreennode(rectimerext, "justplay");
1035        struct skin* repeate = getscreennode(rectimerext, "repeate");
1036        struct skin* repeatetype = getscreennode(rectimerext, "repeatetype");
1037        struct skin* day = getscreennode(rectimerext, "day");
1038        struct skin* mon = getscreennode(rectimerext, "mon");
1039        struct skin* tue = getscreennode(rectimerext, "tue");
1040        struct skin* wed = getscreennode(rectimerext, "wed");
1041        struct skin* thur = getscreennode(rectimerext, "thur");
1042        struct skin* fri = getscreennode(rectimerext, "fri");
1043        struct skin* sat = getscreennode(rectimerext, "sat");
1044        struct skin* sun = getscreennode(rectimerext, "sun");
1045        struct skin* begin = getscreennode(rectimerext, "begin");
1046        struct skin* end = getscreennode(rectimerext, "end");
1047        struct skin* recchannel = getscreennode(rectimerext, "channel");
1048        struct skin* path = getscreennode(rectimerext, "path");
1049        struct skin* after = getscreennode(rectimerext, "after");
1050        struct skin* pincode = getscreennode(rectimerext, "pincode");
1051        struct skin* tmp = NULL;
1052        char* tmpstr = NULL, *buf = NULL, *buf1 = NULL, *tmpchannellist = NULL;
1053        struct tm* loctime = NULL;
1054        time_t akttime = time(NULL);
1055
1056        if(node == NULL)
1057        {
1058                newnode = 1;
1059                node = addrectimernode(NULL, NULL);
1060                tmpservicetype = status.servicetype;
1061                if(tmpservicetype == 0)
1062                        tmpchannellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1063                else
1064                        tmpchannellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1065        }
1066        else
1067        {
1068                tmpservicetype = node->servicetype;
1069                tmpchannellist = ostrcat(node->channellist, NULL, 0, 0);
1070        }
1071
1072        if(node == NULL)
1073        {
1074                err("NULL detect");
1075                return;
1076        }
1077
1078        listbox->aktline = 1;
1079        listbox->aktpage = -1;
1080        begin->aktpage = 0;
1081        end->aktpage = 0;
1082        name->aktpage = 0;
1083       
1084        changeinput(name, node->name);
1085
1086        addchoicebox(justplay, "0", _("record"));
1087        addchoicebox(justplay, "1", _("switch channel"));
1088        if(newnode == 0)
1089        {
1090                tmpstr = oitoa(node->justplay);
1091                setchoiceboxselection(justplay, tmpstr);
1092                free(tmpstr); tmpstr = NULL;
1093        }
1094        else
1095                setchoiceboxselection(justplay, "0");
1096
1097        addchoicebox(repeate, "0", _("once"));
1098        addchoicebox(repeate, "1", _("repeate"));
1099        if(newnode == 0)
1100        {
1101                tmprepeate = node->repeate;
1102                if(node->repeate == 0)
1103                        setchoiceboxselection(repeate, "0");
1104                else
1105                        setchoiceboxselection(repeate, "1");
1106        }
1107        else
1108                setchoiceboxselection(repeate, "0");
1109
1110        addchoicebox(repeatetype, "0", _("daily"));
1111        addchoicebox(repeatetype, "1", _("weekly"));
1112        addchoicebox(repeatetype, "2", _("workdays"));
1113        addchoicebox(repeatetype, "3", _("user defined"));
1114        changeret(repeatetype, NULL);
1115        setchoiceboxselection(repeatetype, "0");
1116
1117        addchoicebox(day, "0", _("Monday"));
1118        addchoicebox(day, "1", _("Tuesday"));
1119        addchoicebox(day, "2", _("Wednesday"));
1120        addchoicebox(day, "3", _("Thursday"));
1121        addchoicebox(day, "4", _("Friday"));
1122        addchoicebox(day, "5", _("Saturday"));
1123        addchoicebox(day, "6", _("Sunday"));
1124        changeret(day, NULL);
1125        setchoiceboxselection(day, "0");
1126
1127        addchoicebox(mon, "0", _("no"));
1128        addchoicebox(mon, "1", _("yes"));
1129        changeret(mon, NULL);
1130        setchoiceboxselection(mon, "0");
1131
1132        addchoicebox(tue, "0", _("no"));
1133        addchoicebox(tue, "1", _("yes"));
1134        changeret(tue, NULL);
1135        setchoiceboxselection(tue, "0");
1136
1137        addchoicebox(wed, "0", _("no"));
1138        addchoicebox(wed, "1", _("yes"));
1139        changeret(wed, NULL);
1140        setchoiceboxselection(wed, "0");
1141
1142        addchoicebox(thur, "0", _("no"));
1143        addchoicebox(thur, "1", _("yes"));
1144        changeret(thur, NULL);
1145        setchoiceboxselection(thur, "0");
1146
1147        addchoicebox(fri, "0", _("no"));
1148        addchoicebox(fri, "1", _("yes"));
1149        changeret(fri, NULL);
1150        setchoiceboxselection(fri, "0");
1151
1152        addchoicebox(sat, "0", _("no"));
1153        addchoicebox(sat, "1", _("yes"));
1154        changeret(sat, NULL);
1155        setchoiceboxselection(sat, "0");
1156
1157        addchoicebox(sun, "0", _("no"));
1158        addchoicebox(sun, "1", _("yes"));
1159        changeret(sun, NULL);
1160        setchoiceboxselection(sun, "0");
1161
1162        recrepeatehidden(node->repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1163        recjustplayhidden(node->justplay, end, path, after);
1164
1165        buf = malloc(MINMALLOC);
1166        if(buf == NULL)
1167        {
1168                err("no memory");
1169                return;
1170        }
1171
1172        changemask(begin, "00:00 00-00-0000");
1173        if(newnode == 0)
1174                loctime = localtime(&node->begin);
1175        else
1176                loctime = localtime(&akttime);
1177        bdaylight = loctime->tm_isdst;
1178        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1179        buf1 = ostrcat(buf, NULL, 0, 0);
1180        changeinput(begin, buf1);
1181        free(buf1); buf1 = NULL;
1182
1183        changemask(end, "00:00 00-00-0000");
1184        if(newnode == 0)
1185                loctime = localtime(&node->end);
1186        else
1187        {
1188                akttime += 300;
1189                loctime = localtime(&akttime);
1190        }
1191        edaylight = loctime->tm_isdst;
1192        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1193        buf1 = ostrcat(buf, NULL, 1, 0);
1194        changeinput(end, buf1);
1195        free(buf1); buf1 = NULL;
1196
1197        if(flag == 1)
1198                recchannel->hidden = YES;
1199        else
1200                recchannel->hidden = NO;
1201
1202        changeinput(recchannel, NULL);
1203        if(newnode == 0)
1204        {
1205                recchannel->handle = (char*)getchannel(node->serviceid, node->transponderid);
1206                if(recchannel->handle != NULL)
1207                        addchoicebox(recchannel, ((struct channel*)recchannel->handle)->name, ((struct channel*)recchannel->handle)->name);
1208        }
1209        else
1210        {
1211                if(status.aktservice->channel != NULL)
1212                {
1213                        addchoicebox(recchannel, status.aktservice->channel->name, status.aktservice->channel->name);
1214                        recchannel->handle = (char*)status.aktservice->channel;
1215                }
1216        }
1217
1218        if(newnode == 0)
1219                changeinput(path, node->recpath);
1220        else
1221                changeinput(path, getconfig("rec_path", NULL));
1222
1223        addchoicebox(after, "0", _("auto"));
1224        addchoicebox(after, "1", _("nothing"));
1225        addchoicebox(after, "2", _("standby"));
1226        addchoicebox(after, "3", _("power off"));
1227        if(newnode == 0)
1228        {
1229                tmpstr = oitoa(node->afterevent);
1230                setchoiceboxselection(after, tmpstr);
1231                free(tmpstr); tmpstr = NULL;
1232        }
1233               
1234        changemask(pincode, "0000");
1235        if(newnode == 0)
1236                changeinput(pincode, node->pincode);
1237        else
1238                changeinput(pincode, "0000");
1239
1240        drawscreen(rectimerext, 0, 0);
1241        addscreenrc(rectimerext, listbox);
1242
1243        tmp = listbox->select;
1244        while(1)
1245        {
1246                addscreenrc(rectimerext, tmp);
1247                rcret = waitrc(rectimerext, 0, 2);
1248                tmp = listbox->select;
1249               
1250                if(rcret == getrcconfigint("rcred", NULL))
1251                {
1252                        if(name->ret != NULL && strlen(name->ret) > 0)
1253                        {
1254                                char* tmppath = NULL;
1255                               
1256                                tmppath = ostrcat(tmppath, name->ret, 1, 0);
1257                                tmppath = strstrip(tmppath);
1258                                delspezchar(tmppath, 2);
1259                                tmppath = ostrcat("/", tmppath, 0, 1);                         
1260                                tmppath = ostrcat(getconfig("rec_path", NULL), tmppath, 0, 1);
1261                               
1262                                if(tmppath != NULL && mkdir(tmppath, 0777) == 0)
1263                                {
1264                                        changeinput(path, tmppath);
1265                                        changetext(path, tmppath);
1266                                }
1267                                else
1268                                        textbox(_("Message"), "Can't create Path", _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1269                               
1270                                drawscreen(rectimerext, 0, 0);
1271                                free(tmppath); tmppath = NULL;
1272                        }
1273                        continue;
1274                }
1275
1276                if(listbox->select != NULL && listbox->select->ret != NULL && ostrcmp(listbox->select->name, "justplay") == 0)
1277                {
1278                        recjustplayhidden(atoi(listbox->select->ret), end, path, after);
1279                }
1280
1281                tmprepeate = recrepeateget(newnode, repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1282                if(listbox->select != NULL && (ostrcmp(listbox->select->name, "repeate") == 0 || ostrcmp(listbox->select->name, "repeatetype") == 0))
1283                {
1284                        recrepeatehidden(tmprepeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1285                }
1286                drawscreen(rectimerext, 0, 0);
1287
1288                if(rcret == getrcconfigint("rcexit", NULL))
1289                {
1290                        if(newnode == 1 || flag == 1) delrectimer(node, 1, 0);
1291                        break;
1292                }
1293                if(rcret == getrcconfigint("rcok", NULL))
1294                {
1295                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "path") == 0)
1296                        {
1297                                clearscreen(rectimerext);
1298                                tmpstr = screendir(listbox->select->ret, "", NULL, NULL, NULL, NULL, 0, "SELECT", 0, NULL, 0, NULL, 0, 700, 0, 650, 0, 0);
1299                                if(tmpstr != NULL)
1300                                        changeinput(listbox->select, tmpstr);
1301                                free(tmpstr); tmpstr = NULL;
1302
1303                                drawscreen(rectimerext, 0, 0);
1304                                continue;
1305                        }
1306                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "channel") == 0)
1307                        {
1308                                clearscreen(rectimerext);
1309                                int saveservicetype = status.servicetype;
1310                                struct channel* tmpchnode = (struct channel*)recchannel->handle;
1311
1312                                status.servicetype = tmpservicetype;
1313                                if(tmpservicetype == 0)
1314                                {
1315                                        addconfigtmp("channellist", tmpchannellist);
1316                                        if(tmpchnode != NULL)
1317                                        {
1318                                                addconfiginttmp("serviceid", tmpchnode->serviceid);
1319                                                addconfigllutmp("transponderid", tmpchnode->transponderid);
1320                                        }
1321                                }
1322                                else
1323                                {
1324                                        addconfigtmp("rchannellist", tmpchannellist);
1325                                        if(tmpchnode != NULL)
1326                                        {
1327                                                addconfiginttmp("rserviceid", tmpchnode->serviceid);
1328                                                addconfigllutmp("rtransponderid", tmpchnode->transponderid);
1329                                        }
1330                                }
1331
1332                                screenchannellist(&tmpchnode, &tmpchannellist, 1);
1333
1334                                recchannel->handle = (char*)tmpchnode;
1335
1336                                status.servicetype = saveservicetype;
1337                                delconfigtmp("channellist");
1338                                delconfigtmp("rchannellist");
1339                                delconfigtmp("serviceid");
1340                                delconfigtmp("rserviceid");
1341                                delconfigtmp("transponderid");
1342                                delconfigtmp("rtransponderid");
1343
1344                                if((struct channel*)recchannel->handle != NULL)
1345                                {
1346                                        changeinput(listbox->select, ((struct channel*)recchannel->handle)->name);
1347                                }
1348
1349                                drawscreen(rectimerext, 0, 0);
1350                                continue;
1351                        }
1352
1353                        free(node->name); node->name = NULL;
1354                        node->name = ostrcat(name->ret, NULL, 0, 0);
1355                        if(justplay->ret != NULL)
1356                                node->justplay = atoi(justplay->ret);
1357                        if(begin->ret != NULL)
1358                        {
1359                                loctime->tm_isdst = bdaylight;
1360                                tmpstr = strptime(begin->ret, "%H:%M %d-%m-%Y", loctime);
1361                                if(tmpstr != NULL)
1362                                        node->begin = mktime(loctime);
1363
1364                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1365                                        node->begin -= getconfigint("recforerun", NULL) * 60;
1366
1367                                node->begin -= (node->begin % 60);
1368
1369                                if(node->justplay == 1)
1370                                        node->end = node->begin + 1;
1371                        }
1372                        if(end->ret != NULL && node->justplay == 0)
1373                        {
1374                                loctime->tm_isdst = edaylight;
1375                                tmpstr = strptime(end->ret, "%H:%M %d-%m-%Y", loctime);
1376                                if(tmpstr != NULL)
1377                                        node->end = mktime(loctime);
1378
1379                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1380                                        node->end += getconfigint("recoverrun", NULL) * 60;
1381                                node->end -= (node->end % 60);
1382                        }
1383                        if(after->ret != NULL)
1384                                node->afterevent = atoi(after->ret);
1385                               
1386                        if(pincode->ret != NULL)
1387                                node->pincode = ostrcat(pincode->ret, NULL, 0, 0);
1388                        else
1389                                node->pincode = ostrcat("0000", NULL, 0, 0);
1390
1391                        if(tmprepeate > 127) tmprepeate = 0;
1392                        node->repeate = tmprepeate;
1393
1394                        free(node->recpath); node->recpath = NULL;
1395                        node->recpath = ostrcat(path->ret, NULL, 0, 0);
1396
1397                        free(node->channellist); node->channellist = NULL;
1398                        node->channellist = tmpchannellist;
1399
1400                        node->servicetype = tmpservicetype;
1401
1402                        if(recchannel->handle != NULL)
1403                        {
1404                                node->serviceid = ((struct channel*)recchannel->handle)->serviceid;
1405                                node->transponderid = ((struct channel*)recchannel->handle)->transponderid;
1406                        }
1407
1408                        char* checkret = NULL;
1409                        ret = checkrectimeradd(node, &checkret);
1410                        if(ret != 0)
1411                        {
1412                                if(ret == 2)
1413                                {
1414                                        ret = textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1415                                        if(ret == 2)
1416                                                ret = 99;
1417                                        else
1418                                                ret = 0;
1419                                }
1420                                if(ret == 1 || ret == 99)
1421                                {
1422                                        node->status = 3;
1423                                        free(node->errstr); node->errstr = NULL;
1424                                        node->errstr = ostrcat(checkret, NULL, 0, 0);
1425                                        stringreplacecharonce(node->errstr, '\n', '\0');
1426                                        if(ret == 1) textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1427                                }
1428                        }
1429
1430                        //check if record is running and change endtime
1431                        m_lock(&status.servicemutex, 2);
1432                        struct service* tmpservice = getservicebyrectimestamp(node->timestamp, 1);
1433                        if(tmpservice != NULL)
1434                                tmpservice->recendtime = node->end;
1435                        m_unlock(&status.servicemutex, 2);
1436                               
1437                        if(newnode == 1 || flag == 1) node->disabled = 0;
1438                        status.writerectimer = 1;
1439                        writerectimer(getconfig("rectimerfile", NULL), 0);
1440                        break;
1441                }
1442        }
1443
1444        if(flag == 1) resettvpic();
1445
1446        delownerrc(rectimerext);
1447        clearscreen(rectimerext);
1448}
1449
1450//flag 0: show normal
1451//flag 1: show log
1452void screenrectimer()
1453{
1454        int rcret = 0, flag = 0;
1455        struct skin* recordtimer = getscreen("rectimer");
1456        struct skin* listbox = getscreennode(recordtimer, "listbox");
1457        struct skin* b1 = getscreennode(recordtimer, "b1");
1458        struct skin* b2 = getscreennode(recordtimer, "b2");
1459        struct skin* b3 = getscreennode(recordtimer, "b3");
1460        struct skin* b4 = getscreennode(recordtimer, "b4");
1461        struct skin* tmp = NULL;
1462        struct rectimer* rectimernode = NULL;
1463        struct tm *loctime = NULL;
1464        struct channel* chnode = NULL;
1465        char* buf = NULL, *tmpstr = NULL;
1466
1467        buf = malloc(MINMALLOC);
1468        if(buf == NULL)
1469        {
1470                err("no memory");
1471                return;
1472        }
1473
1474start:
1475        deloldrectimer();
1476
1477        tmp = NULL;
1478        listbox->aktpage = -1;
1479        listbox->select = NULL;
1480        rectimernode = rectimer;
1481
1482        while(rectimernode != NULL)
1483        {
1484                if((flag == 0 && (rectimernode->status == 2 || rectimernode->status == 3)) || (flag == 1 && (rectimernode->status == 0 || rectimernode->status == 1)) || rectimernode->status == 4 || rectimernode->status == 5)
1485                {
1486                        rectimernode = rectimernode->next;
1487                        continue;
1488                }
1489
1490                tmp = addlistbox(recordtimer, listbox, tmp, 1);
1491                if(tmp != NULL)
1492                {
1493                        loctime = localtime(&rectimernode->begin);
1494                        strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1495                        tmpstr = ostrcat(tmpstr, buf, 1, 0);
1496                        if(rectimernode->justplay == 0)
1497                        {
1498                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1499                                loctime = localtime(&rectimernode->end);
1500                                strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1501                                tmpstr = ostrcat(tmpstr, buf, 1, 0);
1502                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1503                                tmpstr = ostrcat(tmpstr, _("rec"), 1, 0);
1504                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1505                                if(rectimernode->repeate == 0)
1506                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1507                                else
1508                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1509                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1510                        }
1511                        else
1512                        {
1513                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1514                                tmpstr = ostrcat(tmpstr, _("switch"), 1, 0);
1515                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1516                                if(rectimernode->repeate == 0)
1517                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1518                                else
1519                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1520                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1521                        }
1522
1523                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1524                        if(rectimernode->name != NULL)
1525                        {
1526                                if(rectimernode->name == NULL || strlen(rectimernode->name) == 0)
1527                                        tmpstr = ostrcat(tmpstr, "---", 1, 0);
1528                                else
1529                                        tmpstr = ostrcat(tmpstr, rectimernode->name, 1, 0);
1530                        }
1531                        chnode = getchannel(rectimernode->serviceid, rectimernode->transponderid);
1532                        if(chnode != NULL && chnode->name != NULL && strlen(chnode->name) > 0)
1533                        {
1534                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1535                                tmpstr = ostrcat(tmpstr, chnode->name, 1, 0);
1536                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1537                        }
1538
1539                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1540                        if(rectimernode->status == 0)
1541                                tmpstr = ostrcat(tmpstr, _("waiting"), 1, 0);
1542                        else if(rectimernode->status == 1)
1543                                tmpstr = ostrcat(tmpstr, _("running"), 1, 0);
1544                        else if(rectimernode->status == 2)
1545                                tmpstr = ostrcat(tmpstr, _("success"), 1, 0);
1546                        else if(rectimernode->status == 3)
1547                                tmpstr = ostrcat(tmpstr, _("error"), 1, 0);
1548
1549                        if(flag == 1 && rectimernode->errstr != NULL && strlen(rectimernode->errstr) != 0)
1550                        {
1551                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1552                                tmpstr = ostrcat(tmpstr, rectimernode->errstr, 1, 0);
1553                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1554                        }
1555                       
1556                        changetext(tmp, tmpstr);
1557                        free(tmpstr); tmpstr = NULL;
1558                        tmp->handle = (char*)rectimernode;
1559                        tmp->height = 110;
1560                        tmp->type = TEXTBOX;
1561
1562                        if(rectimernode->disabled == 1)
1563                                tmp->fontcol = convertcol("deaktivcol");
1564                }
1565                rectimernode = rectimernode->next;
1566        }
1567
1568        if(flag == 0)
1569        {
1570                b1->hidden = NO;
1571                b2->hidden = NO;
1572                b3->hidden = NO;
1573                b4->hidden = NO;
1574        }
1575        else
1576        {
1577                b1->hidden = YES;
1578                b2->hidden = YES;
1579                b3->hidden = YES;
1580                b4->hidden = YES;
1581        }
1582
1583        drawscreen(recordtimer, 0, 0);
1584        addscreenrc(recordtimer, listbox);
1585
1586        while(1)
1587        {
1588                rcret = waitrc(recordtimer, 5000, 0);
1589
1590                if(flag == 0 && rcret == getrcconfigint("rcblue", NULL))
1591                {
1592                        flag = 1;
1593                        delmarkedscreennodes(recordtimer, 1);
1594                        goto start;
1595                }
1596                if(rcret == getrcconfigint("rcexit", NULL))
1597                {
1598                        if(flag == 0)
1599                                break;
1600                        else
1601                        {
1602                                flag = 0;
1603                                delmarkedscreennodes(recordtimer, 1);
1604                                goto start;
1605                        }
1606                }
1607                if(flag == 0 && rcret == getrcconfigint("rcgreen", NULL))
1608                {
1609                        clearscreen(recordtimer);
1610                        screenrectimerext(NULL, 0);
1611                        delmarkedscreennodes(recordtimer, 1);
1612                        goto start;
1613                }
1614                if(flag == 0 && listbox->select != NULL)
1615                {
1616                        if(rcret == getrcconfigint("rcok", NULL))
1617                        {
1618                                clearscreen(recordtimer);
1619                                screenrectimerext((struct rectimer*)listbox->select->handle, 0);
1620                                delmarkedscreennodes(recordtimer, 1);
1621                                goto start;
1622                        }
1623                        if(rcret == getrcconfigint("rcred", NULL))
1624                        {
1625                                delrectimer((struct rectimer*)listbox->select->handle, 1, 0);
1626                               
1627                                delmarkedscreennodes(recordtimer, 1);
1628                                goto start;
1629                        }
1630                        if(rcret == getrcconfigint("rcyellow", NULL))
1631                        {
1632                                if(((struct rectimer*)listbox->select->handle)->disabled == 1)
1633                                        ((struct rectimer*)listbox->select->handle)->disabled = 0;
1634                                else
1635                                        ((struct rectimer*)listbox->select->handle)->disabled = 1;
1636
1637                                delmarkedscreennodes(recordtimer, 1);
1638                                goto start;
1639                        }
1640                        if(rcret == RCTIMEOUT)
1641                        {
1642                                delmarkedscreennodes(recordtimer, 1);
1643                                goto start;
1644                        }
1645                }
1646        }
1647
1648        free(buf); buf = NULL;
1649        delmarkedscreennodes(recordtimer, 1);
1650        delownerrc(recordtimer);
1651        clearscreen(recordtimer);
1652}
1653
1654int addrecepg(struct channel* chnode, struct epg* epgnode, char* channellist)
1655{
1656        struct rectimer* node = NULL;
1657
1658        deloldrectimer();
1659
1660        if(chnode == NULL || epgnode == NULL)
1661                return 1;
1662
1663        node = addrectimernode(NULL, NULL);
1664        if(node != NULL)
1665        {
1666                node->name = ostrcat(epgnode->title, NULL, 0, 0);
1667                node->begin = epgnode->starttime;
1668                node->end = epgnode->endtime;
1669
1670                node->repeate = 0;
1671
1672                node->recpath = ostrcat(getconfig("rec_path", NULL), NULL, 0, 0);
1673                node->servicetype = status.servicetype;
1674                if(node->servicetype == 0)
1675                {
1676                        if(channellist == NULL)
1677                                node->channellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1678                        else
1679                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1680                }
1681                else
1682                {
1683                        if(channellist == NULL)
1684                                node->channellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1685                        else
1686                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1687                }
1688                node->serviceid = chnode->serviceid;
1689                node->transponderid = chnode->transponderid;
1690                screenrectimerext(node, 1);
1691        }
1692
1693        return 0;
1694}
1695
1696#endif
Note: See TracBrowser for help on using the repository browser.