examples/QtQuick/bluetoothex/connector.cpp

/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). 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 Nokia Corporation 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 HOLDER 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.
 *    
 *    Description:  
 */

// INCLUDE FILES
#include "connector.h"

_LIT(KRfComm,"RFCOMM");

CConnector* CConnector::NewL(MConnectorObserver& aObserver, 
                             RSocketServ& aSocketServ)
    {
    CConnector* self = CConnector::NewLC(aObserver, aSocketServ);
    CleanupStack::Pop(self);
    return self;
    }


CConnector* CConnector::NewLC(MConnectorObserver& aObserver, 
                              RSocketServ& aSocketServ)
    {
    CConnector* self = new (ELeave) CConnector(aObserver, aSocketServ);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }


void CConnector::ConstructL()
    {
    }


CConnector::CConnector(MConnectorObserver& aObserver, 
                       RSocketServ& aSocketServ):
    CActive(CActive::EPriorityStandard),
    iObserver(aObserver),
    iSocketServ(aSocketServ),
    iState(ENone)
    {
    CActiveScheduler::Add(this);
    }


CConnector::~CConnector()
    {
    Cancel();
    // disconnect and kill socket
    Disconnect();
    }


void CConnector::DoCancel()
    {
    iSock.CancelAll();
    }


// ----------------------------------------------------------------------------
// CConnector::ConnectL(THostName aName, TBTDevAddr aAddr, TInt aPort)
//
// create a connection to given address on given port.  
// ----------------------------------------------------------------------------
TRequestStatus CConnector::ConnectL(THostName aName, TBTDevAddr aAddr, 
                                    TInt aPort)
    {
    iName=aName;
    iAddr=aAddr;
    iPort=aPort;

    // load protocol, RFCOMM
    TProtocolDesc pdesc;
    User::LeaveIfError(iSocketServ.FindProtocol(KRfComm(), pdesc));

    // open socket
    User::LeaveIfError(iSock.Open(iSocketServ, KRfComm));
    // set address and port
    TBTSockAddr addr;
    addr.SetBTAddr(iAddr);
    addr.SetPort(iPort);
    
    // connect socket
    TRequestStatus status;
    iSock.Connect(addr, status);
    User::WaitForRequest(status);
    if ( status!=KErrNone )
        {
        // error opening conn
        return status;
        }
        
    iState=EConnecting;
    WaitAndReceive();
    return status;
    }


// ----------------------------------------------------------------------------
// CConnector::Disconnect()
//
// disconnect from remote device, shutdown connected socket
// ----------------------------------------------------------------------------
void CConnector::Disconnect()
    {
    TRequestStatus status;
    // shutdown socket
    if (iState == ENone)
        {
        return;
        }
    iSock.Shutdown(RSocket::ENormal, status);
    User::WaitForRequest(status);
    iSock.Close();
    }


// ----------------------------------------------------------------------------
// CConnector::SendData(const TDesC8& aData)
//
// send given data to remote device, write to connected socket
// ----------------------------------------------------------------------------
void CConnector::SendData(const TDesC8& aData)
    {
    // cancel any read requests on socket
    iSock.CancelRead();
    Cancel();
    // send message
    iState=ESending;
    iSock.Write(aData, iStatus);
    SetActive();
    }


// ----------------------------------------------------------------------------
// CConnector::WaitAndReceiveL()
//
// wait for and receive data from remote device, read connected socket
// ----------------------------------------------------------------------------
void CConnector::WaitAndReceive()
    {
    // cancel pending operations
    iSock.CancelRead();
    Cancel();
    // receive data from socket
    iState=EWaiting;
    iSock.RecvOneOrMore(iBuffer, 0, iStatus, iLen);
    SetActive();
    }


void CConnector::RunL()
    {
    if ( iStatus!=KErrNone )
        {
        iObserver.HandleConnectorErrorL(iName,iStatus.Int());
        return;
        }

    switch (iState)
        {
        case EConnecting:
            {
            // wait incoming data on socket
            WaitAndReceive();
            break;
            }
        case EWaiting:
            {
            // we got incoming data!
            HBufC* text = HBufC::NewLC(iBuffer.Length());
            text->Des().Copy(iBuffer);
            // observer will handle data
            HandleConnectorDataReceivedL(iName, *text);
            CleanupStack::PopAndDestroy(text);

            // start expecting new incoming data
            WaitAndReceive(); 
            break;
            }
        case ESending:
            {
            // tried to send a message
            if(iState!=KErrNone)
                {
                // Add error handling / socket re-read code
                // here, not implemented in this example
                }

            // start expecting new incoming data
            WaitAndReceive();
            break;
            }
        default:
            break;
        }
    }

TInt CConnector::RunError(TInt /*aError*/)
    {
    // Add error handling here, not implemented in this example
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CConnector::HandleConnectorDataReceivedL(THostNama aName, TDesC& aData)
//
// a callback to observer indicating that connector has received data
// ----------------------------------------------------------------------------
void CConnector::HandleConnectorDataReceivedL(THostName aName, const TDesC& aData)
{
    iObserver.HandleConnectorDataReceivedL(aName, aData);
}

---