objectexchangeserver_26.cpp

This C++ code example provides a method for transferring objects or chunks of data from one device

/* Copyright (c) 2004, Nokia. All rights reserved */


// INCLUDE FILES
#include <es_sock.h>
#include <StringLoader.h>
#include <BtObjectExchange.rsg>

#include "ObjectExchangeServer.h"
#include "ObjectExchangeServiceAdvertiser.h"
#include "ObjectExchangeProtocolConstants.h"
#include "Log.h"
#include "BTObjectExchange.pan"

#include <btmanclient.h>
#include <bt_sock.h> // New for 8.0

#include <bautils.h>
#include <eikenv.h>

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------
// CObjectExchangeServer::NewL()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CObjectExchangeServer* CObjectExchangeServer::NewL( MLog& aLog )
    {
    CObjectExchangeServer* self = CObjectExchangeServer::NewLC( aLog );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::NewLC()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CObjectExchangeServer* CObjectExchangeServer::NewLC( MLog& aLog )
    {
    CObjectExchangeServer* self = new ( ELeave ) CObjectExchangeServer( aLog );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::CObjectExchangeServer()
// Constructor.
// ----------------------------------------------------------------------------
//
CObjectExchangeServer::CObjectExchangeServer( MLog& aLog )
:  iLog( aLog )
    {
    }

// -----------------------------------------------------------------------------
// CObjectExchangeServer::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CObjectExchangeServer::ConstructL()
    {
    iAdvertiser = CObjectExchangeServiceAdvertiser::NewL();
    User::LeaveIfError(iFs.Connect());
    iTempFile = KTempFile().AllocL();

    //Make sure the file directory exists
    TFileName file = KTempFile();
    TParsePtr parsePtr ( file );
    TFileName filename = parsePtr.DriveAndPath();
    BaflUtils::EnsurePathExistsL( CEikonEnv::Static()->FsSession(), filename);
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::~CObjectExchangeServer()
// Destructor.
// ----------------------------------------------------------------------------
//
CObjectExchangeServer::~CObjectExchangeServer()
    {
    if ( iObexServer && iObexServer->IsStarted() )
        {
        iObexServer->Stop();
        }

    delete iObexServer;
    iObexServer = NULL;

    //This is used for temp purposes, see TransportDownIndication
    delete iObexBufData;
    iObexBufData = NULL;

    delete iObexBufObject;
    iObexBufObject = NULL;

    delete iAdvertiser;
    iAdvertiser = NULL;

    delete iTempFile;
    iTempFile=NULL;

    iFs.Delete( *iTempFile ); //Destroy temp file
    iFs.Close();
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::ErrorIndication()
// Receive error indication.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::ErrorIndication( TInt aError )
    {
    HBufC* strErrorPrefix = NULL;
    //ignore possible error
    TRAPD(ignore,
        strErrorPrefix = StringLoader::LoadL ( R_BTOB_ERROR_PREFIX );
        );
    Log(*strErrorPrefix, aError );
    delete strErrorPrefix;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::TransportUpIndication()
// Called when the underlying socket transport connection is made from
// a remote client to the server
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::TransportUpIndication()
    {
    HBufC* strConnected = NULL;
    //ignore possible error
    TRAPD(ignore,
        strConnected = StringLoader::LoadL( R_BTOB_CONNECTED );
        );
    Log(*strConnected);
    delete strConnected;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::TransportDownIndication()
// Transport connection is dropped.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::TransportDownIndication()
    {
    HBufC* strDisconnecting = NULL;
    //ignore possible error
    TRAPD(ignore,
        strDisconnecting = StringLoader::LoadL( R_BTOB_DISCONNECTING );
        );
    Log(*strDisconnecting );

    if ( iObexBufObject )
        {
        //transfer cancelled, set temporary
        //buffer so obexobject doesn't create the file again
        delete iObexBufData;
        iObexBufData = NULL;
        TRAPD( err, ( iObexBufData = CBufFlat::NewL( KBufferGranularity ) ) );
        if ( err == KErrNone )
            {
            TRAP( err, ( iObexBufObject->SetDataBufL( iObexBufData ) ) );
            }
        }

    if ( iTempFile )
        {
        iFs.Delete( *iTempFile );
        }


    delete strDisconnecting;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::ObexConnectIndication()
// Invoked when an OBEX connection is made from a remote client.
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::ObexConnectIndication(
    const TObexConnectInfo&, const TDesC8& )
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::ObexDisconnectIndication()
// OBEX server has been disconnected.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::ObexDisconnectIndication( const TDesC8& /*aInfo*/ )
    {
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::PutRequestIndication()
// ----------------------------------------------------------------------------
//
CObexBufObject* CObjectExchangeServer::PutRequestIndication()
    {
    delete iObexBufObject;
    iObexBufObject = NULL;
    iFs.Delete( *iTempFile );

    //Can't leave here
    TRAPD(err,
        {
        iObexBufObject = CObexBufObject::NewL( NULL );
        //The file is created if it doesn't exist
        iObexBufObject->SetDataBufL( *iTempFile );
        }
    );

    if(err)
        {
        Log(KPutRequestIndication, err);
        delete iObexBufObject;
        iObexBufObject=NULL;
        return NULL;
        }

    return iObexBufObject;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::PutPacketIndication()
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::PutPacketIndication()
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::PutCompleteIndication()
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::PutCompleteIndication()
    {
    Log(iObexBufObject->Name());
    TFileName file = KTempFile();
    TParsePtr parsePtr ( file );
    TFileName filename = parsePtr.DriveAndPath();
    filename.Append(iObexBufObject->Name());

    delete iObexBufObject;
    iObexBufObject = NULL;

    TInt err2 = BaflUtils::RenameFile(iFs, KTempFile, filename, CFileMan::EOverWrite);
    if( err2 )
        {
        Log(KCopyFileError, err2 );
        }

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::GetRequestIndication()
// Called when a full get request has been received from the client.
// ----------------------------------------------------------------------------
//
CObexBufObject* CObjectExchangeServer
::GetRequestIndication( CObexBaseObject* /*aRequiredObject*/ )
    {
    return NULL;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::GetPacketIndication()
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::GetPacketIndication()
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::GetCompleteIndication()
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::GetCompleteIndication()
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::SetPathIndication()
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::SetPathIndication( const CObex
                                              ::TSetPathInfo& /*aPathInfo*/,
                                              const TDesC8& /*aInfo*/ )
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::AbortIndication()
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::AbortIndication()
    {
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::DisconnectL()
// Disconnects the server.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::DisconnectL()
    {
    if ( iObexServer && iObexServer->IsStarted() )
        {
        iObexServer->Stop();
        }

    delete iObexServer;
    iObexServer = NULL;

    if ( iAdvertiser->IsAdvertising() )
        {
        iAdvertiser->StopAdvertisingL();
        }
    HBufC* strServerStopped = StringLoader::LoadLC ( R_BTOB_SERVER_STOPPED );
    Log( *strServerStopped );
    CleanupStack::PopAndDestroy ( strServerStopped );
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::StartL()
// Starts the server.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::StartL()
    {
    TRAPD( err,InitialiseServerL() );

    if ( err != KErrNone )
        {
        HBufC* strFailed = StringLoader::LoadLC ( R_BTOB_STR_FAILED );
        iLog.LogL( *strFailed, err );
        CleanupStack::PopAndDestroy ( strFailed );
        DisconnectL();
       }
    else
        {
        TParsePtrC parsePtr ( iTempFile->Des() );
        //Log current working directory
        iLog.LogL( KCurrentWorkingDirectory );
        iLog.LogL(parsePtr.DriveAndPath());
        }
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::InitialiseServerL()
// Initialises the server.
// ----------------------------------------------------------------------------
//
void CObjectExchangeServer::InitialiseServerL()
    {
    if ( iObexServer )
        {
        ASSERT( IsConnected() ); // server already running
        return;
        }

    // Set the Socket's security with parameters,
    // Authentication, Encryption, Authorisation and Denied
    // Method also return the channel available to listen to.
    TInt channel ( SetSecurityWithChannelL( EFalse, EFalse, ETrue, EFalse ) );

    // start the OBEX server
    TObexBluetoothProtocolInfo obexProtocolInfo;
    obexProtocolInfo.iTransport.Copy( KServerTransportName );
    obexProtocolInfo.iAddr.SetPort( channel );

    iObexServer = CObexServer::NewL( obexProtocolInfo );
    iObexServer->Start( this );

    // advertise this service
    iAdvertiser->StartAdvertisingL( channel );
    iAdvertiser->UpdateAvailabilityL( ETrue );

    HBufC* strServerStarted = StringLoader::LoadLC ( R_BTOB_SERVER_STARTED );
    iLog.LogL( *strServerStarted );
    CleanupStack::PopAndDestroy ( strServerStarted );
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::SetSecurityWithChannelL()
// Sets the security on the channel port and returns the available port.
// ----------------------------------------------------------------------------
//
TInt CObjectExchangeServer::SetSecurityWithChannelL( TBool aAuthentication,
                                                  TBool aEncryption,
                                                  TBool aAuthorisation,
                                                  TBool aDenied )

    {

    // Local variable to channel to listen to.
    TInt channel;

    RSocketServ socketServer;

    // Connect to SocetServer
    User::LeaveIfError( socketServer.Connect() );
    CleanupClosePushL( socketServer );

    RSocket socket;
    // Open the Socket connection
    User::LeaveIfError( socket.Open( socketServer, KStrRFCOMM ) );  // "RFCOMM"
    CleanupClosePushL( socket );

    // Retreive to one channel that is available.
    User::LeaveIfError( socket.GetOpt( KRFCOMMGetAvailableServerChannel,KSolBtRFCOMM, channel ) );

    // Set the Socket's Port.
    TBTSockAddr sockaddr;
    sockaddr.SetPort( channel );

    // Set the security according to.
    TBTServiceSecurity serviceSecurity;
    serviceSecurity.SetUid ( KUidBTObjectExchangeApp );
    serviceSecurity.SetAuthentication ( aAuthentication );
    serviceSecurity.SetEncryption ( aEncryption );
    serviceSecurity.SetAuthorisation ( aAuthorisation );
    serviceSecurity.SetDenied( aDenied );

    // Attach the security settings.
    sockaddr.SetSecurity(serviceSecurity);

    // Bind and start listeing the port with security setted,
    User::LeaveIfError(socket.Bind(sockaddr));
    User::LeaveIfError(socket.Listen(KSimultainousSocketsOpen ) );

    // now close the socket and the socket server
    CleanupStack::PopAndDestroy();  //  socket
    CleanupStack::PopAndDestroy();  //  socketServer

    return channel;
    }

// ----------------------------------------------------------------------------
// CObjectExchangeServer::IsConnected()
// Results true if the server is connected.
// ----------------------------------------------------------------------------
//
TBool CObjectExchangeServer::IsConnected()
    {
    return iObexServer != NULL;
    }

void CObjectExchangeServer::Log(const TDesC& aText, TInt KErrCode)
    {
    //Ignore possible logging errors
    if( KErrCode == KErrNone )
        {
        TRAPD(ignore, iLog.LogL(aText) );
        }
    else
        {
        TRAPD(ignore, iLog.LogL(aText, KErrCode) );
        }
    }

// End of File