import of enigma2
[enigma2.git] / lib / driver / rc.cpp
1 #include <lib/driver/rc.h>
2
3 #include <asm/types.h>
4 #include <stdio.h>
5 #include <fcntl.h>
6 #include <unistd.h>
7 #include <linux/input.h>
8
9 #include <lib/base/init.h>
10 #include <lib/base/init_num.h>
11 #include <lib/base/econfig.h>
12 #include <lib/base/eerror.h>
13
14 /*
15  *  note on the enigma input layer:
16  *  the enigma input layer (rc*) supports n different devices which
17  *  all have completely different interfaces, mapped down to 32bit + 
18  *  make/break/release codes mapped down (via xml files) to "actions".
19  *  this was necessary to support multiple remote controls with proprietary
20  *  interfaces. now everybody is using input devices, and thus adding
21  *  another input layer seems to be a bit overkill. BUT:
22  *  image a remote control with two hundred buttons. each and every function
23  *  in enigma can be bound to a button. no need to use them twice. 
24  *  for example, you would have KEY_MENU assigned to a menu for setup etc.,
25  *  but no audio and video settings, since you have special keys for that,
26  *  and you don't want to display a big menu with entries that are available
27  *  with another single key.
28  *  then image a remote control with ten buttons. do you really want to waste
29  *  KEY_MENU for a simple menu? you need the audio/video settings there too.
30  *  take this just as a (bad) example. another (better) example might be front-
31  *  button-keys. usually you have KEY_UP, KEY_DOWN, KEY_POWER. you don't want
32  *  them to behave like the remote-control-KEY_UP, KEY_DOWN and KEY_POWER,
33  *  don't you? 
34  *  so here we can map same keys of different input devices to different 
35  *  actions. have fun.
36  */
37
38 int eRCDevice::getKeyCompatibleCode(const eRCKey &) const
39 {
40         return -1;
41 }
42
43 eRCDevice::eRCDevice(eString id, eRCDriver *driver): driver(driver), id(id)
44 {
45         input=driver->getInput();
46         driver->addCodeListener(this);
47         eRCInput::getInstance()->addDevice(id, this);
48 }
49
50 eRCDevice::~eRCDevice()
51 {
52         driver->removeCodeListener(this);
53         eRCInput::getInstance()->removeDevice(id.c_str());
54 }
55
56 eRCDriver::eRCDriver(eRCInput *input): input(input), enabled(1)
57 {
58 }
59
60 eRCDriver::~eRCDriver()
61 {
62         for (std::list<eRCDevice*>::iterator i=listeners.begin(); i!=listeners.end(); ++i)
63                 delete *i;
64 }
65
66 void eRCShortDriver::keyPressed(int)
67 {
68         __u16 rccode;
69         while (1)
70         {
71                 if (read(handle, &rccode, 2)!=2)
72                         break;
73                 if (enabled && !input->islocked())
74                         for (std::list<eRCDevice*>::iterator i(listeners.begin()); i!=listeners.end(); ++i)
75                                 (*i)->handleCode(rccode);
76         }
77 }
78
79 eRCShortDriver::eRCShortDriver(const char *filename): eRCDriver(eRCInput::getInstance())
80 {
81         handle=open(filename, O_RDONLY|O_NONBLOCK);
82         if (handle<0)
83         {
84                 eDebug("failed to open %s", filename);
85                 sn=0;
86         } else
87         {
88                 sn=new eSocketNotifier(eApp, handle, eSocketNotifier::Read);
89                 CONNECT(sn->activated, eRCShortDriver::keyPressed);
90                 eRCInput::getInstance()->setFile(handle);
91         }
92 }
93
94 eRCShortDriver::~eRCShortDriver()
95 {
96         if (handle>=0)
97                 close(handle);
98         if (sn)
99                 delete sn;
100 }
101
102 void eRCInputEventDriver::keyPressed(int)
103 {
104         struct input_event ev;
105         while (1)
106         {
107                 if (read(handle, &ev, sizeof(struct input_event))!=sizeof(struct input_event))
108                         break;
109                 if (enabled && !input->islocked())
110                         for (std::list<eRCDevice*>::iterator i(listeners.begin()); i!=listeners.end(); ++i)
111                                 (*i)->handleCode((int)&ev);
112         }
113 }
114
115 eRCInputEventDriver::eRCInputEventDriver(const char *filename): eRCDriver(eRCInput::getInstance())
116 {
117         handle=open(filename, O_RDONLY|O_NONBLOCK);
118         if (handle<0)
119         {
120                 eDebug("failed to open %s", filename);
121                 sn=0;
122         } else
123         {
124                 sn=new eSocketNotifier(eApp, handle, eSocketNotifier::Read);
125                 CONNECT(sn->activated, eRCInputEventDriver::keyPressed);
126                 eRCInput::getInstance()->setFile(handle);
127         }
128 }
129
130 eString eRCInputEventDriver::getDeviceName()
131 {
132         char name[128]="";
133         if (handle >= 0)
134                 ::ioctl(handle, EVIOCGNAME(128), name);
135         return name;
136 }
137
138 eRCInputEventDriver::~eRCInputEventDriver()
139 {
140         if (handle>=0)
141                 close(handle);
142         if (sn)
143                 delete sn;
144 }
145
146 eRCConfig::eRCConfig()
147 {
148         reload();
149 }
150
151 eRCConfig::~eRCConfig()
152 {
153         save();
154 }
155
156 void eRCConfig::set( int delay, int repeat )
157 {
158         rdelay = delay;
159         rrate = repeat;
160 }
161
162 void eRCConfig::reload()
163 {
164         rdelay=500;
165         rrate=100;
166         if ( eConfig::getInstance()->getKey("/ezap/rc/repeatRate", rrate) )
167                 save();
168         eConfig::getInstance()->getKey("/ezap/rc/repeatDelay", rdelay);
169 }
170
171 void eRCConfig::save()
172 {
173         eConfig::getInstance()->setKey("/ezap/rc/repeatRate", rrate);
174         eConfig::getInstance()->setKey("/ezap/rc/repeatDelay", rdelay);
175 }
176
177 eRCInput *eRCInput::instance;
178
179 eRCInput::eRCInput()
180 {
181         ASSERT( !instance);
182         instance=this;
183         handle = -1;
184         locked = 0;
185 }
186
187 eRCInput::~eRCInput()
188 {
189 }
190
191 void eRCInput::close()
192 {
193 }
194
195 bool eRCInput::open()
196 {
197         return false;
198 }
199
200 int eRCInput::lock()
201 {
202         locked=1;
203         return handle;
204 }
205
206 void eRCInput::unlock()
207 {
208         if (locked)
209                 locked=0;
210 }
211
212 void eRCInput::setFile(int newh)
213 {
214         handle=newh;
215 }
216
217 void eRCInput::addDevice(const eString &id, eRCDevice *dev)
218 {
219         devices.insert(std::pair<eString,eRCDevice*>(id, dev));
220 }
221
222 void eRCInput::removeDevice(const eString &id)
223 {
224         devices.erase(id);
225 }
226
227 eRCDevice *eRCInput::getDevice(const eString &id)
228 {
229         std::map<eString,eRCDevice*>::iterator i=devices.find(id);
230         if (i == devices.end())
231         {
232                 eDebug("failed, possible choices are:");
233                 for (std::map<eString,eRCDevice*>::iterator i=devices.begin(); i != devices.end(); ++i) 
234                         eDebug("%s", i->first.c_str());
235                 return 0;
236         }
237         return i->second;
238 }
239
240 std::map<eString,eRCDevice*,eRCInput::lstr> &eRCInput::getDevices()
241 {
242         return devices;
243 }
244
245 eAutoInitP0<eRCInput> init_rcinput(eAutoInitNumbers::rc, "RC Input layer");