source: titan/titan/rc.h @ 39988

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

[titan] activate front buttons for some devices

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