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