code.vuplus.com Git - vuplus_dvbapp/blob - 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=2;  // running but not in poll yet
  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.getTimeOffset();
  49 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
  50         nextActivation += (msek<0 ? 0 : 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.getTimeOffset();
  64 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds);
  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 void eTimer::addTimeOffset( int offset )
 112 {
 113         nextActivation.tv_sec += offset;
 114 }
 115
 116 // mainloop
 117 ePtrList<eMainloop> eMainloop::existing_loops;
 118
 119 eMainloop::~eMainloop()
 120 {
 121         existing_loops.remove(this);
 122         pthread_mutex_destroy(&recalcLock);
 123         for (std::map<int, eSocketNotifier*>::iterator it(notifiers.begin());it != notifiers.end();++it)
 124                 it->second->stop();
 125         while(m_timer_list.begin() != m_timer_list.end())
 126                 m_timer_list.begin()->stop();
 127 }
 128
 129 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
 130 {
 131         int fd = sn->getFD();
 132         ASSERT(notifiers.find(fd) == notifiers.end());
 133         notifiers[fd]=sn;
 134 }
 135
 136 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
 137 {
 138         int fd = sn->getFD();
 139         std::map<int,eSocketNotifier*>::iterator i(notifiers.find(fd));
 140         if (i != notifiers.end())
 141                 return notifiers.erase(i);
 142         eFatal("removed socket notifier which is not present");
 143 }
 144
 145 int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional)
 146 {
 147         int return_reason = 0;
 148                 /* get current time */
 149
 150         if (additional && !PyDict_Check(additional))
 151                 eFatal("additional, but it's not dict");
 152
 153         if (additional && !res)
 154                 eFatal("additional, but no res");
 155
 156         long poll_timeout = -1; /* infinite in case of empty timer list */
 157
 158         if (!m_timer_list.empty() || twisted_timeout > 0)
 159         {
 160                 applyTimeOffset();
 161                 if (!m_timer_list.empty())
 162                 {
 163                         /* process all timers which are ready. first remove them out of the list. */
 164                         while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 )
 165                         {
 166                                 m_timer_list.begin()->activate();
 167                                 applyTimeOffset();
 168                         }
 169                         if (poll_timeout < 0)
 170                                 poll_timeout = 0;
 171                         else /* convert us to ms */
 172                                 poll_timeout /= 1000;
 173                 }
 174         }
 175
 176         if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout))
 177         {
 178                 poll_timeout = twisted_timeout;
 179                 return_reason = 1;
 180         }
 181
 182         int nativecount=notifiers.size(),
 183                 fdcount=nativecount,
 184                 ret=0;
 185
 186         if (additional)
 187                 fdcount += PyDict_Size(additional);
 188
 189                 // build the poll aray
 190         pollfd pfd[fdcount];  // make new pollfd array
 191         std::map<int,eSocketNotifier*>::iterator it = notifiers.begin();
 192         int i=0;
 193         for (; i < nativecount; ++i, ++it)
 194         {
 195                 it->second->state = 1; // running and in poll
 196                 pfd[i].fd = it->first;
 197                 pfd[i].events = it->second->getRequested();
 198         }
 199
 200         if (additional)
 201         {
 202                 PyObject *key, *val;
 203                 int pos=0;
 204                 while (PyDict_Next(additional, &pos, &key, &val)) {
 205                         pfd[i].fd = PyObject_AsFileDescriptor(key);
 206                         pfd[i++].events = PyInt_AsLong(val);
 207                 }
 208         }
 209
 210         m_is_idle = 1;
 211
 212         if (this == eApp)
 213         {
 214                 Py_BEGIN_ALLOW_THREADS
 215                 ret = ::poll(pfd, fdcount, poll_timeout);
 216                 Py_END_ALLOW_THREADS
 217         } else
 218                 ret = ::poll(pfd, fdcount, poll_timeout);
 219
 220         m_is_idle = 0;
 221
 222                         /* ret > 0 means that there are some active poll entries. */
 223         if (ret > 0)
 224         {
 225                 int i=0;
 226                 return_reason = 0;
 227                 for (; i < nativecount; ++i)
 228                 {
 229                         if (pfd[i].revents)
 230                         {
 231                                 it = notifiers.find(pfd[i].fd);
 232                                 if (it != notifiers.end()
 233                                         && it->second->state == 1) // added and in poll
 234                                 {
 235                                         int req = it->second->getRequested();
 236                                         if (pfd[i].revents & req)
 237                                                 it->second->activate(pfd[i].revents & req);
 238                                         pfd[i].revents &= ~req;
 239                                 }
 240                                 if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
 241                                         eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
 242                         }
 243                 }
 244                 for (; i < fdcount; ++i)
 245                 {
 246                         if (pfd[i].revents)
 247                         {
 248                                 if (!*res)
 249                                         *res = PyList_New(0);
 250                                 ePyObject it = PyTuple_New(2);
 251                                 PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
 252                                 PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
 253                                 PyList_Append(*res, it);
 254                                 Py_DECREF(it);
 255                         }
 256                 }
 257         }
 258         else if (ret < 0)
 259         {
 260                         /* when we got a signal, we get EINTR. */
 261                 if (errno != EINTR)
 262                         eDebug("poll made error (%m)");
 263                 else
 264                         return_reason = 2; /* don't assume the timeout has passed when we got a signal */
 265         }
 266
 267         return return_reason;
 268 }
 269
 270 void eMainloop::addTimer(eTimer* e)
 271 {
 272         m_timer_list.insert_in_order(e);
 273 }
 274
 275 void eMainloop::removeTimer(eTimer* e)
 276 {
 277         m_timer_list.remove(e);
 278 }
 279
 280 int eMainloop::iterate(unsigned int twisted_timeout, PyObject **res, ePyObject dict)
 281 {
 282         int ret = 0;
 283
 284         if (twisted_timeout)
 285         {
 286                 gettimeofday(&m_twisted_timer, 0);
 287                 m_twisted_timer += twisted_timeout;
 288         }
 289
 290                 /* TODO: this code just became ugly. fix that. */
 291         do
 292         {
 293                 if (m_interrupt_requested)
 294                 {
 295                         m_interrupt_requested = 0;
 296                         return 0;
 297                 }
 298
 299                 if (app_quit_now)
 300                         return -1;
 301
 302                 int to = 0;
 303                 if (twisted_timeout)
 304                 {
 305                         timeval now, timeout;
 306                         gettimeofday(&now, 0);
 307                         m_twisted_timer += time_offset;  // apply pending offset
 308                         if (m_twisted_timer<=now) // timeout
 309                                 return 0;
 310                         timeout = m_twisted_timer - now;
 311                         to = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
 312                         // remove pending offset .. it is re-applied in next call of processOneEvent.. applyTimeOffset
 313                         m_twisted_timer -= time_offset;
 314                 }
 315                 ret = processOneEvent(to, res, dict);
 316         } while ( !ret && !(res && *res) );
 317
 318         return ret;
 319 }
 320
 321 int eMainloop::runLoop()
 322 {
 323         while (!app_quit_now)
 324                 iterate();
 325         return retval;
 326 }
 327
 328 void eMainloop::reset()
 329 {
 330         app_quit_now=false;
 331 }
 332
 333 PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict)
 334 {
 335         PyObject *res=0;
 336
 337         if (app_quit_now)
 338                 Py_RETURN_NONE;
 339
 340         int twisted_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
 341
 342         iterate(twisted_timeout, &res, dict);
 343         if (res)
 344                 return res;
 345
 346         return PyList_New(0); /* return empty list on timeout */
 347 }
 348
 349 void eMainloop::interruptPoll()
 350 {
 351         m_interrupt_requested = 1;
 352 }
 353
 354 void eMainloop::quit(int ret)
 355 {
 356         retval = ret;
 357         app_quit_now = true;
 358 }
 359
 360 void eMainloop::addTimeOffset(int offset)
 361 {
 362         for (ePtrList<eMainloop>::iterator it(existing_loops.begin()); it != existing_loops.end(); ++it )
 363                 it->addInstanceTimeOffset(offset);
 364 }
 365
 366 void eMainloop::addInstanceTimeOffset(int offset)
 367 {
 368         singleLock s(recalcLock);
 369         if (m_timer_list.empty())
 370                 time_offset=0;
 371         else
 372         {
 373                 if ( time_offset )
 374                         eDebug("time_offset %d avail.. add new offset %d than new is %d",
 375                         time_offset, offset, time_offset+offset);
 376                 time_offset+=offset;
 377         }
 378 }
 379
 380 void eMainloop::applyTimeOffset()
 381 {
 382         singleLock s(recalcLock);
 383         if ( time_offset )
 384         {
 385                 for (ePtrList<eTimer>::iterator it(m_timer_list.begin()); it != m_timer_list.end(); ++it )
 386                         it->addTimeOffset( time_offset );
 387                 m_twisted_timer += time_offset;
 388                 time_offset=0;
 389         }
 390 }
 391
 392 eApplication* eApp = 0;