1 TimedEventQueue

目录

1、概述

2、一个典型的使用TimedEventQueue的例子

3、TimedEventQueue类介绍

 

1概述

---

    TimeEventQueue是android多媒体系统中实现异步操作的一种手段

    在Awesomeplayer中，依赖mVideoEvent、mStreamDoneEvent、mBufferingEvent、mCheckAudioStatusEvent等几个事件驱动着整个播放流程

    可以认为TimeEventQueue 是一个调度系统，调度的对象是事件Event，一个TimeEventQueue 可以同时处理多个事件

    本篇只分析TimeEventQueue 类结构及其用法

 

2、一个典型的使用TimedEventQueue的例子

---

一个简单的使用TimedEventQueue 的序列如下

mEventRead = new dtEvent(this,&dtPlayer::onReadEvent);             mQueue.start();             mQueue.postEvent(mEventRead);             mQueue.stop();

【说明】

首先建立一个事件

启动TimedEventQueue

通过postEvent触发事件，事件触发后会执行mEventRead对应的fire函数

最后结束

 

我们首先建立一个事件类

structdtEvent : publicTimedEventQueue::Event {                  dtEvent(dtPlayer *player,void(dtPlayer::*method)()):                     mPlayer(player),                    mMethod(method)                   {                  }                protected:                  virtual~dtEvent() {}                    virtualvoid fire(TimedEventQueue *queue, int64_t/* now_us */) {                      (mPlayer->*mMethod)();                  }                private:                  dtPlayer *mPlayer;                  void(dtPlayer::*mMethod)();                    dtEvent(constdtEvent &);                  dtEvent &operator=(constdtEvent &);              };

这里处理方法与awesomeplayer等类似，由于Event是抽象类，不能直接使用，因此需要建立一个继承自Event的子类，并重载fire方法

这里构造函数中传入了dtPlayer::*method 参数，作为fire中执行的函数体。这样就保证了对于每一个事件，通过传入不同的mMethod方法，便可以做出不同的反应

 

类似Awesomeplayer，我们需要为TimedEventQueue建立一个载体类dtPlayer

class dtPlayer{           public:                 dtPlayer();                 virtual ~dtPlayer(){};             private:               TimedEventQueue mQueue;               bool mQueueStarted;                 sp<TimedEventQueue::Event> mEventRead;                 sp<TimedEventQueue::Event> mEventWrite;                 sp<TimedEventQueue::Event> mEventSearch;                   voidonReadEvent();               voidonWriteEvent();               voidonSearchEvent();           public:               voidstart();               voidstop();               bool isplaying();               voidpostRandomEvent();           private:               dtPlayer(constdtPlayer &);               dtPlayer &operator=(constdtPlayer &);           };

 在载体类中，我们有

TimedEventQueue 对象mQueue,

三个Event对象，分别是mEventRead mEventWrite mEventSearch

三个方法，分别是传入给上面三个事件的参数，是void onReadEvent(); void onWriteEvent(); void onSearchEvent();

状态机：start stop 等

postRandomEvent 方法：封装的触发事件的方法

 

下面看下具体实现

dtPlayer::dtPlayer()          {            mEventRead =new dtEvent(this,&dtPlayer::onReadEvent);              mEventWrite =new dtEvent(this,&dtPlayer::onWriteEvent);              mEventSearch =new dtEvent(this,&dtPlayer::onSearchEvent);               mQueueStarted=false;           }

先看下构造函数，构造函数主要是生成三个事件，并将参数传递进去，这里可以看到调用的是重载的event的构造函数

并设置mQueue状态

void dtPlayer::onReadEvent()          {            ALOGI("--read event occur-- read something \n"); }            void dtPlayer::onWriteEvent()          {            ALOGI("--write event occur-- write something \n"); }            void dtPlayer::onSearchEvent()          {            ALOGI("--search event occur-- search something \n");             }

 对应的实现，只加了打印，表示执行过了

void dtPlayer::start()        {          if(mQueueStarted==false)            mQueue.start();          mQueueStarted=true;          printf("dtplayer start  \n");        }          void dtPlayer::stop()        {          if(mQueueStarted==true)            mQueue.stop(true);          mQueueStarted=false;          }          bool dtPlayer::isplaying()        {          return(mQueueStarted==true);        }

状态机代码，主要是控制mQueue的状态

void dtPlayer::postRandomEvent()        {          mQueue.postEvent(mEventRead);        }

事件触发函数，这里可以看到触发方法便是调用mQueue的postEvent方法，并且将事件对象作为参数传入。这样便可以执行对应事件的fire方法了

 

extern "C"int dt_test()        {            ALOGE("--post event start \n");            dtPlayer *player=newdtPlayer();            player->start();            player->postRandomEvent();            player->stop();            ALOGE("--post event end\n");            sleep(5);            return0;        }

这里实现了测试code，只是简单的触发一个事件然后返回

【说明】具体的例子源代码已经打包放在了附件中

测试方法：

(1)将压缩包拷贝至framework/av/media/libstagefright目录下

(2)解压缩并进入_timeeventqueue_test文件夹

(3)mm

(4)将可执行文件拷贝到目标板执行即可

 

通过上面的例子可以看到，TimedEventQueue 的使用时比较简单的，只要新建一个Event子类，并重载fire方法

之后通过TimedEventQueue 的postEvent等就可以出发执行了

而且这里一个TimedEventQueue 可以支持多个事件

 

下面看下TimedEventQueue 具体是如何实现这一机制的

 

3、TimedEventQueue类介绍

---

2.1 event事件

TimedEventQueue调度的对象是事件

先看下事件的定义，事件是定义在TimedEventQueue 结构体内部的结构体

 typedef int32_t event_id;    struct Event : public RefBase {        Event()            : mEventID(0) {        }        virtual ~Event() {}        event_id eventID() {            return mEventID;        }    protected:        virtual void fire(TimedEventQueue *queue, int64_t now_us) = 0;    private:        friend class TimedEventQueue;        event_id mEventID;        void setEventID(event_id id) {            mEventID = id;        }        Event(const Event &);        Event &operator=(const Event &);    };

说明：

mEventID 事件ID

fire 纯虚函数，事件触发时调度执行的函数

因此Event不能直接使用，需继承并重载fire方法后使用

 

 2.2 TimedEventQueue 一些重要方法解析

挑一下比较重要的解释下

void TimedEventQueue::start() {            if(mRunning) {                return;            }            mStopped =false;            pthread_attr_t attr;            pthread_attr_init(&attr);            pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);            pthread_create(&mThread, &attr, ThreadWrapper,this);            pthread_attr_destroy(&attr);            mRunning =true;        }

这里调用mQueue->start 后主要是启动一个线程，看下线程代码

// static        void *TimedEventQueue::ThreadWrapper(void *me) {              androidSetThreadPriority(0, ANDROID_PRIORITY_FOREGROUND);              static_cast<TimedEventQueue *>(me)->threadEntry();              returnNULL;        }

 这里线程实现方法的主要作用是调用mQueue->threadEntry 方法，因为上面传入的参数是this指针

代码比较多我们分段来看

void TimedEventQueue::threadEntry() {           prctl(PR_SET_NAME, (unsigned long)"TimedEventQueue",0, 0,0);             for(;;) {               int64_t now_us =0;               sp<Event> event;                 {                   Mutex::Autolock autoLock(mLock);                     if(mStopped) {                       break;                   }                     while(mQueue.empty()) {                       mQueueNotEmptyCondition.wait(mLock);                   }

首先判断mStopped，确定是否要退出

然后判断mQueue中是否为空，若未空表示没有要处理的事件，则等待

event_id eventID = 0;                  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 it = mQueue.begin();                      eventID = (*it).event->eventID();                        now_us = ALooper::GetNowUs();                      int64_t when_us = (*it).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;                      }                        staticint64_t kMaxTimeoutUs = 10000000ll;  // 10 secs                      booltimeoutCapped = 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 = ALooper::GetNowUs();                          break;                      }                  }

若mQueue事件列表非空，则有要处理的事件，进入for loop进行处理,主要工作有

从mQueue的event列表中获取一个event

判断是否执行，如果时间到了（delay_us <= 0），则跳出循环执行事件处理函数，否则若需等待时间低于10s，则mQueueHeadChangedCondition.waitRelative等待。若高于10s，等10s后重新轮询

当条件满足时，通过event = removeEventFromQueue_l(eventID);获取事件对象，并调用event->fire(this, now_us);

 

这里有几个问题

（1）对mQueue，每个event都有一个唯一eventID，mQueue通过eventID来获取事件对象，eventID如何计算的

此问题的答案在mQueue->postEvent中。看下代码

TimedEventQueue::event_id TimedEventQueue::postEvent(constsp<Event> &event) {       // Reserve an earlier timeslot an INT64_MIN to be able to post       // the StopEvent to the absolute head of the queue.       returnpostTimedEvent(event, INT64_MIN + 1);   }

TimedEventQueue::event_id TimedEventQueue::postTimedEvent(           constsp<Event> &event, int64_t realtime_us) {       Mutex::Autolock autoLock(mLock);         event->setEventID(mNextEventID++);         List<QueueItem>::iterator it = mQueue.begin();       while(it != mQueue.end() && realtime_us >= (*it).realtime_us) {           ++it;       }         QueueItem item;       item.event = event;       item.realtime_us = realtime_us;         if(it == mQueue.begin()) {           mQueueHeadChangedCondition.signal();       }         mQueue.insert(it, item);         mQueueNotEmptyCondition.signal();         returnevent->eventID();   }

 从代码可以看出，postEvent会调用postTimedEvent，而在postTimedEvent中第一步操作就是设置eventID，这也就保证了每个event都有唯一一个eventID标识

另外，会将事件通过mQueue.insert(it, item); 插入到TimedEventQueue->mQueue中，如下定义

struct QueueItem {       sp<Event> event;       int64_t realtime_us;   };

mQueue是一个QueueItem列表，存储了事件对象及要触生的时间

（2）每次mQueue都从列表中取出第一个事件进行处理，但有个问题，若此事件阻塞的时候，其他事件需要触发，怎么处理？

玄机同样在postTimedEvent中，在插入列表之前，会首先查找要插入到TimedEventQueue->mQueue 中的位置，按照触发时间排序

 

2.3 其他方法介绍

TimedEventQueue 中还有一些接口扩展使得其功能更加强大，主要有

event_id postEventToBack(const sp<Event> &event); 插入到事件列表末尾

TimedEventQueue::event_id TimedEventQueue::postEventWithDelay(const sp<Event> &event, int64_t delay_us) ； 注册事件同时设置delay时间

bool TimedEventQueue::cancelEvent(event_id id)；注销某个事件

void TimedEventQueue::cancelEvents（*）；注销所有事件