BluetoothSocket.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : BluetoothSocket
 * Package    : Zeus.ZeusBase.Net.Bluetooth
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef BluetoothSocketH
#define BluetoothSocketH

#ifndef DISABLE_BLUETOOTH

#include <zeusbase/Net/AbstractSocket.h>
#include <zeusbase/Net/Bluetooth/BTDefines.hpp>
#include <zeusbase/System/Interfaces/IInputStream.hpp>
#include <zeusbase/System/Interfaces/IOutputStream.hpp>

BEGIN_NAMESPACE_Zeus

class TBTAddress;

/****************************************************************************/
/****************************************************************************/
zeusbase_class TBluetoothSocket : public TAbstractSocket, public IInputStream, public IOutputStream
{
  public:
    TBluetoothSocket();
    TBluetoothSocket(TBTAddress& rAddress);
    TBluetoothSocket(Int iFD, SOCKADDR_BTH& rSocketAddr);

    bool hasAuthentication() const;
    bool hasEncryption() const;
    void setAuthentication(bool bMode);
    void setEncryption(bool bMode);

    //Methods of TAbstractSocket
    virtual Retval connect();

    //Methods of IInputStream
    virtual bool MQUALIFIER available() const{ return m_bConnected; }
    virtual bool MQUALIFIER isEndReached() const { return !m_bConnected; }
    virtual Retval MQUALIFIER read(char* pBuffer, Int iBufferSize, Int& rValidSize) const;
    virtual Int  MQUALIFIER readItem() const;
    virtual Int8 MQUALIFIER readInt8(BOOL_ERRORRETVAL(pError)) const;
    virtual Int16 MQUALIFIER readInt16(BOOL_ERRORRETVAL(pError)) const;
    virtual Int32 MQUALIFIER readInt32(BOOL_ERRORRETVAL(pError)) const;
    virtual Int64 MQUALIFIER readInt64(BOOL_ERRORRETVAL(pError)) const;
    virtual Uint8 MQUALIFIER readUint8(BOOL_ERRORRETVAL(pError)) const;
    virtual Uint16 MQUALIFIER readUint16(BOOL_ERRORRETVAL(pError)) const;
    virtual Uint32 MQUALIFIER readUint32(BOOL_ERRORRETVAL(pError)) const;
    virtual Uint64 MQUALIFIER readUint64(BOOL_ERRORRETVAL(pError)) const;
    virtual Float64 MQUALIFIER readFloat64(BOOL_ERRORRETVAL(pError)) const;
    virtual Float32 MQUALIFIER readFloat32(BOOL_ERRORRETVAL(pError)) const;
    virtual bool MQUALIFIER readBool(BOOL_ERRORRETVAL(pError)) const;
    virtual Retval MQUALIFIER readArray(IByteArray& rData) const;
    virtual Retval MQUALIFIER readString(IString& rstrData) const;
    virtual void MQUALIFIER close() { disconnect(); }
    virtual void MQUALIFIER reset() {}
    virtual bool MQUALIFIER skip(Int iBytes = 1);

    //Methods of IOutputStream
    virtual Retval MQUALIFIER write(const char* pBuffer, Int iBufferSize);
    virtual Retval MQUALIFIER writeInt8(Int8 cData);
    virtual Retval MQUALIFIER writeInt16(Int16 sData);
    virtual Retval MQUALIFIER writeInt32(Int32 lData);
    virtual Retval MQUALIFIER writeInt64(const Int64& rldData);
    virtual Retval MQUALIFIER writeUint8(Uint8 ucData);
    virtual Retval MQUALIFIER writeUint16(Uint16 usData);
    virtual Retval MQUALIFIER writeUint32(Uint32 ulData);
    virtual Retval MQUALIFIER writeUint64(const Uint64& ruldData);
    virtual Retval MQUALIFIER writeFloat32(Float32 fData);
    virtual Retval MQUALIFIER writeFloat64(const Float64& rdData);
    virtual Retval MQUALIFIER writeBool(bool bData);
    virtual Retval MQUALIFIER writeArray(const IByteArray& rData);
    virtual Retval MQUALIFIER writeString(const IString& rData);
    virtual void MQUALIFIER flush() {}

    //Methods of IZUnknown
    MEMORY_MANAGER_DECL

  protected:
    virtual ~TBluetoothSocket();
    virtual void openSocket();

  private:
};

//INLINE METHODS
/**************************************************************************/
/**************************************************************************/
inline bool TBluetoothSocket::hasAuthentication() const
{
  #if defined(ENABLE_WIN32_BLUETOOTH)
    return TAbstractSocket::getBoolSocketOption(m_iSocketFD, SO_BTH_AUTHENTICATE, SOL_RFCOMM);
  #elif defined(ENABLE_BLUEZ_BLUETOOTH)
    return TAbstractSocket::getBoolSocketOption(m_iSocketFD, RFCOMM_LM_AUTH, SOL_RFCOMM);
  #else
    return false;
  #endif
}

/**************************************************************************/
/**************************************************************************/
inline bool TBluetoothSocket::hasEncryption() const
{
  #if defined(ENABLE_WIN32_BLUETOOTH)
    return TAbstractSocket::getBoolSocketOption(m_iSocketFD, SO_BTH_ENCRYPT, SOL_RFCOMM);
  #elif defined(ENABLE_BLUEZ_BLUETOOTH)
    return TAbstractSocket::getBoolSocketOption(m_iSocketFD, RFCOMM_LM_ENCRYPT, SOL_RFCOMM);
  #else
    return false;
  #endif
}

/**************************************************************************/
/**************************************************************************/
inline void TBluetoothSocket::setAuthentication(bool bMode)
{
  #if defined(ENABLE_WIN32_BLUETOOTH)
    TAbstractSocket::setBoolSocketOption(m_iSocketFD, SO_BTH_AUTHENTICATE, SOL_RFCOMM, bMode);
  #elif defined(ENABLE_BLUEZ_BLUETOOTH)
    TAbstractSocket::setBoolSocketOption(m_iSocketFD, RFCOMM_LM_AUTH, SOL_RFCOMM, bMode);
  #else
    //no bluetooth available
  #endif
}

/**************************************************************************/
/**************************************************************************/
inline void TBluetoothSocket::setEncryption(bool bMode)
{
  #if defined(ENABLE_WIN32_BLUETOOTH)
    TAbstractSocket::setBoolSocketOption(m_iSocketFD, SO_BTH_ENCRYPT, SOL_RFCOMM, bMode);
  #elif defined(ENABLE_BLUEZ_BLUETOOTH)
    TAbstractSocket::setBoolSocketOption(m_iSocketFD, RFCOMM_LM_ENCRYPT, SOL_RFCOMM, bMode);
  #else
    //no bluetooth available
  #endif
}

/***************************************************************************/
/***************************************************************************/
inline Uint8 MQUALIFIER TBluetoothSocket::readUint8(bool* pError) const
{
  return static_cast<Uint8>(readInt8(pError));
}

/***************************************************************************/
/***************************************************************************/
inline Uint16 MQUALIFIER TBluetoothSocket::readUint16(bool* pError) const
{
  return static_cast<Uint16>(readInt16(pError));
}

/***************************************************************************/
/***************************************************************************/
inline Uint32 MQUALIFIER TBluetoothSocket::readUint32(bool* pError) const
{
  return static_cast<Uint32>(readInt32(pError));
}

/***************************************************************************/
/***************************************************************************/
inline Uint64 MQUALIFIER TBluetoothSocket::readUint64(bool* pError) const
{
  return static_cast<Uint64>(readInt64(pError));
}

/**************************************************************************/
/**************************************************************************/
inline bool MQUALIFIER TBluetoothSocket::readBool(bool* pError) const
{
  return (readInt8(pError) != 0 );
}

/***************************************************************************/
/***************************************************************************/
inline Retval MQUALIFIER TBluetoothSocket::writeUint8(Uint8 ucData)
{
  return writeInt8(static_cast<Int8>(ucData));
}

/***************************************************************************/
/***************************************************************************/
inline Retval MQUALIFIER TBluetoothSocket::writeUint16(Uint16 usData)
{
  return writeInt16(static_cast<Int16>(usData));
}

/***************************************************************************/
/***************************************************************************/
inline Retval MQUALIFIER TBluetoothSocket::writeUint32(Uint32 ulData)
{
  return writeInt32(static_cast<Int32>(ulData));
}

/***************************************************************************/
/***************************************************************************/
inline Retval MQUALIFIER TBluetoothSocket::writeUint64(const Uint64& ruldData)
{
  return writeInt64(static_cast<Int64>(ruldData));
}

/***************************************************************************/
/***************************************************************************/
inline Retval MQUALIFIER TBluetoothSocket::writeBool(bool bData)
{
  return writeInt8(static_cast<Int8>(bData));
}

END_NAMESPACE_Zeus


#endif // #ifndef DISABLE_BLUETOOTH

#endif