bluetoothclient.cpp

来自「series60 应用程序开发的源代码 series60 应用程序开发的源代码」· C++ 代码 · 共 272 行

/**
*
* @brief Definition of CBluetoothClient
*
* Copyright (c) EMCC Software Ltd 2003
* @version 1.0
*/

// System include
#include <s32mem.h>

// User include
#include "BluetoothClient.h"
#include "BluetoothDefinitions.h"
#include "BluetoothObserver.h"

/**
* Constructor.
*
* Private - must use factory constructor
* Set observer and flag to indicate not connected
* Add this active object to the scheduler
*
* @see NewL
* @param aObserver a reference to the "mix-in" class MBluetoothObserver.
*
**/
CBluetoothClient::CBluetoothClient(MBluetoothObserver& aObserver)
: CActive(CActive::EPriorityStandard),
  iObserver(aObserver),
  iState(EDisconnected)
{
    CActiveScheduler::Add(this);
}

/**
* Destructor
*
* Cancel this active object, and disconnect the Client
*
**/
CBluetoothClient::~CBluetoothClient()
{
    Cancel();
    Disconnect();
}


/**
* Factory Constructor.
* Only available way to construct class.
* This function can leave L
*
* @see ConstructL
* @param  aObserver reference to the observer to notify
* @return new instance of the CBluetoothClient
*/
CBluetoothClient* CBluetoothClient::NewL(MBluetoothObserver& aObserver)
{
    CBluetoothClient* self = new (ELeave) CBluetoothClient(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}


/**
* Second Stage Constructor.
* This function can leave L
* @param none
* @see NewL
* @see NewLC
* @param none
* @return none
*/
void CBluetoothClient::ConstructL()
{
}

/**
* Disconnect when tidying up this active object.
* @param none
* @return none
**/
void CBluetoothClient::DoCancel()
{
    Disconnect();
}

/**
* ConnectToServerL.
* Set up Socket Address from the Bluetooth Address and Port number passed through as parameters.
* Connect to Socket Server
* Open a socket on the Server on the RFCOMM protocol (KServerTransportName)
* Issue an asynchronous Connect on the socket, utilising the remote device address information
*
* @param aBTDevAddr address of the bluetooth device to connect to.
* @param aPort the port to connect to on the device specified
* @return none
**/
void CBluetoothClient::ConnectToServerL(const TBTDevAddr& aBTDevAddr, const TInt aPort)
{
    iState = EConnecting;

    iSocketAddress.SetBTAddr(aBTDevAddr);
    iSocketAddress.SetPort(aPort);

    User::LeaveIfError(iSocketServer.Connect());
    User::LeaveIfError(iSendingSocket.Open(iSocketServer, KServerTransportName));

    iSendingSocket.Connect(iSocketAddress, iStatus);

#ifdef __WINS__
    User::After(1); // Fix to allow emulator client to connect to server
#endif

    SetActive();
}

/**
* SendL.
*
* Issue an asynchronous Write on the socket, passing through the message to send
*
* @param aMessage the message to send
* @return none
**/
void CBluetoothClient::Send(const TDesC& aMessage)
{
    TRAPD(err, SendL(aMessage));
}

void CBluetoothClient::SendL(const TDesC& aMessage)
{
    iMessage.Zero();
    TDesBuf buffer;    
    buffer.Set (iMessage);
    
    RWriteStream stream(&buffer);
    CleanupClosePushL(stream);

    stream << aMessage;
    
    CleanupStack::PopAndDestroy();

    iState = ESendData;
    iSendingSocket.Write(iMessage, iStatus);
    SetActive();
}

/**
* RequestData.
*
* Issue an asynchronous receive function on the socket, passing through a buffer to be populated.
*
* @param none
* @return none
**/
void CBluetoothClient::RequestData()
{
    iMessage.Zero();

    iState = EWaitingForMessage;
    iSendingSocket.RecvOneOrMore(iMessage, 0, iStatus, iLen);
    SetActive();
}

/**
* RunL
*
* Called when an asynchronous request completes.
* iStatus variable indicates error conditions
* iState indicates present state of the Client
*
* @param none
* @return none
**/
void CBluetoothClient::RunL()
{
    if (iStatus.Int() == KErrNone)
    {
        switch (iState)
        {
            case EConnecting:
            {
                iObserver.ConnectedL();
                iState = EConnected;
                break;
            }

            case EWaitingForMessage:
            {
                iState = EConnected;

                TDesBuf buffer;    
                buffer.Set (iMessage);

                RReadStream stream (&buffer);
                CleanupClosePushL(stream);

                TBuf<KMaxMessageLength> rxBuf;

                stream >> rxBuf;

                CleanupStack::PopAndDestroy();
                
                iObserver.DataReceivedL(rxBuf);
                break;
            }

            case ESendData:
            {
                RequestData();
                break;
            }

            default:
                Panic(EInvalidClientState);
                break;
        }
    }
    else
    {
        Disconnect();
        iObserver.HandleErrorL(iStatus.Int());
    }
}

/**
* Disconnect
*
* Cancel any outstanding requests.
* Close the socket
* Close the connection to the socket server
*
* @param none
* @return none
**/
void CBluetoothClient::Disconnect()
{
    if (iState != EDisconnected)
    {
        iSendingSocket.CancelAll();
        iSendingSocket.Close();
        iSocketServer.Close();
    }

    iState = EDisconnected;
}
/**
 * Returns connected state.
 *
 * @param none
 * @retval boolean, true if client is connected.
 */
TBool CBluetoothClient::IsConnected()
{
    return !(iState == EDisconnected);
}

/**
 * Returns information on connected state.
 *
 * @param none
 * @retval boolean, true if the client is connected and can send data.
 */
TBool CBluetoothClient::AvailableToSend()
{
    return (iState == EConnected);
}