source: titan/titan/rc.h @ 30760

Last change on this file since 30760 was 29558, checked in by obi, 10 years ago

nemesis fix webif rc

File size: 9.0 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
226int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview)
227{
228        fd_set rfds;
229        struct timeval tv;
230        struct input_event rcdata;
231        int treffer = 0, rest = 0;
232        int ret = 0, len = 0, fromthread = 0, longpress = 0, longpresscount = 0;
233        struct rc *node;
234        struct timeval aktrctime;
235
236        if(pthread_self() != status.mainthread)
237                fromthread = 1;
238
239        rest = timeout % 1000;
240        timeout = (timeout - rest) / 1000;
241
242        if(timeout == 0 && rest == 0) timeout = 0x7fffffff;
243
244        while(treffer == 0)
245        {
246                tv.tv_sec = timeout;
247                tv.tv_usec = rest * 1000;
248                FD_ZERO(&rfds);
249                FD_SET(status.fdrc, &rfds);
250
251                if(fromthread == 0) status.sec = 0;
252                if((fromthread == 0 && status.rckey == 0) || fromthread == 1)
253                {
254                        if(fromthread == 0) m_unlock(&status.waitrcmutex, 24);
255                        ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
256                        if(fromthread == 0) m_lock(&status.waitrcmutex, 24);
257
258                        if((status.rcowner != NULL && status.rcowner != owner) || (status.rcstandby != NULL && status.rcstandby != owner))
259                        {
260                                if(status.rcstandby == NULL || status.rcstandby != owner)
261                                {
262                                        usleep(100000);
263                                        continue;
264                                }
265                        }
266                }
267                if(fromthread == 0) status.sec = time(NULL);
268
269                if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0))
270                {
271                        if(FD_ISSET(status.fdrc, &rfds))
272                                len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
273
274                        if(rcdata.type != EV_KEY)
275                        {
276                                usleep(10000);
277                                continue;
278                        }
279                        if(rcdata.value == 0) //release
280                        {
281                                usleep(10000);
282                                continue;
283                        }
284
285                        if(islongkey(rcdata.code))
286                        {
287                                longpress = rcdata.code;
288                                longpresscount++;
289                                timeout = 0;
290                                rest = 500;
291                                usleep(10000);
292                                continue;
293                        }
294                       
295                        gettimeofday(&aktrctime, NULL);
296                        if(status.rcskipms > 0 && ((aktrctime.tv_sec - rcdata.time.tv_sec) * 1000000LL + aktrctime.tv_usec - rcdata.time.tv_usec) > status.rcskipms)
297                        {
298                                usleep(10000);
299                                continue;
300                        }
301                       
302//                      printf(".\n");
303                       
304                        debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value);
305                        treffer = 1;
306                        rcdata.code = maprc(rcdata.code, owner);
307
308                        node = getrc(rcdata.code, owner);
309                        if(node != NULL && node->rcfunc != NULL)
310                        {
311                                if(fromthread == 0)
312                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
313                                else
314                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
315                        }
316                       
317                        ret = rcdata.code;
318#ifdef SIMULATE
319                        if(ret == 16) treffer = 0;
320#endif
321                }
322                else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout
323                {
324                        rcdata.code = 0;
325                        if(longpress > 0)
326                        {
327                                rcdata.code = longpress;
328                                if(longpresscount > 5) rcdata.code = longpress + 3000;
329                        }
330                        treffer = 1;
331                        rcdata.code = maprc(rcdata.code, owner);
332
333                        node = getrc(rcdata.code, NULL);
334                        if(node != NULL && node->rcfunc != NULL)
335                        {
336                                if(fromthread == 0)
337                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
338                                else
339                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
340                        }
341                        if(longpress > 0)
342                                ret = rcdata.code;
343                        else
344                                ret = RCTIMEOUT;
345                }
346                else if(fromthread == 0 && status.rckey != 0)
347                {
348                        treffer = 1;
349                        rcdata.code = maprc(rcdata.code, owner);
350
351                        node = getrc(status.rckey, owner);
352                        if(node != NULL && node->rcfunc != NULL)
353                        {
354                                if(fromthread == 0)
355                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
356                                else
357                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
358                        }
359                        ret = status.rckey;
360                        status.rckey = 0;
361                }
362                else
363                {
364                        treffer = 1;
365                        perr("select failed");
366                }
367        }
368
369        if(ret != RCTIMEOUT)
370                status.lastrcaction = time(NULL);
371        return ret;
372}
373
374int waitrc(struct skin* owner, unsigned int timeout, int screencalc)
375{
376        return waitrcext(owner, timeout, screencalc, 0);
377}
378
379struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
380{
381        struct rc *newnode, *node = rc;
382        struct rc **nodeaddr;
383
384        newnode = (struct rc*)malloc(sizeof(struct rc));       
385        if(newnode == NULL)
386        {
387                err("no memory");
388                return NULL;
389        }
390
391        memset(newnode, 0, sizeof(struct rc));
392        newnode->key = key;
393        newnode->rcfunc = func;
394        newnode->screen = screen;
395        newnode->screennode = screennode;
396        newnode->owner = screen;
397
398        if(node != NULL)
399        {
400                while(node != NULL)
401                {
402                        if(node->key == key && node->owner == screen)
403                        {
404                                node->rcfunc = func;
405                                node->screen = screen;
406                                node->screennode = screennode;
407                                free(newnode);
408                                newnode = NULL;
409                                return node;
410                        }
411                        nodeaddr = &node->next;
412                        node = node->next;
413                }
414                *nodeaddr = newnode;
415        }
416        else
417                rc = newnode;
418
419        return newnode;
420}
421
422void delrc(int key, struct skin* owner, struct skin* screennode)
423{
424        struct rc *node = rc, *prev = rc;
425
426        while(node != NULL)
427        {
428                if(node->key == key && node->owner == owner && node->screennode == screennode)
429                {
430                        if(node == rc)
431                                rc = node->next;
432                        else
433                                prev->next = node->next;
434
435                        free(node);
436                        node = NULL;
437                        break;
438                }
439
440                prev = node;
441                node = node->next;
442        }
443}
444
445void delownerrc(struct skin* owner)
446{
447        struct rc *node = rc, *prev = rc;
448
449        while(node != NULL)
450        {
451                prev = node;
452                node = node->next;
453                if(prev != NULL && prev->owner == owner)
454                        delrc(prev->key, prev->owner, prev->screennode);
455        }
456}
457
458void freerc()
459{
460        struct rc *node = rc, *prev = rc;
461
462        while(node != NULL)
463        {
464                prev = node;
465                node = node->next;
466                if(prev != NULL)
467                        delrc(prev->key, prev->owner, prev->screennode);
468        }
469}
470
471#endif
Note: See TracBrowser for help on using the repository browser.