X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fbase%2Febase.cpp;h=6efbf90b17346d6d60c5612db18720552900d463;hp=3babc2eb19358250f4de15abd2aa39bf85621dda;hb=6d87184b8fa7ebe005e5ba19fb311b9e505a72f8;hpb=d63d2c3c6cbbd574dda4f8b00ebe6c661735edd5 diff --git a/lib/base/ebase.cpp b/lib/base/ebase.cpp index 3babc2e..6efbf90 100644 --- a/lib/base/ebase.cpp +++ b/lib/base/ebase.cpp @@ -2,8 +2,10 @@ #include #include +#include #include +#include eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested) { @@ -22,7 +24,7 @@ void eSocketNotifier::start() stop(); context.addSocketNotifier(this); - state=1; + state=2; // running but not in poll yet } void eSocketNotifier::stop() @@ -42,13 +44,28 @@ void eTimer::start(long msek, bool singleShot) bActive = true; bSingleShot = singleShot; interval = msek; - gettimeofday(&nextActivation, 0); + gettimeofday(&nextActivation, 0); // eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek); nextActivation += (msek<0 ? 0 : msek); // eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec ); context.addTimer(this); } +void eTimer::startLongTimer( int seconds ) +{ + if (bActive) + stop(); + + bActive = bSingleShot = true; + interval = 0; + gettimeofday(&nextActivation, 0); +// eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds); + if ( seconds > 0 ) + nextActivation.tv_sec += seconds; +// eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec ); + context.addTimer(this); +} + void eTimer::stop() { if (bActive) @@ -66,7 +83,7 @@ void eTimer::changeInterval(long msek) nextActivation -= interval; // sub old interval } else - bActive=true; // then activate Timer + bActive=true; // then activate Timer interval = msek; // set new Interval nextActivation += interval; // calc nextActivation @@ -76,10 +93,6 @@ void eTimer::changeInterval(long msek) void eTimer::activate() // Internal Funktion... called from eApplication { - timeval now; - gettimeofday(&now, 0); -// 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 ); -// eDebug("Timer emitted"); context.removeTimer(this); if (!bSingleShot) @@ -93,114 +106,257 @@ void eTimer::activate() // Internal Funktion... called from eApplication /*emit*/ timeout(); } +void eTimer::addTimeOffset( int offset ) +{ + nextActivation.tv_sec += offset; +} + // mainloop +ePtrList eMainloop::existing_loops; void eMainloop::addSocketNotifier(eSocketNotifier *sn) { - notifiers.insert(std::pair (sn->getFD(), sn)); + int fd = sn->getFD(); + ASSERT(notifiers.find(fd) == notifiers.end()); + notifiers[fd]=sn; } void eMainloop::removeSocketNotifier(eSocketNotifier *sn) { - notifiers.erase(sn->getFD()); + int fd = sn->getFD(); + std::map::iterator i(notifiers.find(fd)); + if (i != notifiers.end()) + return notifiers.erase(i); + eFatal("removed socket notifier which is not present"); } -void eMainloop::processOneEvent() +int eMainloop::processOneEvent(unsigned int user_timeout, PyObject **res, ePyObject additional) { -// process pending timers... - long usec=0; - - while (TimerList && (usec = timeout_usec( TimerList.begin()->getNextActivation() ) ) <= 0 ) - TimerList.begin()->activate(); - - int fdAnz = notifiers.size(); - pollfd* pfd = new pollfd[fdAnz]; // make new pollfd array + int return_reason = 0; + /* get current time */ + timeval now; + gettimeofday(&now, 0); + m_now_is_invalid = 0; + + if (additional && !PyDict_Check(additional)) + eFatal("additional, but it's not dict"); + + if (additional && !res) + eFatal("additional, but no res"); + + int poll_timeout = -1; /* infinite in case of empty timer list */ + + if (m_timer_list) + { + singleLock s(recalcLock); + poll_timeout = timeval_to_usec(m_timer_list.begin()->getNextActivation() - now); + /* if current timer already passed, don't delay infinite. */ + if (poll_timeout < 0) + poll_timeout = 0; + else /* convert us to ms */ + poll_timeout /= 1000; + } + + if ((user_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > user_timeout)) + { + poll_timeout = user_timeout; + return_reason = 1; + } -// fill pfd array - std::map::iterator it(notifiers.begin()); - for (int i=0; i < fdAnz; i++, it++) + int nativecount=notifiers.size(), + fdcount=nativecount, + ret=0; + + if (additional) + fdcount += PyDict_Size(additional); + + // build the poll aray + pollfd pfd[fdcount]; // make new pollfd array + std::map::iterator it = notifiers.begin(); + int i=0; + for (; i < nativecount; ++i, ++it) { + it->second->state = 1; // running and in poll pfd[i].fd = it->first; pfd[i].events = it->second->getRequested(); } + + if (additional) + { + PyObject *key, *val; + int pos=0; + while (PyDict_Next(additional, &pos, &key, &val)) { + pfd[i].fd = PyObject_AsFileDescriptor(key); + pfd[i++].events = PyInt_AsLong(val); + } + } - int ret=poll(pfd, fdAnz, TimerList ? usec / 1000 : -1); // milli .. not micro seks + if (this == eApp) + Py_BEGIN_ALLOW_THREADS + ret = ::poll(pfd, fdcount, poll_timeout); + Py_END_ALLOW_THREADS + else + ret = ::poll(pfd, fdcount, poll_timeout); - if (ret>0) + /* ret > 0 means that there are some active poll entries. */ + if (ret > 0) { -// eDebug("bin aussem poll raus und da war was"); - for (int i=0; i < fdAnz ; i++) + int i=0; + return_reason = 0; + for (; i < nativecount; ++i) { - if( notifiers.find(pfd[i].fd) == notifiers.end()) - continue; - - int req = notifiers[pfd[i].fd]->getRequested(); - - if ( pfd[i].revents & req ) + if (pfd[i].revents) { - notifiers[pfd[i].fd]->activate(pfd[i].revents); - - if (!--ret) - break; - } else if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL)) - eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd,pfd[i].revents); + it = notifiers.find(pfd[i].fd); + if (it != notifiers.end() + && it->second->state == 1) // added and in poll + { + int req = it->second->getRequested(); + if (pfd[i].revents & req) + it->second->activate(pfd[i].revents & req); + pfd[i].revents &= ~req; + } + if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL)) + eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents); + } } + for (; i < fdcount; ++i) + { + if (pfd[i].revents) + { + if (!*res) + *res = PyList_New(0); + ePyObject it = PyTuple_New(2); + PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd)); + PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents)); + PyList_Append(*res, it); + Py_DECREF(it); + } + } + } + else if (ret < 0) + { + /* when we got a signal, we get EINTR. */ + if (errno != EINTR) + eDebug("poll made error (%m)"); + else + return_reason = 2; /* don't assume the timeout has passed when we got a signal */ } - else if (ret<0) - eDebug("poll made error"); + + /* when we not processed anything, check timers. */ + if (!m_timer_list.empty()) + { + /* we know that this time has passed. */ + singleLock s(recalcLock); - // check Timers... - while ( TimerList && timeout_usec( TimerList.begin()->getNextActivation() ) <= 0 ) - TimerList.begin()->activate(); + if (ret || m_now_is_invalid) + gettimeofday(&now, 0); + else // poll timeoutet + now += poll_timeout; - delete [] pfd; + /* process all timers which are ready. first remove them out of the list. */ + while ((!m_timer_list.empty()) && (m_timer_list.begin()->getNextActivation() <= now)) + m_timer_list.begin()->activate(); + } + + return return_reason; } +void eMainloop::addTimer(eTimer* e) +{ + m_timer_list.insert_in_order(e); +} -int eMainloop::exec() +void eMainloop::removeTimer(eTimer* e) { - if (!loop_level) - { - app_quit_now = false; - enter_loop(); - } - return retval; + m_timer_list.remove(e); } -void eMainloop::enter_loop() +int eMainloop::iterate(unsigned int user_timeout, PyObject **res, ePyObject dict) { - loop_level++; + int ret = 0; - // Status der vorhandenen Loop merken - bool old_exit_loop = app_exit_loop; - - app_exit_loop = false; + timeval user_timer; + gettimeofday(&user_timer, 0); + user_timer += user_timeout; - while (!app_exit_loop && !app_quit_now) + /* TODO: this code just became ugly. fix that. */ + do { - processOneEvent(); - } + if (m_interrupt_requested) + { + m_interrupt_requested = 0; + return 0; + } - // wiederherstellen der vorherigen app_exit_loop - app_exit_loop = old_exit_loop; + if (app_quit_now) + return -1; - loop_level--; + int to = 0; + if (user_timeout) + { + timeval now, timeout; + gettimeofday(&now, 0); + if (user_timer<=now) // timeout + return 0; + timeout = user_timer - now; + to = timeout.tv_sec * 1000 + timeout.tv_usec / 1000; + } + ret = processOneEvent(to, res, dict); + } while ( !ret && !(res && *res) ); + + return ret; +} - if (!loop_level) - { - // do something here on exit the last loop - } +int eMainloop::runLoop() +{ + while (!app_quit_now) + iterate(); + return retval; +} + +void eMainloop::reset() +{ + app_quit_now=false; } -void eMainloop::exit_loop() // call this to leave the current loop +PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict) { - app_exit_loop = true; + PyObject *res=0; + + if (app_quit_now) + Py_RETURN_NONE; + + int user_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout); + + iterate(user_timeout, &res, dict); + if (res) + return res; + + return PyList_New(0); /* return empty list on timeout */ } -void eMainloop::quit( int ret ) // call this to leave all loops +void eMainloop::interruptPoll() { - retval=ret; + m_interrupt_requested = 1; +} + +void eMainloop::quit(int ret) +{ + retval = ret; app_quit_now = true; } +void eMainloop::addTimeOffset(int offset) +{ + for (ePtrList::iterator it(eMainloop::existing_loops) + ;it != eMainloop::existing_loops.end(); ++it) + { + singleLock s(it->recalcLock); + it->m_now_is_invalid = 1; + for (ePtrList::iterator tit = it->m_timer_list.begin(); tit != it->m_timer_list.end(); ++tit ) + tit->addTimeOffset(offset); + } +} + eApplication* eApp = 0;