non blocking diseqc and sec stuff
[enigma2.git] / lib / driver / rc.h
1 #ifndef __rc_h
2 #define __rc_h
3
4 #include <list>
5 #include <map>
6
7 #include <lib/base/ebase.h>
8 #include <libsig_comp.h>
9 #include <string>
10
11 class eRCInput;
12 class eRCDriver;
13 class eRCKey;
14
15 /**
16  * \brief A remote control.
17  *
18  * Handles one remote control. Gets codes from a \ref eRCDriver. Produces events in \ref eRCInput.
19  */
20 class eRCDevice: public Object
21 {
22 protected:
23         eRCInput *input;
24         eRCDriver *driver;
25         std::string id;
26 public:
27         /**
28          * \brief Constructs a new remote control.
29          *
30          * \param id The identifier of the RC, for use in settings.
31          * \param input The \ref eRCDriver where this remote gets its codes from.
32          */
33         eRCDevice(std::string id, eRCDriver *input);
34         ~eRCDevice();
35         /**
36          * \brief Handles a device specific code.
37          *
38          * Generates events in \ref eRCInput. code is highly device- and driver dependant.
39          * For Example, it might be 16bit codes with one bit make/break or special codes
40          * for repeat.
41          */
42         virtual void handleCode(int code)=0;
43         /**
44          * \brief Get user readable description.
45          * \result The description.
46          */
47         virtual const char *getDescription() const=0;
48         const std::string getIdentifier() const { return id; }
49         /**
50          * \brief Get a description for a specific key.
51          * \param key The key to get the description for.
52          * \result User readable description of given key.
53          */
54 };
55
56 /**
57  * Receives codes from one or more remote controls.
58  */
59 class eRCDriver: public Object
60 {
61 protected:
62         std::list<eRCDevice*> listeners;
63         eRCInput *input;
64         int enabled;
65 public:
66         /**
67          * \brief Constructs a driver.
68          *
69          * \param input The RCInput to bind this driver to.
70          */
71         eRCDriver(eRCInput *input);
72         /**
73          * \brief Get pointer to key-consumer.
74          */
75         eRCInput *getInput() const { return input; }
76         /**
77          * \brief Adds a code lister
78          */
79         void addCodeListener(eRCDevice *dev)
80         {
81                 listeners.push_back(dev);
82         }
83         void removeCodeListener(eRCDevice *dev)
84         {
85                 listeners.remove(dev);
86         }
87         ~eRCDriver();
88         
89         void enable(int en) { enabled=en; }
90 };
91
92 class eRCShortDriver: public eRCDriver
93 {
94 protected:
95         int handle;
96         eSocketNotifier *sn;
97         void keyPressed(int);
98 public:
99         eRCShortDriver(const char *filename);
100         ~eRCShortDriver();
101 };
102
103 class eRCInputEventDriver: public eRCDriver
104 {
105 protected:
106         int handle;
107         eSocketNotifier *sn;
108         void keyPressed(int);
109 public:
110         std::string getDeviceName();
111         eRCInputEventDriver(const char *filename);
112         ~eRCInputEventDriver();
113 };
114
115 class eRCKey
116 {
117 public:
118         eRCDevice *producer;
119         int code, flags;
120
121         eRCKey(eRCDevice *producer, int code, int flags): 
122                 producer(producer), code(code), flags(flags)
123         {
124         }
125         enum
126         {
127                 flagBreak=1,
128                 flagRepeat=2
129         };
130         
131         bool operator<(const eRCKey &r) const
132         {
133                 if (r.producer == producer)
134                 {
135                         if (r.code == code)
136                         {
137                                 if (r.flags < flags)
138                                         return 1;
139                                 else
140                                         return 0;
141                         } else if (r.code < code)
142                                 return 1;
143                         else
144                                 return 0;
145                 } else if (r.producer < producer)
146                         return 1;
147                 else
148                         return 0;
149         }
150 };
151
152 class eRCConfig
153 {
154 public:
155         eRCConfig();
156         ~eRCConfig();
157         void reload();
158         void save();
159         void set(int delay, int repeat);
160         int rdelay, // keypress delay after first keypress to begin of repeat (in ms)
161                 rrate;          // repeat rate (in ms)
162 };
163
164 class eRCInput: public Object
165 {
166         int locked;     
167         int handle;
168         static eRCInput *instance;
169
170 public:
171         struct lstr
172         {
173                 bool operator()(const std::string &a, const std::string &b) const
174                 {
175                         return a<b;
176                 }
177         };
178 protected:
179         std::map<std::string,eRCDevice*,lstr> devices;
180 public:
181         Signal1<void, const eRCKey&> keyEvent;
182         eRCInput();
183         ~eRCInput();
184         
185         int lock();
186         void unlock();
187         int islocked() { return locked; }
188         void close();
189         bool open();
190
191         void setFile(int handle);
192
193         void keyPressed(const eRCKey &key)
194         {
195                 /*emit*/ keyEvent(key);
196         }
197         
198         void addDevice(const std::string &id, eRCDevice *dev);
199         void removeDevice(const std::string &id);
200         eRCDevice *getDevice(const std::string &id);
201         std::map<std::string,eRCDevice*,lstr> &getDevices();
202         
203         static eRCInput *getInstance() { return instance; }
204         
205         eRCConfig config;
206 };
207
208 #endif