source: titan/titan/rc.h @ 39803

Last change on this file since 39803 was 39803, checked in by gost, 7 years ago

[titan] fix pip long press
File size: 9.9 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
110        rcdev = getconfig("rcdev", NULL);
111        if(rcdev != NULL)
112        {
113                while(status.fdrc < 0 && i < 3)
114                {
115                        status.fdrc = open(rcdev, O_RDWR);
116                        if(status.fdrc < 0) sleep(1);
117                        i++;
118                }
119
120                if(status.fdrc < 0)
121                {
122                        err("open input device %s", rcdev);
123                        return 1;
124                }
125                closeonexec(status.fdrc);
126        }
127        else
128        {
129                err("input device not found in config");
130                return 1;
131        }
132
133        return 0;
134}
135
136void closerc()
137{
138        if(status.fdrc != -1)
139                close(status.fdrc);
140}
141
142int islongkey(int keycode)
143{
144        int i = 0;
145
146        for(i = 0; i < MAXLONGKEY; i++)
147        {
148                if(status.longkeycode[i] == keycode)
149                        return 1;
150        }
151        return 0;
152}
153
154int writerc(int keycode)
155{
156        int ret = 0;
157        struct input_event rcdata;
158        struct timeval akttime;
159
160        gettimeofday(&akttime, 0);
161        sendtuxtxt(keycode);
162
163        rcdata.time = akttime;
164        rcdata.type = EV_KEY;
165        rcdata.code = keycode;
166        rcdata.value = 1;
167        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
168
169#ifdef MIPSEL   
170        rcdata.time = akttime;
171        rcdata.type = 0;
172        rcdata.code = 0;
173        rcdata.value = 0;
174        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
175#endif
176
177        rcdata.time = akttime;
178        rcdata.type = EV_KEY;
179        rcdata.code = keycode;
180        rcdata.value = 0;
181        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
182
183#ifdef MIPSEL   
184        rcdata.time = akttime;
185        rcdata.type = 0;
186        rcdata.code = 0;
187        rcdata.value = 0;
188        ret = write(status.fdrc, &rcdata, sizeof(rcdata));
189#endif
190       
191        return ret;
192}
193
194int flushrc(unsigned int timeout)
195{
196        fd_set rfds;
197        struct timeval tv;
198        struct input_event rcdata;
199        int rest = 0, count = 0;
200        int ret = 0, len = 0;
201
202        rest = timeout % 1000;
203        timeout = (timeout - rest) / 1000;
204
205        while(count < 10)
206        {
207                count++;
208                tv.tv_sec = timeout;
209                tv.tv_usec = rest * 1000;
210                FD_ZERO(&rfds);
211                FD_SET(status.fdrc, &rfds);
212
213                ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
214
215                if(ret < 1) break;
216                if(FD_ISSET(status.fdrc, &rfds))
217                {
218                        count = 0;
219                        len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
220                }
221        }
222
223        return 0;
224}
225
226void rcsignal(int flag)
227{
228        if(checkbox("DM900") == 1 && status.standby == 0)
229        {
230                int art = getconfigint("dm900frontrun", NULL);
231                if(flag == 1)
232                {
233                        if(art == 0)
234                                writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1);
235                        else if(art == 1)
236                                writesys("/proc/stb/fp/led0_pattern", "ffffffff", 1);
237                        else if(art == 2)       
238                                writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1);
239                }
240                if(flag == 0)
241                {
242                        if(art == 0)
243                                writesys("/proc/stb/fp/led1_pattern", "00000000", 1);
244                        else if(art == 1)
245                                writesys("/proc/stb/fp/led0_pattern", "00000000", 1);
246                        else if(art == 2)       
247                                writesys("/proc/stb/fp/led1_pattern", "00000000", 1);
248                }
249        }
250}       
251
252int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview)
253{
254        fd_set rfds;
255        struct timeval tv;
256        struct input_event rcdata;
257        int treffer = 0, rest = 0;
258        int ret = 0, len = 0, fromthread = 0, longpress = 0, longpresscount = 0;
259        struct rc *node;
260        struct timeval aktrctime;
261
262        if(pthread_self() != status.mainthread)
263                fromthread = 1;
264
265        rest = timeout % 1000;
266        timeout = (timeout - rest) / 1000;
267
268        if(timeout == 0 && rest == 0) timeout = 0x7fffffff;
269
270        while(treffer == 0)
271        {
272                tv.tv_sec = timeout;
273                tv.tv_usec = rest * 1000;
274                FD_ZERO(&rfds);
275                FD_SET(status.fdrc, &rfds);
276
277                if(fromthread == 0) status.sec = 0;
278                if((fromthread == 0 && status.rckey == 0) || fromthread == 1)
279                {
280                        if(fromthread == 0) m_unlock(&status.waitrcmutex, 24);
281                        ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
282                        if(fromthread == 0) m_lock(&status.waitrcmutex, 24);
283
284                        if((status.rcowner != NULL && status.rcowner != owner) || (status.rcstandby != NULL && status.rcstandby != owner))
285                        {
286                                if(status.rcstandby == NULL || status.rcstandby != owner)
287                                {
288                                        usleep(100000);
289                                        continue;
290                                }
291                        }
292                }
293                if(fromthread == 0) status.sec = time(NULL);
294
295                if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0))
296                {
297                        if(FD_ISSET(status.fdrc, &rfds))
298                                len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
299
300                        if(rcdata.type != EV_KEY)
301                        {
302                                usleep(10000);
303                                continue;
304                        }
305                        if(rcdata.value == 0) //release
306                        {
307                                rcsignal(0);
308#ifdef DREAMBOX
309                                if(longpresscount > 0)
310                                {
311                                        rcdata.code = longpress;
312                                        if(longpresscount > 3) rcdata.code = longpress + 3000;
313                                        ret = rcdata.code;     
314                                        break;
315                                }
316#endif
317                                usleep(10000);
318                                continue;
319                        }
320                        else
321                                rcsignal(1);
322
323                        if(islongkey(rcdata.code))
324                        {
325                                longpress = rcdata.code;
326                                longpresscount++;
327                                timeout = 0;
328#ifdef DREAMBOX
329                                if(longpresscount == 1)
330                                        rest = 700;
331                                else
332                                        rest = 500;
333#else
334                                rest = 500;
335#endif                                                         
336                                usleep(10000);
337                                continue;
338                        }
339                       
340                        gettimeofday(&aktrctime, NULL);
341                        if(status.rcskipms > 0 && ((aktrctime.tv_sec - rcdata.time.tv_sec) * 1000000LL + aktrctime.tv_usec - rcdata.time.tv_usec) > status.rcskipms)
342                        {
343                                usleep(10000);
344                                continue;
345                        }
346                       
347//                      printf(".\n");
348                       
349                        debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value);
350                        treffer = 1;
351                        rcdata.code = maprc(rcdata.code, owner);
352
353                        node = getrc(rcdata.code, owner);
354                        if(node != NULL && node->rcfunc != NULL)
355                        {
356                                if(fromthread == 0)
357                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
358                                else
359                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
360                        }
361                       
362                        ret = rcdata.code;
363#ifdef SIMULATE
364                        if(ret == 16) treffer = 0;
365#endif
366                }
367                else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout
368                {
369                        rcdata.code = 0;
370                        if(longpress > 0)
371                        {
372                                rcdata.code = longpress;
373                                if(longpresscount > 5) rcdata.code = longpress + 3000;
374                        }
375                        treffer = 1;
376                        rcdata.code = maprc(rcdata.code, owner);
377
378                        node = getrc(rcdata.code, NULL);
379                        if(node != NULL && node->rcfunc != NULL)
380                        {
381                                if(fromthread == 0)
382                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
383                                else
384                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
385                        }
386                        if(longpress > 0)
387                                ret = rcdata.code;
388                        else
389                                ret = RCTIMEOUT;
390                }
391                else if(fromthread == 0 && status.rckey != 0)
392                {
393                        treffer = 1;
394                        rcdata.code = maprc(rcdata.code, owner);
395
396                        node = getrc(status.rckey, owner);
397                        if(node != NULL && node->rcfunc != NULL)
398                        {
399                                if(fromthread == 0)
400                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
401                                else
402                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
403                        }
404                        ret = status.rckey;
405                        status.rckey = 0;
406                }
407                else
408                {
409                        treffer = 1;
410                        perr("select failed");
411                }
412        }
413
414        if(ret != RCTIMEOUT)
415                status.lastrcaction = time(NULL);
416        return ret;
417}
418
419int waitrc(struct skin* owner, unsigned int timeout, int screencalc)
420{
421        return waitrcext(owner, timeout, screencalc, 0);
422}
423
424struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
425{
426        struct rc *newnode, *node = rc;
427        struct rc **nodeaddr;
428
429        newnode = (struct rc*)malloc(sizeof(struct rc));       
430        if(newnode == NULL)
431        {
432                err("no memory");
433                return NULL;
434        }
435
436        memset(newnode, 0, sizeof(struct rc));
437        newnode->key = key;
438        newnode->rcfunc = func;
439        newnode->screen = screen;
440        newnode->screennode = screennode;
441        newnode->owner = screen;
442
443        if(node != NULL)
444        {
445                while(node != NULL)
446                {
447                        if(node->key == key && node->owner == screen)
448                        {
449                                node->rcfunc = func;
450                                node->screen = screen;
451                                node->screennode = screennode;
452                                free(newnode);
453                                newnode = NULL;
454                                return node;
455                        }
456                        nodeaddr = &node->next;
457                        node = node->next;
458                }
459                *nodeaddr = newnode;
460        }
461        else
462                rc = newnode;
463
464        return newnode;
465}
466
467void delrc(int key, struct skin* owner, struct skin* screennode)
468{
469        struct rc *node = rc, *prev = rc;
470
471        while(node != NULL)
472        {
473                if(node->key == key && node->owner == owner && node->screennode == screennode)
474                {
475                        if(node == rc)
476                                rc = node->next;
477                        else
478                                prev->next = node->next;
479
480                        free(node);
481                        node = NULL;
482                        break;
483                }
484
485                prev = node;
486                node = node->next;
487        }
488}
489
490void delownerrc(struct skin* owner)
491{
492        struct rc *node = rc, *prev = rc;
493
494        while(node != NULL)
495        {
496                prev = node;
497                node = node->next;
498                if(prev != NULL && prev->owner == owner)
499                        delrc(prev->key, prev->owner, prev->screennode);
500        }
501}
502
503void freerc()
504{
505        struct rc *node = rc, *prev = rc;
506
507        while(node != NULL)
508        {
509                prev = node;
510                node = node->next;
511                if(prev != NULL)
512                        delrc(prev->key, prev->owner, prev->screennode);
513        }
514}
515
516#endif
Note: See TracBrowser for help on using the repository browser.