source: titan/titan/rc.h @ 13635

Last change on this file since 13635 was 13635, checked in by gost, 12 years ago

[titan] notice RC action

File size: 6.8 KB
Line 
1#ifndef RC_H
2#define RC_H
3
4int openrcsim()
5{
6        status.fdrcsim = -1;
7
8        mkfifo("/tmp/rcsimpipe", 0666);
9        status.fdrcsim = open("/tmp/rcsimpipe", O_RDWR);
10        if(status.fdrcsim < 0)
11        {
12                perr("open or create /tmp/rcsimpipe");
13                return 1;
14        }
15
16        return 0;
17}
18
19int maprc(int rccode, struct skin* owner)
20{
21        if(owner != NULL)
22        {
23                struct rcmap* rcmapnode = getrcmap(owner->name, rccode);
24                if(rcmapnode != NULL)
25                        rccode = rcmapnode->newkey;
26        }
27
28        return rccode;
29}
30
31struct rc* getrc(int key, struct skin* owner)
32{
33        debug(1000, "in");
34        struct rc *node = rc;
35
36        while(node != NULL)
37        {
38                if(node->key == key && node->owner == owner)
39                {
40                        debug(1000, "out");
41                        return node;
42                }
43
44                node = node->next;
45        }
46
47        node = rc;
48
49        while(node != NULL)
50        {
51                if(node->key == key && node->owner == NULL)
52                {
53                        debug(1000, "out");
54                        return node;
55                }
56
57                node = node->next;
58        }
59        return NULL;
60}
61
62int openrc()
63{
64        debug(1000, "in");
65        char *rcdev = NULL;
66        int i = 0;
67
68        status.fdrc = -1;
69
70        rcdev = getconfig("rcdev", NULL);
71        if(rcdev != NULL)
72        {
73                while(status.fdrc < 0 && i < 3)
74                {
75                        status.fdrc = open(rcdev, O_RDONLY);
76                        if(status.fdrc < 0) sleep(1);
77                        i++;
78                }
79
80                if(status.fdrc < 0)
81                {
82                        err("open input device %s", rcdev);
83                        return 1;
84                }
85                closeonexec(status.fdrc);
86        }
87        else
88        {
89                err("input device not found in config");
90                return 1;
91        }
92
93        debug(1000, "out");
94        return 0;
95}
96
97void closerc()
98{
99        debug(1000, "in");
100
101        if(status.fdrc != -1)
102                close(status.fdrc);
103
104        debug(1000, "out");
105}
106
107int islongkey(int keycode)
108{
109        int i = 0;
110
111        for(i = 0; i < MAXLONGKEY; i++)
112        {
113                if(status.longkeycode[i] == keycode)
114                        return 1;
115        }
116        return 0;
117}
118
119int writerc(int keycode)
120{
121        struct input_event rcdata;
122        struct timeval akttime;
123
124        gettimeofday(&akttime, 0);
125       
126        rcdata.time = akttime;
127        rcdata.type = EV_KEY;
128        rcdata.code = keycode;
129        rcdata.value = 1;
130       
131        return  write(status.fdrcsim, &rcdata, sizeof(rcdata));
132}
133
134int waitrc(struct skin* owner, unsigned int timeout, int flag)
135{
136        debug(1000, "in");
137        fd_set rfds;
138        struct timeval tv;
139        struct input_event rcdata;
140        int treffer = 0, rest = 0;
141        int ret = 0, len, fromthread = 0, longpress = 0, longpresscount = 0;
142        struct rc *node;
143
144        if(pthread_self() != status.mainthread)
145                fromthread = 1;
146
147        rest = timeout % 1000;
148        timeout = (timeout - rest) / 1000;
149
150        if(timeout == 0 && rest == 0) timeout = 0x7fffffff;
151
152        while(treffer == 0)
153        {
154                tv.tv_sec = timeout;
155                tv.tv_usec = rest * 1000;
156                FD_ZERO(&rfds);
157                FD_SET(status.fdrc, &rfds);
158                FD_SET(status.fdrcsim, &rfds);
159
160                if(fromthread == 0) status.sec = 0;
161                if((fromthread == 0 && status.rckey == 0) || fromthread == 1)
162                {
163                        ret = TEMP_FAILURE_RETRY(select(status.fdrcsim + 1, &rfds, NULL, NULL, &tv));
164                        if(status.rcowner != NULL && status.rcowner != owner)
165                        {
166                                usleep(100000);
167                                continue;
168                        }
169                }
170                if(fromthread == 0) status.sec = time(NULL);
171
172                if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0))
173                {
174                        if(FD_ISSET(status.fdrc, &rfds))
175                                len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
176                        if(FD_ISSET(status.fdrcsim, &rfds))
177                                len = TEMP_FAILURE_RETRY(read(status.fdrcsim, &rcdata, sizeof(struct input_event)));
178
179                        if(rcdata.type != EV_KEY)
180                        {
181                                usleep(10000);
182                                continue;
183                        }
184                        if(rcdata.value == 0) //release
185                        {
186                                usleep(10000);
187                                continue;
188                        }
189
190                        if(islongkey(rcdata.code))
191                        {
192                                longpress = rcdata.code;
193                                longpresscount++;
194                                timeout = 0;
195                                rest = 500;
196                                usleep(10000);
197                                continue;
198                        }
199
200                        if(time(NULL) - rcdata.time.tv_sec > 1)
201                        {
202                                usleep(10000);
203                                continue;
204                        }
205
206                        debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value);
207                        treffer = 1;
208                        rcdata.code = maprc(rcdata.code, owner);
209
210                        node = getrc(rcdata.code, owner);
211                        if(node != NULL && node->rcfunc != NULL)
212                        {
213                                if(fromthread == 0)
214                                        node->rcfunc(node->screen, node->screennode, 0);
215                                else
216                                        node->rcfunc(node->screen, node->screennode, 2);
217                        }
218                       
219                        ret = rcdata.code;
220#ifdef SIMULATE
221                        if(ret == 16) treffer = 0;
222#endif
223                }
224                else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout
225                {
226                        rcdata.code = 0;
227                        if(longpress > 0)
228                        {
229                                rcdata.code = longpress;
230                                if(longpresscount > 5) rcdata.code = longpress + 3000;
231                        }
232                        treffer = 1;
233                        rcdata.code = maprc(rcdata.code, owner);
234
235                        node = getrc(rcdata.code, NULL);
236                        if(node != NULL && node->rcfunc != NULL)
237                        {
238                                if(fromthread == 0)
239                                        node->rcfunc(node->screen, node->screennode, 0);
240                                else
241                                        node->rcfunc(node->screen, node->screennode, 2);
242                        }
243                        if(longpress > 0)
244                                ret = rcdata.code;
245                        else
246                                ret = RCTIMEOUT;
247                }
248                else if(fromthread == 0 && status.rckey != 0)
249                {
250                        treffer = 1;
251                        rcdata.code = maprc(rcdata.code, owner);
252
253                        node = getrc(status.rckey, owner);
254                        if(node != NULL && node->rcfunc != NULL)
255                        {
256                                if(fromthread == 0)
257                                        node->rcfunc(node->screen, node->screennode, 0);
258                                else
259                                        node->rcfunc(node->screen, node->screennode, 2);
260                        }
261                        ret = status.rckey;
262                        status.rckey = 0;
263                }
264                else
265                {
266                        treffer = 1;
267                        perr("select failed");
268                }
269        }
270
271        debug(1000, "out");
272        status.lastrcaction = time(NULL);
273        return ret;
274}
275
276struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
277{
278        debug(1000, "in");
279        struct rc *newnode, *node = rc;
280        struct rc **nodeaddr;
281
282        newnode = (struct rc*)malloc(sizeof(struct rc));       
283        if(newnode == NULL)
284        {
285                err("no memory");
286                return NULL;
287        }
288
289        memset(newnode, 0, sizeof(struct rc));
290        newnode->key = key;
291        newnode->rcfunc = func;
292        newnode->screen = screen;
293        newnode->screennode = screennode;
294        newnode->owner = screen;
295
296        if(node != NULL)
297        {
298                while(node != NULL)
299                {
300                        if(node->key == key && node->owner == screen)
301                        {
302                                node->rcfunc = func;
303                                node->screen = screen;
304                                node->screennode = screennode;
305                                free(newnode);
306                                newnode = NULL;
307                                debug(1000, "out -> key %d found, use change instread add", key);
308                                return node;
309                        }
310                        nodeaddr = &node->next;
311                        node = node->next;
312                }
313                *nodeaddr = newnode;
314        }
315        else
316                rc = newnode;
317
318        debug(1000, "out");
319        return newnode;
320}
321
322void delrc(int key, struct skin* owner, struct skin* screennode)
323{
324        debug(1000, "in");
325        struct rc *node = rc, *prev = rc;
326
327        while(node != NULL)
328        {
329                if(node->key == key && node->owner == owner && node->screennode == screennode)
330                {
331                        if(node == rc)
332                                rc = node->next;
333                        else
334                                prev->next = node->next;
335
336                        free(node);
337                        node = NULL;
338                        break;
339                }
340
341                prev = node;
342                node = node->next;
343        }
344        debug(1000, "out");
345}
346
347void delownerrc(struct skin* owner)
348{
349        debug(1000, "in");
350        struct rc *node = rc, *prev = rc;
351
352        while(node != NULL)
353        {
354                prev = node;
355                node = node->next;
356                if(prev != NULL && prev->owner == owner)
357                        delrc(prev->key, prev->owner, prev->screennode);
358        }
359        debug(1000, "out");
360}
361
362void freerc()
363{
364        debug(1000, "in");
365        struct rc *node = rc, *prev = rc;
366
367        while(node != NULL)
368        {
369                prev = node;
370                node = node->next;
371                if(prev != NULL)
372                        delrc(prev->key, prev->owner, prev->screennode);
373        }
374        debug(1000, "out");
375}
376
377#endif
Note: See TracBrowser for help on using the repository browser.