19444d20d46e75440023daac6e8c0f75d523f994
[enigma2.git] / lib / base / ebase.cpp
1 #include <lib/base/ebase.h>
2
3 #include <fcntl.h>
4 #include <unistd.h>
5 #include <errno.h>
6
7 #include <lib/base/eerror.h>
8 #include <lib/base/elock.h>
9
10 eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested)
11 {
12         if (startnow)   
13                 start();
14 }
15
16 eSocketNotifier::~eSocketNotifier()
17 {
18         stop();
19 }
20
21 void eSocketNotifier::start()
22 {
23         if (state)
24                 stop();
25
26         context.addSocketNotifier(this);
27         state=1;
28 }
29
30 void eSocketNotifier::stop()
31 {
32         if (state)
33                 context.removeSocketNotifier(this);
34
35         state=0;
36 }
37
38                                         // timer
39 void eTimer::start(long msek, bool singleShot)
40 {
41         if (bActive)
42                 stop();
43
44         bActive = true;
45         bSingleShot = singleShot;
46         interval = msek;
47         gettimeofday(&nextActivation, 0);
48         nextActivation.tv_sec -= context.getTimerOffset();
49         nextActivation += (msek<0 ? 0 : msek);
50 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
51 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
52         context.addTimer(this);
53 }
54
55 void eTimer::startLongTimer( int seconds )
56 {
57         if (bActive)
58                 stop();
59
60         bActive = bSingleShot = true;
61         interval = 0;
62         gettimeofday(&nextActivation, 0);
63         nextActivation.tv_sec -= context.getTimerOffset();
64 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
65         if ( seconds > 0 )
66                 nextActivation.tv_sec += seconds;
67 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
68         context.addTimer(this);
69 }
70
71 void eTimer::stop()
72 {
73         if (bActive)
74         {
75                 bActive=false;
76                 context.removeTimer(this);
77         }
78 }
79
80 void eTimer::changeInterval(long msek)
81 {
82         if (bActive)  // Timer is running?
83         {
84                 context.removeTimer(this);       // then stop
85                 nextActivation -= interval;  // sub old interval
86         }
87         else
88                 bActive=true; // then activate Timer
89
90         interval = msek;                                                // set new Interval
91         nextActivation += interval;             // calc nextActivation
92
93         context.addTimer(this);                         // add Timer to context TimerList
94 }
95
96 void eTimer::activate()   // Internal Funktion... called from eApplication
97 {
98         context.removeTimer(this);
99
100         if (!bSingleShot)
101         {
102                 nextActivation += interval;
103                 context.addTimer(this);
104         }
105         else
106                 bActive=false;
107
108         /*emit*/ timeout();
109 }
110
111 inline void eTimer::recalc( int offset )
112 {
113         nextActivation.tv_sec += offset;
114 }
115
116 // mainloop
117 ePtrList<eMainloop> eMainloop::existing_loops;
118
119 void eMainloop::setTimerOffset( int difference )
120 {
121         singleLock s(recalcLock);
122         if (!TimerList)
123                 timer_offset=0;
124         else
125         {
126                 if ( timer_offset )
127                         eDebug("time_offset %d avail.. add new offset %d than new is %d",
128                         timer_offset, difference, timer_offset+difference);
129                 timer_offset+=difference;
130         }
131 }
132
133 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
134 {
135         notifiers.insert(std::pair<int,eSocketNotifier*> (sn->getFD(), sn));
136 }
137
138 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
139 {
140         notifiers.erase(sn->getFD());
141 }
142
143 void eMainloop::processOneEvent()
144 {
145                 /* notes:
146                   - we should use epoll(4)
147                   - timer are checked twice. there was a strong reason for it, but i can't remember. (FIXME)
148                   - for each time, we gettimeofday() and check wether the timer should fire.
149                     we should do this all better - we know how long the poll last, so we know which
150                     timers should fire. Problem is that a timer handler could have required so
151                     much time that another timer fired.
152
153                     A probably structure could look
154
155                     while (1)
156                     {
157                             time = gettimeofday()
158                             timeout = calculate_pending_timers(time);
159
160                       doPoll(timeout or infinite);
161
162                         if (poll_had_results)
163                                 handle_poll_handler();
164                         else
165                                     fire_timers(time + timeout)
166                           }
167
168                           the gettimeofday() call is required because fire_timers could last more
169                           than nothing.
170
171                           when poll did no timeout, we don't handle timers, as this will be done
172                           in the next iteration (without adding overhead - we had to get the new
173                           time anyway
174                 */
175
176                 // first, process pending timers...
177         long usec=0;
178
179         if ( TimerList )
180                 doRecalcTimers();
181         while (TimerList && (usec = timeout_usec( TimerList.begin()->getNextActivation() ) ) <= 0 )
182         {
183                 TimerList.begin()->activate();
184                 doRecalcTimers();
185         }
186
187         int fdAnz = notifiers.size();
188         pollfd pfd[fdAnz];
189
190 // fill pfd array
191         std::map<int,eSocketNotifier*>::iterator it(notifiers.begin());
192         for (int i=0; i < fdAnz; i++, it++)
193         {
194                 pfd[i].fd = it->first;
195                 pfd[i].events = it->second->getRequested();
196         }
197
198                 // to the poll. When there are no timers, we have an infinite timeout
199         int ret=poll(pfd, fdAnz, TimerList ? usec / 1000 : -1);  // convert to ms
200
201         if (ret>0)
202         {
203         //              eDebug("bin aussem poll raus und da war was");
204                 for (int i=0; i < fdAnz ; i++)
205                 {
206                         if( notifiers.find(pfd[i].fd) == notifiers.end())
207                                 continue;
208
209                         int req = notifiers[pfd[i].fd]->getRequested();
210
211                         if ( pfd[i].revents & req )
212                         {
213                                 notifiers[pfd[i].fd]->activate(pfd[i].revents);
214                                 if (!--ret)
215                                         break;
216                         }
217                         else if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
218                                 eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd,pfd[i].revents);
219                 }
220         }
221         else if (ret<0)
222         {
223                         /* when we got a signal, we get EINTR. we do not care,
224                            because we check current time in timers anyway. */
225                 if (errno != EINTR)
226                         eDebug("poll made error");
227         }
228 }
229
230 int eMainloop::exec()
231 {
232         if (!loop_level)
233         {
234                 app_quit_now = false;
235                 app_exit_loop = false;
236                 enter_loop();
237         }
238         return retval;
239 }
240
241 void eMainloop::enter_loop()
242 {
243         loop_level++;
244         // Status der vorhandenen Loop merken
245         bool old_exit_loop = app_exit_loop;
246
247         app_exit_loop = false;
248
249         while (!app_exit_loop && !app_quit_now)
250                 processOneEvent();
251
252         // wiederherstellen der vorherigen app_exit_loop
253         app_exit_loop = old_exit_loop;
254
255         --loop_level;
256
257         if (!loop_level)
258         {
259                 // do something here on exit the last loop
260         }
261 }
262
263 void eMainloop::exit_loop()  // call this to leave the current loop
264 {
265         app_exit_loop = true;
266 }
267
268 void eMainloop::quit( int ret )   // call this to leave all loops
269 {
270         retval=ret;
271         app_quit_now = true;
272 }
273
274 inline void eMainloop::doRecalcTimers()
275 {
276         singleLock s(recalcLock);
277         if ( timer_offset )
278         {
279                 for (ePtrList<eTimer>::iterator it(TimerList); it != TimerList.end(); ++it )
280                         it->recalc( timer_offset );
281                 timer_offset=0;
282         }
283 }
284
285 eApplication* eApp = 0;