bundles/PlayerMPD/PlayerMPD.h

/**
 * @class   PlayerMPD
 * @brief   Interface for PlayerMPD implementations.
 *
 * @see     IPlayerMPDListener
 ****************************************************************************
 * @version 0.8.471 $Id: PlayerMPD.h 3775 2011-01-01 16:38:17Z alex $
 * @author  Alessandro Polo
 ****************************************************************************/
/* Copyright (c) 2007-2011, WOSH - Wide Open Smart Home 
 * by Alessandro Polo - OpenSmartHome.com
 * 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 OpenSmartHome.com WOSH 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 Alessandro Polo ''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 Alessandro Polo 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 __WOSH_DEVICES_PlayerMPD_H__
 #define __WOSH_DEVICES_PlayerMPD_H__

 #include <woshDefs.h>
 #include <core/Containers.h>
 #include <core/BundleGenericWorker.h>
 #include <interfaces/entertainment/PlayerAudio.h>
 #include <framework/entertainment/MediaTrack.h>
 #include <framework/entertainment/MediaList.h>
 #include <core/DataFields.h>
 #include <map>


using namespace wosh;
using namespace wosh::entertainment;

class IPlayerMPDListener;

class PlayerMpdOutput : public virtual IDataFieldRW
 {
    WOSH_DF_MEYER_RW(PlayerMpdOutput, PlayerMpdOutput)

    public:
        PlayerMpdOutput() {
            this->index = -1;
            this->enabled = false;
         }
        virtual ~PlayerMpdOutput() { }

    public:
        int getIndex() const                { return this->index; }
        const std::string& getName() const  { return this->name; }
        bool isEnabled() const              { return this->enabled; }

    public:
        int index;
        std::string name;
        bool enabled;
 };

std::string print_PlayerMpdOutputList( VectorT<PlayerMpdOutput*>& cont );


class PlayerMPD :   public BundleGenericWorker,
                    public wosh::interfaces::entertainment::PlayerAudio
 {
    WOSH_CLASSNAME(PlayerMPD)

    public:
        enum UPDATE_TYPE {
            UPDATE_NONE             = 0x00,
            UPDATE_STATUS           = 0x01,
            UPDATE_STATS            = 0x02,
            UPDATE_PLAYLIST         = 0x05,
            UPDATE_OUTPUTS          = 0x08,
            UPDATE_ALL              = 0xFF
         };

/** @name Playlist management
 * @{
 ******************************************************************************/
    public:
    //  virtual WRESULT play() = 0;
    //  virtual WRESULT play( unsigned int index ) = 0;
    //  virtual WRESULT play( const std::string& file_url, int volume = -1, bool override_current = false ) = 0;
        virtual WRESULT playSearch( const std::string& query ) = 0;
    //  virtual WRESULT pause() = 0;
    //  virtual WRESULT stop() = 0;

    //  virtual WRESULT enqueue( const std::string& file_url ) = 0;
    //  virtual WRESULT remove( unsigned int index ) = 0;
    //  virtual WRESULT remove( const std::string& file_url ) = 0;
        virtual WRESULT move( unsigned int index_old, unsigned int index_new ) = 0;
        virtual WRESULT swap( unsigned int index_old, unsigned int index_new ) = 0;
    //  virtual WRESULT clear() = 0;

    //  virtual WRESULT first() = 0;
    //  virtual WRESULT next() = 0;
    //  virtual WRESULT prev() = 0;
    //  virtual WRESULT last() = 0;

//@}
/** @name Getters
 * @{
 ******************************************************************************/
    public:
    //  virtual bool isPlaying() const = 0;
    //  virtual long getPlayListIndex() const = 0;
    //  virtual long getPlayListLength() const = 0;

    //  virtual int getVolume() const = 0;
    //  virtual bool isMuted() const = 0;
    //  virtual int getCrossfade() const = 0;
    //  virtual short getRepeat() const = 0;
    //  virtual short getRandom() const = 0;

    //  virtual float getPosition() const = 0;
    //  virtual std::string getPositionStr() const = 0;
    //  virtual int64 getPositionMs() const = 0;

    //  virtual int64 getLengthMs() const = 0;
    //  virtual std::string getLengthStr() const = 0;

        virtual int getBitRate() const = 0;     ///< current bit rate in kbs

        virtual const VectorT<PlayerMpdOutput*>& getOutputs() const = 0;
        virtual VectorT<PlayerMpdOutput*>& getOutputs() = 0;

        virtual const wosh::entertainment::MediaTrack& getCurrentTrack() const = 0;
        virtual wosh::entertainment::MediaTrack& getCurrentTrack() = 0;

        virtual const wosh::entertainment::MediaList& getPlayList() const = 0;
        virtual wosh::entertainment::MediaList& getPlayList() = 0;

//@}
/** @name Setters
 * @{
 ******************************************************************************/
    public:
        virtual inline void setPlayerListener( IPlayerMPDListener* Listener ) {
            this->playerListener = Listener;
         }

    //  virtual WRESULT setVolume( int newVolume ) = 0;
    //  virtual WRESULT setVolumeOffset( int volume_span ) = 0;
    //  virtual WRESULT setMute( bool on ) = 0;
    //  virtual WRESULT setRepeat( short value ) = 0;
    //  virtual WRESULT setRandom( short value ) = 0;
    //  virtual WRESULT setCrossfade( int seconds ) = 0;

    //  virtual WRESULT setPosition( float position_rate ) = 0;
    //  virtual WRESULT setPositionOffset( float position_rate_offset ) = 0;
    //  virtual WRESULT setPositionMs( int64 position_ms ) = 0;

        virtual WRESULT switchOutput( int index, bool enable ) = 0;
        virtual WRESULT forceServerUpdate( const std::string& path ) = 0;

        virtual void setRefreshPeriod( long seconds ) = 0;
        virtual void setRefreshFullDivider( long divider ) = 0;

//@}
/** @name Server management
 * @{
 ******************************************************************************/
    public:
        virtual void setAddressPort( const std::string& add_value, int port_value ) = 0;
        virtual void setAddressPort( const std::string& value ) = 0;

        virtual const std::string& getAddress() const = 0;
        virtual int getPort() const = 0;
        virtual std::string getAddressPort() const = 0;

        virtual const std::string& getDatabasePath() const = 0;
        virtual void setDatabasePath( const std::string& value ) = 0;

        virtual long getRefreshPeriod() const = 0;
        virtual long getRefreshFullDivider() const = 0;

        virtual bool isServerUpdating() const = 0;
        virtual WRESULT getAPIInfo( std::map<std::string, std::string>& fields ) = 0;

        virtual WRESULT updateAll( bool smart, bool callbacks = true ) = 0;
        virtual WRESULT updateOutputs( bool callbacks = true ) = 0;
        virtual WRESULT updateStatus( bool callbacks = true ) = 0;
        virtual WRESULT updateStats( bool callbacks = true ) = 0;
        virtual WRESULT updatePlaylist( bool callbacks = true ) = 0;

//@}
    public:
        PlayerMPD( BundleGeneric& bundle ) : BundleGenericWorker(bundle) {
            this->playerListener = NULL;
         }
        virtual ~PlayerMPD() { }

    protected:
        IPlayerMPDListener* playerListener;

}; // class def



class IPlayerMPDListener : public virtual wosh::interfaces::entertainment::PlayerAudioListener
 {
    public:
        virtual void updated_Stats( const std::map<std::string, std::string>& fields, PlayerMPD* source ) = 0;
        virtual void changed_Outputs( const VectorT<PlayerMpdOutput*>& final_outputs,
                                        VectorT<PlayerMpdOutput*>& outofdate_items, VectorT<PlayerMpdOutput*>& new_items,
                                        VectorT<PlayerMpdOutput*>& changed_items,
                                        PlayerMPD* source ) = 0;

    public:
        virtual ~IPlayerMPDListener() { }
}; // class def


#endif //__WOSH_DEVICES_PlayerMPD_H__