www.pudn.com > S60_Platform_Bluetooth_OBEX_Example.rar > objectexchangeclient.cpp

/* Copyright (c) 2004, Nokia. All rights reserved */ 
 
 
// INCLUDE FILES 
#include  
#include  
 
#include "ObjectExchangeClient.h" 
#include "ObjectExchangeServiceSearcher.h" 
#include "BTObjectExchange.pan" 
#include "Log.h" 
 
// ============================ MEMBER FUNCTIONS ============================== 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::NewL() 
// Symbian two-phased constructor. 
// ---------------------------------------------------------------------------- 
// 
CObjectExchangeClient* CObjectExchangeClient::NewL( MLog& aLog ) 
    { 
    CObjectExchangeClient* self = NewLC( aLog ); 
    CleanupStack::Pop( self ); 
    return self; 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::NewLC() 
// Symbian two-phased constructor. 
// ---------------------------------------------------------------------------- 
// 
CObjectExchangeClient* CObjectExchangeClient::NewLC( MLog& aLog ) 
    { 
    CObjectExchangeClient* self = new ( ELeave ) CObjectExchangeClient( aLog ); 
    CleanupStack::PushL( self ); 
    self->ConstructL(); 
    return self; 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::CObjectExchangeClient() 
// Constructor. 
// ---------------------------------------------------------------------------- 
// 
CObjectExchangeClient::CObjectExchangeClient( MLog& aLog ) 
: CActive( CActive::EPriorityStandard ), 
  iState( EWaitingToGetDevice ), 
  iLog( aLog ) 
    { 
    CActiveScheduler::Add( this ); 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::~CObjectExchangeClient() 
// Destructor. 
// ---------------------------------------------------------------------------- 
// 
CObjectExchangeClient::~CObjectExchangeClient() 
    { 
 
    if ( iState != EWaitingToGetDevice && iClient ) 
    { 
        iClient->Abort(); 
        iStatus = KErrNone; 
    } 
 
    Cancel(); 
     
    delete iCurrObject; 
    iCurrObject = NULL; 
 
    delete iServiceSearcher; 
    iServiceSearcher = NULL; 
 
    delete iClient; 
    iClient = NULL; 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::ConstructL() 
// Perform second phase construction of this object. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::ConstructL() 
    { 
    iServiceSearcher = CObjectExchangeServiceSearcher::NewL( iLog ); 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::DoCancel() 
// Cancel any outstanding requests. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::DoCancel() 
    { 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::RunL() 
// Respond to an event. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::RunL() 
    { 
    HBufC* textResource = NULL; 
 
    if ( iStatus != KErrNone ) 
        { 
        switch ( iState ) 
            { 
            case EGettingDevice: 
                if ( iStatus == KErrCancel ) 
                    { 
                    textResource = StringLoader::LoadLC ( R_BTOB_NO_DEVICE ); 
                    iLog.LogL( *textResource ); 
                    CleanupStack::PopAndDestroy ( textResource ); 
                    } 
                iState = EWaitingToGetDevice; 
                break; 
            case EGettingService: 
            case EGettingConnection: 
            case EDisconnecting: 
                textResource = StringLoader::LoadLC ( R_BTOB_CONNECTION_ERROR ); 
                iLog.LogL( *textResource, iStatus.Int() ); 
                CleanupStack::PopAndDestroy ( textResource ); 
                iState = EWaitingToGetDevice; 
                break; 
            case EWaitingToSend: 
                textResource = StringLoader::LoadLC ( R_BTOB_SEND_ERROR ); 
                iLog.LogL( *textResource, iStatus.Int() ); 
                CleanupStack::PopAndDestroy ( textResource ); 
                iState = EWaitingToGetDevice; 
                break; 
            default: 
                Panic( EBTObjectExchangeUnexpectedLogicState ); 
                break; 
            } 
        } 
    else  
        { 
        switch ( iState ) 
            { 
            case EGettingDevice: 
                // found a device now search for a suitable service 
                iLog.LogL( iServiceSearcher->ResponseParams().DeviceName() ); 
                iState = EGettingService; 
                iStatus = KRequestPending;  
                // this means that the RunL can not be called until 
                // this program does something to iStatus 
                iServiceSearcher->FindServiceL( iStatus ); 
                SetActive(); 
                break; 
 
            case EGettingService: 
                textResource = StringLoader::LoadLC ( R_BTOB_FOUND_SERVICE ); 
                iLog.LogL( *textResource ); 
                CleanupStack::PopAndDestroy ( textResource ); 
                iState = EGettingConnection; 
                ConnectToServerL(); 
                break; 
 
            case EGettingConnection: 
                textResource = StringLoader::LoadLC ( R_BTOB_CONNECTED ); 
                iLog.LogL( *textResource ); 
                CleanupStack::PopAndDestroy ( textResource ); 
                iState = EWaitingToSend; 
                break; 
 
            case EWaitingToSend: 
                textResource = StringLoader::LoadLC ( R_BTOB_SENT_OBJECT ); 
                iLog.LogL( *textResource ); 
                CleanupStack::PopAndDestroy ( textResource ); 
                break; 
 
            case EDisconnecting: 
                textResource = StringLoader::LoadLC ( R_BTOB_DISCONNECTED ); 
                iLog.LogL( *textResource); 
                CleanupStack::PopAndDestroy ( textResource ); 
                iState = EWaitingToGetDevice; 
                break; 
 
            default: 
                Panic( EBTObjectExchangeSdpRecordDelete ); 
                break; 
            }; 
        } 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::ConnectL() 
// Connect to a service. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::ConnectL() 
    { 
    if ( iState == EWaitingToGetDevice && !IsActive() ) 
        { 
        iServiceSearcher->SelectDeviceByDiscoveryL( iStatus ); 
        iState = EGettingDevice; 
        SetActive(); 
        } 
    else 
        { 
        HBufC* strClientBusy = StringLoader::LoadLC( R_BTOB_CLIENT_BUSY ); 
        iLog.LogL( *strClientBusy ); 
        CleanupStack::PopAndDestroy ( strClientBusy ); 
        User::Leave( KErrInUse ); 
        } 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::ConnectToServerL() 
// Connect to the server. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::ConnectToServerL() 
    { 
    TObexBluetoothProtocolInfo protocolInfo; 
 
    protocolInfo.iTransport.Copy( KServerTransportName ); 
    protocolInfo.iAddr.SetBTAddr( iServiceSearcher->BTDevAddr() ); 
    protocolInfo.iAddr.SetPort( iServiceSearcher->Port() ); 
 
    if ( iClient ) 
        { 
        delete iClient; 
        iClient = NULL; 
        } 
    iClient = CObexClient::NewL( protocolInfo ); 
     
    iClient->Connect( iStatus ); 
    SetActive(); 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::SendObjectL() 
// Send a message to a service on a remote machine. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::SendObjectL(TFileName& aName) 
    { 
    if ( iState != EWaitingToSend ) 
        { 
        User::Leave( KErrDisconnected ); 
        } 
    else if ( IsActive() )  
        { 
        User::Leave( KErrInUse ); 
        } 
     
    delete iCurrObject; 
    iCurrObject = NULL; 
    iCurrObject = CObexFileObject::NewL(aName); 
     
    TParsePtr parsePtr (aName);         
    TPtrC ptr = parsePtr.NameAndExt(); 
     
    iCurrObject->SetNameL( ptr ); 
         
    iClient->Put( *iCurrObject, iStatus ); 
    SetActive(); 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::StopL() 
// Aborts command. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::StopL() 
    { 
    if ( iClient && iClient->IsConnected() ) 
        { 
        iClient->Abort(); 
        iState = EWaitingToGetDevice; 
        } 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::DisconnectL() 
// Disconnects from the remote machine. 
// ---------------------------------------------------------------------------- 
// 
void CObjectExchangeClient::DisconnectL() 
    { 
    if ( iState == EWaitingToGetDevice ) 
        { 
        return; 
        } 
    if ( iState == EWaitingToSend ) 
        { 
        HBufC* strDisconnecting = StringLoader::LoadLC( R_BTOB_DISCONNECTING ); 
        iLog.LogL( *strDisconnecting ); 
        CleanupStack::PopAndDestroy ( strDisconnecting ); 
        iState = EDisconnecting; 
        iClient->Disconnect( iStatus ); 
        SetActive(); 
        } 
    else  
        { 
        User::Leave( KErrInUse ); 
        } 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::IsBusy() 
// True, if the client is performing some operation.. 
// ---------------------------------------------------------------------------- 
// 
TBool CObjectExchangeClient::IsBusy() 
    { 
    return IsActive(); 
    } 
 
// ---------------------------------------------------------------------------- 
// CObjectExchangeClient::IsConnected() 
// True, if the client is performing some operation.. 
// ---------------------------------------------------------------------------- 
// 
TBool CObjectExchangeClient::IsConnected() 
    { 
    return iState == EWaitingToSend; 
    } 
 
// End of File