bool SimpleEventQueue::postTimedEvent(const sp<Event>& event, int64_t realtime_us)
{
Mutex::Autolock _l(mLock);
List<QueueItem>::iterator iter = mQueue.begin();
while (iter != mQueue.end() && realtime_us >= iter->realtime_us) {
++iter;
}
QueueItem item;
item.event = event;
item.realtime_us = realtime_us;//getRealTimeUs();
item.has_wakelock = false;
if (iter == mQueue.begin()) {
mQueueHeadChangedCondition.signal();
}
if (realtime_us > getRealTimeUs() + kWakelockMinDelay) {
acquireWakeLock_l();
item.has_wakelock = true;
}
mQueue.insert(iter, item);
mQueueNotEmptyCondition.signal();
return true;
}
void SimpleEventQueue::stop(bool flush) {
ALOGV("stop: flush=%d, running=%d", flush, mRunning);
if (!mRunning) {
return;
}
if (flush) {
postTimedEvent(new StopEvent(this), getRealTimeUs());
} else {
postTimedEvent(new StopEvent(this), INT64_MIN);
}
void *dummy;
pthread_join(mThread, &dummy);
// some events may be left in the queue if we did not flush and the wake lock
// must be released.
if (!mQueue.empty()) {
releaseWakeLock_l(true /*force*/);
}
mQueue.clear();
mRunning = false;
}
int64_t TunnelPlayer::getMediaTimeUs() {
//essentially there is only one time, the real time
return getRealTimeUs();
}
void SimpleEventQueue::threadEntry()
{
prctl(PR_SET_NAME, (unsigned long)"SimpleEventQueue", 0, 0, 0);
while(true) {
int64_t now_us = 0;
sp<Event> event;
bool wakeLocked = false;
{
Mutex::Autolock _l(mLock);
if (mStopped) {
break;
}
while (mQueue.empty()) {
mQueueNotEmptyCondition.wait(mLock);
}
for (;;) {
if (mQueue.empty()) {
// The only event in the queue could have been cancelled
// while we were waiting for its scheduled time.
break;
}
List<QueueItem>::iterator iter = mQueue.begin();
now_us = getRealTimeUs();
int64_t when_us = iter->realtime_us;
int64_t delay_us;
if (when_us < 0 || when_us == INT64_MAX) {
delay_us = 0;
} else {
delay_us = when_us - now_us;
}
if (delay_us <= 0) {
break;
}
static int64_t kMaxTimeoutUs = 10000000ll; // 10 secs
bool timeoutCapped = false;
if (delay_us > kMaxTimeoutUs) {
ALOGW("delay_us exceeds max timeout: %lld us", delay_us);
// We'll never block for more than 10 secs, instead
// we will split up the full timeout into chunks of
// 10 secs at a time. This will also avoid overflow
// when converting from us to ns.
delay_us = kMaxTimeoutUs;
timeoutCapped = true;
}
status_t err = mQueueHeadChangedCondition.waitRelative(
mLock, delay_us * 1000ll);
if (!timeoutCapped && err == -ETIMEDOUT) {
// We finally hit the time this event is supposed to
// trigger.
now_us = getRealTimeUs();
break;
}
}
// The event w/ this id may have been cancelled while we're
// waiting for its trigger-time, in that case
// removeEventFromQueue_l will return NULL.
// Otherwise, the QueueItem will be removed
// from the queue and the referenced event returned.
event = removeEventFromQueue_l(&wakeLocked);
}
if (event != NULL && !event->isCanceled()) {
event->fire();
if (wakeLocked) {
Mutex::Autolock _l(mLock);
releaseWakeLock_l();
}
}
}
}
TimedEventQueue::event_id TimedEventQueue::postEventWithDelay(
const sp<Event> &event, int64_t delay_us) {
CHECK(delay_us >= 0);
return postTimedEvent(event, getRealTimeUs() + delay_us);
}
