source: titan/titan/rc.h @ 41542

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

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