ArSoundsQueue.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/


#ifndef ARSOUNDSQUEUE_H
#define ARSOUNDSQUEUE_H


#include "ariaTypedefs.h"
#include "ArASyncTask.h"
#include "ArCondition.h"
#include "ArSpeech.h"
#include <list>
#include <string>
#include <set>

class ArSoundsQueue: public ArASyncTask
{
public:

  enum ItemType { SPEECH, SOUND_FILE, SOUND_DATA, OTHER };

  typedef ArRetFunctor2<bool, const char*, const char*> PlayItemFunctor;
  typedef ArFunctor InterruptItemFunctor;

  typedef ArRetFunctor<bool> PlaybackConditionFunctor;

  class Item {
  public:
    std::string data;
    ItemType type;
    std::string params;
    int priority;
    std::list<InterruptItemFunctor*> interruptCallbacks;
    std::list<PlayItemFunctor*> playCallbacks;
    std::list<ArFunctor*> doneCallbacks;
    std::list<PlaybackConditionFunctor*> playbackConditionCallbacks;

    AREXPORT Item();
    AREXPORT Item(std::string _data, ItemType _type, std::string _params = "", int priority = 0);
    AREXPORT Item(std::string _data, ItemType _type, std::string _params, int priority, std::list<PlayItemFunctor*> callbacks); 

    AREXPORT Item(const ArSoundsQueue::Item& toCopy);

    bool operator==(const Item& other) const
    {
      return (other.type == type && other.params == params && other.data == data);
    }

    void play();

    void interrupt();

    void done();
  };


  AREXPORT ArSoundsQueue();

  AREXPORT ArSoundsQueue(ArRetFunctor<bool> *speakInitCB, 
            PlayItemFunctor *speakCB = 0, 
        InterruptItemFunctor *interruptSpeechCB = 0,
            ArRetFunctor<bool> *playInitCB = 0, 
            PlayItemFunctor *playFileCB = 0,
        InterruptItemFunctor *interruptFileCB = 0);

  AREXPORT ArSoundsQueue(ArSpeechSynth* speechSynthesizer, 
            ArRetFunctor<bool> *playInitCB = 0, 
            PlayItemFunctor *playFileCB = 0,
        InterruptItemFunctor *interruptFileCB = 0);

  AREXPORT virtual ~ArSoundsQueue();

  AREXPORT void addInitCallback(ArRetFunctor<bool> *cb) {
    myInitCallbacks.push_back(cb);
  }

  AREXPORT void setSpeakInitCallback(ArRetFunctor<bool> *cb) {
    addInitCallback(cb);
  }

  AREXPORT void addItem(ArSoundsQueue::Item item);

  AREXPORT void addItem(ItemType type, const char* data, std::list<PlayItemFunctor*> callbacks, int priority = 0, const char* params = 0);

  AREXPORT bool isInitialized()
  {
    return myInitialized;
  }

  AREXPORT bool isSpeakingOrPlaying(void) { return (myPlayingSomething); }

  AREXPORT bool isPlaying() { return myPlayingSomething; }


  AREXPORT bool isSpeaking() { return myPlayingSomething; }


  AREXPORT void run(void) { runInThisThread(); }

  AREXPORT void runAsync(void) { create(false); }

  AREXPORT void pause();

  AREXPORT void resume() ;

  AREXPORT bool isPaused();

  AREXPORT void interrupt();

  AREXPORT void clearQueue();

  AREXPORT void stop() ;

  AREXPORT ArFunctor* getPauseCallback() 
  {
    return new ArFunctorC<ArSoundsQueue>(this, &ArSoundsQueue::pause);
  }

  AREXPORT ArFunctor* getResumeCallback() 
  {
    return new ArFunctorC<ArSoundsQueue>(this, &ArSoundsQueue::resume);
  }


  AREXPORT size_t getCurrentQueueSize()
  {
    size_t size;
    lock();
    size = myQueue.size();
    unlock();
    return size;
  }

  AREXPORT void addSoundStartedCallback(ArFunctor* f)
  {
    myStartPlaybackCBList.push_back(f);
  }

  AREXPORT void remSoundStartedCallback(ArFunctor* f)
  {
    myStartPlaybackCBList.remove(f);
  }

  AREXPORT void addSoundFinishedCallback(ArFunctor* f)
  {
    myEndPlaybackCBList.push_back(f);
  }

  AREXPORT void remSoundFinishedCallback(ArFunctor* f)
  {
    myEndPlaybackCBList.remove(f);
  }

  AREXPORT void addQueueNonemptyCallback(ArFunctor* f)
  {
    myQueueNonemptyCallbacks.push_back(f);
  }

  AREXPORT void remQueueNonemptyCallback(ArFunctor* f)
  {
    myQueueNonemptyCallbacks.remove(f);
  }

  AREXPORT void addQueueEmptyCallback(ArFunctor* f)
  {
    myQueueEmptyCallbacks.push_back(f);
  }

  AREXPORT void remQueueEmptyCallback(ArFunctor* f)
  {
    myQueueEmptyCallbacks.remove(f);
  }


  
  AREXPORT std::set<int> findPendingItems(const char* item);

  AREXPORT void removePendingItems(const char* item, ItemType type);

  AREXPORT void removePendingItems(const char* data);

  AREXPORT void removePendingItems(int priority);

  AREXPORT void removePendingItems(int priority, ItemType type);

  AREXPORT void removePendingItems(ItemType type);

  AREXPORT std::string nextItem(ItemType type);
  AREXPORT std::string nextItem(int priority);
  AREXPORT std::string nextItem(ItemType type, int priority);


  
  AREXPORT void setSpeakCallback(PlayItemFunctor *cb) {
    myDefaultSpeakCB = cb;
  }

  AREXPORT void setInterruptSpeechCallback(InterruptItemFunctor *cb) {
    myDefaultInterruptSpeechCB = cb;
  }

  AREXPORT void setPlayFileCallback(PlayItemFunctor *cb) {
    myDefaultPlayFileCB = cb;
  }

  AREXPORT void setPlayWavFileCallback(PlayItemFunctor* cb) {
    setPlayFileCallback(cb);
  }

  AREXPORT void setInterruptFileCallback(InterruptItemFunctor *cb) {
    myDefaultInterruptFileCB = cb;
  }

  AREXPORT void setInterruptWavFileCallback(InterruptItemFunctor* cb) {
    setInterruptFileCallback(cb);
  }
  

  
  
#if !(defined(WIN32) && defined(_MANAGED))

  AREXPORT void speak(const char *fmt, ...);

  AREXPORT void speakWithVoice(const char* voice, const char* fmt, ...);

  AREXPORT void speakWithPriority(int priority, const char* fmt, ...);

  AREXPORT void play(const char *filename_fmt, ...);

#endif // MS Managed C++

  AREXPORT ArSoundsQueue::Item createDefaultSpeechItem(const char* speech = 0);

  AREXPORT ArSoundsQueue::Item createDefaultFileItem(const char* filename = 0);


  AREXPORT void setDefaultPlayConditionCB(PlaybackConditionFunctor* f) {
    myDefaultPlayConditionCB = f;
  }
  

  AREXPORT virtual void *runThread(void *arg);

protected:
  bool myInitialized;
  std::list<Item> myQueue;
  ArMutex myQueueMutex;
  void lock() {
    myQueueMutex.lock();
  }
  void unlock() {
    myQueueMutex.unlock();
  }
  bool tryLock() {
    return myQueueMutex.tryLock();
  }

  std::list< ArRetFunctor<bool>* > myInitCallbacks;

  bool myPlayingSomething;
  Item myLastItem; 


  PlayItemFunctor *myDefaultSpeakCB;
  InterruptItemFunctor *myDefaultInterruptSpeechCB;
  PlayItemFunctor *myDefaultPlayFileCB;
  InterruptItemFunctor *myDefaultInterruptFileCB;
 
  int myPauseRequestCount;  
  ArCondition myPausedCondition;    


  std::list<ArFunctor*> myStartPlaybackCBList;
  std::list<ArFunctor*> myEndPlaybackCBList;
  std::list<ArFunctor*> myQueueNonemptyCallbacks;
  std::list<ArFunctor*> myQueueEmptyCallbacks;
  
  PlaybackConditionFunctor* myDefaultPlayConditionCB; 

  void invokeCallbacks(const std::list<ArFunctor*>& lst);

  void invokeCallbacks(const std::list<ArRetFunctor<bool>*>& lst);

  void pushQueueItem(Item item);
  void pushQueueItem_NoLock(Item item);

  Item popQueueItem();
  Item popQueueItem_NoLock();

};

#endif

---