sound_play.h

Go to the documentation of this file.

/*
 ***********************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2009, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the Willow Garage nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 ***********************************************************
 */

#ifndef __SOUND_PLAY__SOUND_PLAY__H__
#define __SOUND_PLAY__SOUND_PLAY__H__

#include <string>
#include <ros/ros.h>
#include <ros/node_handle.h>
#include <sound_play/SoundRequest.h>
#include <boost/thread.hpp>

namespace sound_play
{

class SoundClient
{
public:
        class Sound
        {
                friend class SoundClient;
        private:
                int snd_;
                std::string arg_;
                SoundClient *client_;

                Sound(SoundClient *sc, int snd, const std::string &arg)
                {
                        client_ = sc;
                        snd_ = snd;
                        arg_ = arg;
                }

        public:
                void play()
                {
                        client_->sendMsg(snd_, SoundRequest::PLAY_ONCE, arg_);
                }

                void repeat()
                {
                        client_->sendMsg(snd_, SoundRequest::PLAY_START, arg_);
                }

                void stop()
                {
                        client_->sendMsg(snd_, SoundRequest::PLAY_STOP, arg_);
                }
        };
        
        SoundClient(ros::NodeHandle &nh, const std::string &topic)
    {
                init(nh, topic);
        }

        SoundClient()
  {
                init(ros::NodeHandle(), "robotsound");
  }

  Sound voiceSound(const std::string &s)
        {
                return Sound(this, SoundRequest::SAY, s);
        }

  Sound waveSound(const std::string &s)
        {
                return Sound(this, SoundRequest::PLAY_FILE, s);
        }

  Sound builtinSound(int id)
        {
                return Sound(this, id, "");
        }

        void say(const std::string &s, const std::string &voice="voice_kal_diphone")
  {
    sendMsg(SoundRequest::SAY, SoundRequest::PLAY_ONCE, s, voice);
  }

  void repeat(const std::string &s)
  {
    sendMsg(SoundRequest::SAY, SoundRequest::PLAY_START, s);
  }

  void stopSaying(const std::string &s)
  {
    sendMsg(SoundRequest::SAY, SoundRequest::PLAY_STOP, s);
  }

  void playWave(const std::string &s)
  {
    sendMsg(SoundRequest::PLAY_FILE, SoundRequest::PLAY_ONCE, s);
  }

  void startWave(const std::string &s)
  {
    sendMsg(SoundRequest::PLAY_FILE, SoundRequest::PLAY_START, s);
  }

  void stopWave(const std::string &s)
  {
    sendMsg(SoundRequest::PLAY_FILE, SoundRequest::PLAY_STOP, s);
  }

        void play(int sound)
  {
    sendMsg(sound, SoundRequest::PLAY_ONCE);
  }

        void start(int sound) 
        { 
                sendMsg(sound, SoundRequest::PLAY_START); 
        }

  void stop(int sound)
  {
    sendMsg(sound, SoundRequest::PLAY_STOP);
  }

  void stopAll()
        {
                stop(SoundRequest::ALL);
        }
  
  void setQuiet(bool state)
        {
                quiet_ = state;
        }

private:
        void init(ros::NodeHandle nh, const std::string &topic)
        {
        nh_ = nh;
                pub_ = nh.advertise<sound_play::SoundRequest>(topic, 5);
                quiet_ = false;
    }

        void sendMsg(int snd, int cmd, const std::string &s = "", const std::string &arg2 = "")
  {
    boost::mutex::scoped_lock lock(mutex_);

    if (!nh_.ok())
      return;

    SoundRequest msg;
    msg.sound = snd;
    msg.command = cmd;
    msg.arg = s;
    msg.arg2 = arg2;
    pub_.publish(msg);

    if (pub_.getNumSubscribers() == 0 && !quiet_)
      ROS_WARN("Sound command issued, but no node is subscribed to the topic. Perhaps you forgot to run soundplay_node.py");
  }

    bool quiet_;
        ros::NodeHandle nh_;
    ros::Publisher pub_;
        boost::mutex mutex_;
};

typedef SoundClient::Sound Sound;

};

#endif