source: titan/titan/rc.h @ 41515

Last change on this file since 41515 was 41515, checked in by gost, 6 years ago

fix

File size: 11.6 KB
Line 
1#ifndef RC_H
2#define RC_H
3
4#ifdef ARM
5#define SECEVENT
6#endif
7
8int sendtuxtxt(int code)
9{
10        int rc;
11   
12        if((rc = open("/tmp/block.tmp", O_RDONLY)) >= 0)
13        {
14                close(rc);
15       
16                if(status.fdrctxt <= 0)
17                {
18                        struct sockaddr_un vAddr;
19                        vAddr.sun_family = AF_UNIX;
20                        strcpy(vAddr.sun_path, "/tmp/rc.socket");
21                        status.fdrctxt = socket(PF_UNIX, SOCK_STREAM, 0);
22       
23                        if(status.fdrctxt <= 0)
24                        {
25                                err("open tuxtxt rc socket");
26                                return 1;
27                        };
28
29                        if(connect(status.fdrctxt, (struct sockaddr *)&vAddr, sizeof(vAddr)) !=0)
30                        {
31                                close(status.fdrctxt);
32                                status.fdrctxt = -1;
33                                err("connect to tuxtxt rc socket");
34                                return 1;
35                        }
36                }
37       
38                if(status.fdrctxt > 0)
39                {
40                        char* tmpstr = malloc(8);
41                        if(tmpstr != NULL)
42                        {
43                                sprintf(tmpstr, "%08d", code);
44
45                                if(write(status.fdrctxt, tmpstr, 8) <= 0)
46                                {
47                                        err("forwarding to rc socket");
48                                        close(status.fdrctxt);
49                                        status.fdrctxt = -1;
50                                        free(tmpstr); tmpstr = NULL;
51                                        return 1;
52                                }
53                        }
54                        free(tmpstr); tmpstr = NULL;
55                }
56                else
57                {
58                        err("forwarding to rc socket");
59                }
60                return 0;
61        }
62
63        if(status.fdrctxt != -1)
64        {
65                close(status.fdrctxt);
66                status.fdrctxt = -1;
67        }
68        return 0;
69}
70
71int maprc(int rccode, struct skin* owner)
72{
73        if(owner != NULL)
74        {
75                struct rcmap* rcmapnode = getrcmap(owner->name, rccode);
76                if(rcmapnode != NULL)
77                        rccode = rcmapnode->newkey;
78        }
79
80        return rccode;
81}
82
83struct rc* getrc(int key, struct skin* owner)
84{
85        struct rc *node = rc;
86
87        while(node != NULL)
88        {
89                if(node->key == key && node->owner == owner)
90                        return node;
91
92                node = node->next;
93        }
94
95        node = rc;
96
97        while(node != NULL)
98        {
99                if(node->key == key && node->owner == NULL)
100                        return node;
101
102                node = node->next;
103        }
104        return NULL;
105}
106
107int openrc()
108{
109        char *rcdev = NULL;
110        int i = 0;
111
112        status.fdrc = -1;
113        status.fdrc1 = -1;
114
115        rcdev = getconfig("rcdev", NULL);
116        if(rcdev != NULL)
117        {
118                while(status.fdrc < 0 && i < 3)
119                {
120                        status.fdrc = open(rcdev, O_RDWR);
121                        if(status.fdrc < 0) sleep(1);
122                        i++;
123                }
124
125                if(status.fdrc < 0)
126                {
127                        err("open input device %s", rcdev);
128                        return 1;
129                }
130                closeonexec(status.fdrc);
131        }
132        else
133        {
134                err("input device not found in config");
135                return 1;
136        }
137       
138        rcdev = getconfig("rcfrontdev", NULL);
139        if(rcdev != NULL)
140        {
141                i = 0;
142                while(status.fdrc1 < 0 && i < 3)
143                {
144                        status.fdrc1 = open(rcdev, O_RDWR);
145                        if(status.fdrc1 < 0) sleep(1);
146                        i++;
147                }
148                if(status.fdrc1 > -1)
149                        closeonexec(status.fdrc1);
150        }
151
152        return 0;
153}
154
155void closerc()
156{
157        if(status.fdrc != -1)
158                close(status.fdrc);
159        if(status.fdrc1 != -1)
160                close(status.fdrc1);
161}
162
163int islongkey(int keycode)
164{
165        int i = 0;
166
167        for(i = 0; i < MAXLONGKEY; i++)
168        {
169                if(status.longkeycode[i] == keycode)
170                        return 1;
171        }
172        return 0;
173}
174
175int writerc(int keycode)
176{
177        int ret = 0;
178        struct input_event rcdata;
179        struct timeval akttime;
180
181        gettimeofday(&akttime, 0);
182        sendtuxtxt(keycode);
183
184        rcdata.time = akttime;
185        rcdata.type = EV_KEY;
186        rcdata.code = keycode;
187        rcdata.value = 1;
188        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
189
190#ifdef MIPSEL   
191        rcdata.time = akttime;
192        rcdata.type = 0;
193        rcdata.code = 0;
194        rcdata.value = 0;
195        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
196#endif
197
198        rcdata.time = akttime;
199        rcdata.type = EV_KEY;
200        rcdata.code = keycode;
201        rcdata.value = 0;
202        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
203
204#ifdef MIPSEL   
205        rcdata.time = akttime;
206        rcdata.type = 0;
207        rcdata.code = 0;
208        rcdata.value = 0;
209        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
210#endif
211       
212        return ret;
213}
214
215int flushrc(unsigned int timeout)
216{
217        fd_set rfds;
218        struct timeval tv;
219        struct input_event rcdata;
220        int rest = 0, count = 0;
221        int ret = 0, len = 0;
222
223        rest = timeout % 1000;
224        timeout = (timeout - rest) / 1000;
225
226        while(count < 10)
227        {
228                count++;
229                tv.tv_sec = timeout;
230                tv.tv_usec = rest * 1000;
231                FD_ZERO(&rfds);
232                FD_SET(status.fdrc, &rfds);
233
234                ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
235
236                if(ret < 1) break;
237                if(FD_ISSET(status.fdrc, &rfds))
238                {
239                        count = 0;
240                        len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
241                }
242        }
243
244        return 0;
245}
246
247void rcsignal(int flag)
248{
249        if((checkbox("DM900") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1) && status.standby == 0)
250        {
251                int art = getconfigint("dm900frontrun", NULL);
252                if(flag == 1)
253                {
254                        if(art == 0)
255                                writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1);
256                        else if(art == 1)
257                                writesys("/proc/stb/fp/led0_pattern", "ffffffff", 1);
258                        else if(art == 2)       
259                                writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1);
260                }
261                if(flag == 0)
262                {
263                        if(art == 0)
264                                writesys("/proc/stb/fp/led1_pattern", "00000000", 1);
265                        else if(art == 1)
266                                writesys("/proc/stb/fp/led0_pattern", "00000000", 1);
267                        else if(art == 2)       
268                                writesys("/proc/stb/fp/led1_pattern", "00000000", 1);
269                }
270        }
271}       
272
273int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview)
274{
275        fd_set rfds;
276        fd_set rfds1;
277        struct timeval tv;
278        struct input_event rcdata;
279        int treffer = 0, rest = 0, j = 0, front = 0;
280        int ret = 0, len = 0, fromthread = 0, longpress = 0, longpresscount = 0;
281        struct rc *node;
282        struct timeval aktrctime;
283       
284        if(pthread_self() != status.mainthread)
285                fromthread = 1;
286
287        rest = timeout % 1000;
288        timeout = (timeout - rest) / 1000;
289
290        if(timeout == 0 && rest == 0) timeout = 0x7fffffff;
291
292        while(treffer == 0)
293        {
294                tv.tv_sec = timeout;
295                tv.tv_usec = rest * 1000;
296                FD_ZERO(&rfds);
297                FD_SET(status.fdrc, &rfds);
298                front = 0;
299
300                if(fromthread == 0) status.sec = 0;
301                if((fromthread == 0 && status.rckey == 0) || fromthread == 1)
302                {
303                        if(fromthread == 0) m_unlock(&status.waitrcmutex, 24);
304#ifdef SECEVENT                 
305                        if(status.fdrc1 > -1 && timeout > 1)
306                        {
307                                for(j = 0; j < timeout / 2; j++)
308                                {
309                                        tv.tv_sec = 2;
310                                        tv.tv_usec = 0;
311                                        FD_ZERO(&rfds);
312                                        FD_SET(status.fdrc, &rfds);
313                                        ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
314                                        if(ret == 0)
315                                        {
316                                                tv.tv_sec = 0;
317                                                tv.tv_usec = 1000;
318                                                FD_ZERO(&rfds1);
319                                                FD_SET(status.fdrc1, &rfds1);
320                                                ret = TEMP_FAILURE_RETRY(select(status.fdrc1 + 1, &rfds1, NULL, NULL, &tv));
321                                                front = 1;
322                                        }
323                                        if(ret != 0)
324                                                break;
325                                }
326                        }
327                        else
328                        {
329#endif
330                                tv.tv_sec = timeout;
331                                tv.tv_usec = rest * 1000;
332                                FD_ZERO(&rfds);
333                                FD_SET(status.fdrc, &rfds);
334                                ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
335#ifdef SECEVENT                         
336                                if(ret == 0 && status.fdrc1 > -1)
337                                {
338                                        tv.tv_sec = 0;
339                                        tv.tv_usec = 1000;
340                                        FD_ZERO(&rfds1);
341                                        FD_SET(status.fdrc1, &rfds1);
342                                        ret = TEMP_FAILURE_RETRY(select(status.fdrc1 + 1, &rfds1, NULL, NULL, &tv));
343                                        front = 1;
344                                }
345                        }
346#endif
347                               
348                        if(fromthread == 0) m_lock(&status.waitrcmutex, 24);
349
350                        if((status.rcowner != NULL && status.rcowner != owner) || (status.rcstandby != NULL && status.rcstandby != owner))
351                        {
352                                if(status.rcstandby == NULL || status.rcstandby != owner)
353                                {
354                                        usleep(100000);
355                                        continue;
356                                }
357                        }
358                }
359                if(fromthread == 0) status.sec = time(NULL);
360
361                if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0))
362                {
363                        if(front == 0 && FD_ISSET(status.fdrc, &rfds))
364                                len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
365                        else if(front == 1 && FD_ISSET(status.fdrc1, &rfds1))
366                        {
367                                len = TEMP_FAILURE_RETRY(read(status.fdrc1, &rcdata, sizeof(struct input_event)));
368                                if(rcdata.code  == getrcconfigint("rcpower", NULL))
369                                        rcdata.code =  getrcconfigint("rcfrontpower", NULL);
370                        }
371
372                        if(rcdata.type != EV_KEY)
373                        {
374                                usleep(10000);
375                                continue;
376                        }
377                        if(rcdata.value == 0) //release
378                        {
379                                rcsignal(0);
380#ifdef DREAMBOX
381                                if(longpresscount > 0)
382                                {
383                                        rcdata.code = longpress;
384                                        if(longpresscount > 3) rcdata.code = longpress + 3000;
385                                        ret = rcdata.code;     
386                                        break;
387                                }
388#endif
389                                usleep(10000);
390                                continue;
391                        }
392                        else
393                                rcsignal(1);
394
395                        if(islongkey(rcdata.code))
396                        {
397                                longpress = rcdata.code;
398                                longpresscount++;
399                                timeout = 0;
400#ifdef DREAMBOX
401                                if(longpresscount == 1)
402                                        rest = 700;
403                                else
404                                        rest = 500;
405#else
406                                rest = 500;
407#endif                                                         
408                                usleep(10000);
409                                continue;
410                        }
411                       
412                        gettimeofday(&aktrctime, NULL);
413                        if(status.rcskipms > 0 && ((aktrctime.tv_sec - rcdata.time.tv_sec) * 1000000LL + aktrctime.tv_usec - rcdata.time.tv_usec) > status.rcskipms)
414                        {
415                                usleep(10000);
416                                continue;
417                        }
418                       
419//                      printf(".\n");
420                       
421                        debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value);
422                        treffer = 1;
423                        rcdata.code = maprc(rcdata.code, owner);
424
425                        node = getrc(rcdata.code, owner);
426                        if(node != NULL && node->rcfunc != NULL)
427                        {
428                                if(fromthread == 0)
429                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
430                                else
431                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
432                        }
433                       
434                        ret = rcdata.code;
435#ifdef SIMULATE
436                        if(ret == 16) treffer = 0;
437#endif
438                }
439                else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout
440                {
441                        rcdata.code = 0;
442                        if(longpress > 0)
443                        {
444                                rcdata.code = longpress;
445                                if(longpresscount > 5) rcdata.code = longpress + 3000;
446                        }
447                        treffer = 1;
448                        rcdata.code = maprc(rcdata.code, owner);
449
450                        node = getrc(rcdata.code, NULL);
451                        if(node != NULL && node->rcfunc != NULL)
452                        {
453                                if(fromthread == 0)
454                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
455                                else
456                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
457                        }
458                        if(longpress > 0)
459                                ret = rcdata.code;
460                        else
461                                ret = RCTIMEOUT;
462                }
463                else if(fromthread == 0 && status.rckey != 0)
464                {
465                        treffer = 1;
466                        rcdata.code = maprc(rcdata.code, owner);
467
468                        node = getrc(status.rckey, owner);
469                        if(node != NULL && node->rcfunc != NULL)
470                        {
471                                if(fromthread == 0)
472                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
473                                else
474                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
475                        }
476                        ret = status.rckey;
477                        status.rckey = 0;
478                }
479                else
480                {
481                        treffer = 1;
482                        perr("select failed");
483                }
484        }
485
486        if(ret != RCTIMEOUT)
487                status.lastrcaction = time(NULL);
488        return ret;
489}
490
491int waitrc(struct skin* owner, unsigned int timeout, int screencalc)
492{
493        return waitrcext(owner, timeout, screencalc, 0);
494}
495
496struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
497{
498        struct rc *newnode, *node = rc;
499        struct rc **nodeaddr;
500
501        newnode = (struct rc*)malloc(sizeof(struct rc));       
502        if(newnode == NULL)
503        {
504                err("no memory");
505                return NULL;
506        }
507
508        memset(newnode, 0, sizeof(struct rc));
509        newnode->key = key;
510        newnode->rcfunc = func;
511        newnode->screen = screen;
512        newnode->screennode = screennode;
513        newnode->owner = screen;
514
515        if(node != NULL)
516        {
517                while(node != NULL)
518                {
519                        if(node->key == key && node->owner == screen)
520                        {
521                                node->rcfunc = func;
522                                node->screen = screen;
523                                node->screennode = screennode;
524                                free(newnode);
525                                newnode = NULL;
526                                return node;
527                        }
528                        nodeaddr = &node->next;
529                        node = node->next;
530                }
531                *nodeaddr = newnode;
532        }
533        else
534                rc = newnode;
535
536        return newnode;
537}
538
539void delrc(int key, struct skin* owner, struct skin* screennode)
540{
541        struct rc *node = rc, *prev = rc;
542
543        while(node != NULL)
544        {
545                if(node->key == key && node->owner == owner && node->screennode == screennode)
546                {
547                        if(node == rc)
548                                rc = node->next;
549                        else
550                                prev->next = node->next;
551
552                        free(node);
553                        node = NULL;
554                        break;
555                }
556
557                prev = node;
558                node = node->next;
559        }
560}
561
562void delownerrc(struct skin* owner)
563{
564        struct rc *node = rc, *prev = rc;
565
566        while(node != NULL)
567        {
568                prev = node;
569                node = node->next;
570                if(prev != NULL && prev->owner == owner)
571                        delrc(prev->key, prev->owner, prev->screennode);
572        }
573}
574
575void freerc()
576{
577        struct rc *node = rc, *prev = rc;
578
579        while(node != NULL)
580        {
581                prev = node;
582                node = node->next;
583                if(prev != NULL)
584                        delrc(prev->key, prev->owner, prev->screennode);
585        }
586}
587
588#endif
Note: See TracBrowser for help on using the repository browser.