/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  PC Connectivity client
*
*/



// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include <e32base.h>
#include <s32mem.h>

// Client - server 
#include "sconpcconnclient.h"
#include "sconpcconnclientserver.h"
#include "debug.h"

// -----------------------------------------------------------------------------
// RSConPCConnSession::RSConPCConnSession()
// Default constructor
// -----------------------------------------------------------------------------
//
EXPORT_C RSConPCConnSession::RSConPCConnSession()
    {
    TRACE_FUNC;
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::~RSConPCConnSession()
// Default destructor
// -----------------------------------------------------------------------------
//
EXPORT_C RSConPCConnSession::~RSConPCConnSession()
    {
    TRACE_FUNC;
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Connect()
// Creates a chunk and server, starts the server connection
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RSConPCConnSession::Connect()
    {
    TRACE_FUNC_ENTRY;
 	
    TInt ret ( KErrNone );

    ret = CreateSession(KSConPCConnServerName,Version());
    
    if ( ret == KErrNotFound || ret == KErrServerTerminated )
    	{
    	ret = LaunchServer();
    	
    	if ( ret == KErrNone || ret == KErrAlreadyExists )
    		{
    		ret = CreateSession( KSConPCConnServerName, Version() );
    		}
    	}
    	
    if ( ret == KErrNone )
    	{
    	ret = CreateAndSendChunkHandle();
    	if ( ret != KErrNone )
    	    {
    	    LOGGER_WRITE("CreateAndSendChunkHandle failed, close session");
    	    Close();
    	    }
    	}
    
    LOGGER_WRITE_1( "RSConPCConnSession::Connect() : returned %d", ret );
    return ret; 
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Close()
// Closes the server connection
// -----------------------------------------------------------------------------
//
EXPORT_C void RSConPCConnSession::Close()
    {
    TRACE_FUNC_ENTRY;
    iChunk.Close();
    RSessionBase::Close();
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Version()
// Returns the version of the client
// -----------------------------------------------------------------------------
//	
TVersion RSConPCConnSession::Version(void) const
    {
    return (TVersion(KSConPCConnServerVersionMajor, 
                               KSConPCConnServerVersionMinor, 
                               KSConPCConnServerVersionBuild));
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Version()
// Forwards a PUT -message to the server
// -----------------------------------------------------------------------------
//	
EXPORT_C TInt RSConPCConnSession::PutPacketL( 
    const TDesC& aNameHeader, const TDesC8& aTypeHeader, CBufFlat*& aBuffer )
    {
    TRACE_FUNC_ENTRY;

    if ( !aBuffer )
        {
        return KErrArgument;
        }

    if ((aBuffer->Size() + aTypeHeader.Size() + 
         aNameHeader.Size()) > KSConPCConnChunkMaxSize)
        {
        LOGGER_WRITE( "RSConPCConnSession::PutPacketL() :\
         WBXML document too big" );
        return KErrTooBig;
        }
	
    TInt ret (KErrNone);
    iChunk.Adjust( KSConPCConnChunkMaxSize );
    RMemWriteStream buf( iChunk.Base(), iChunk.Size() );
	
    buf.WriteInt32L( aNameHeader.Size() );
    buf.WriteL( aNameHeader );

    buf.WriteInt32L( aTypeHeader.Size() );
    buf.WriteL( aTypeHeader );
	
    // WBXML document	
    buf.WriteInt32L( aBuffer->Size() );
    buf.WriteL( aBuffer->Ptr(0) );
    buf.CommitL();
    buf.Close();
    
    TIpcArgs args;
    ret = SendReceive ( EPutMessage, args );

    LOGGER_WRITE_1( "RSConPCConnSession::PutPacketL() : returned %d", ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Version()
// Forwards a GET -message to the server
// -----------------------------------------------------------------------------
//	
EXPORT_C TInt RSConPCConnSession::GetPacketL( 
    const TDesC& aNameHeader, const TDesC8& aTypeHeader, CBufFlat*& aBuffer )
    {
    TRACE_FUNC_ENTRY;

    if ( !aBuffer )
        {
        return KErrArgument;
        }

    TInt ret (KErrNone);
	
    iChunk.Adjust( KSConPCConnChunkMaxSize);
    RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
    writeBuf.WriteInt32L( aNameHeader.Size() );
    writeBuf.WriteL( aNameHeader );
    
    writeBuf.WriteInt32L( aTypeHeader.Size() );
    writeBuf.WriteL( aTypeHeader );

    writeBuf.CommitL();
    writeBuf.Close();
    
    TIpcArgs args;
    ret = SendReceive ( EGetMessage, args );

    if ( ret != KErrNone) 
        {
        LOGGER_WRITE_1( "RSConPCConnSession::GetPacketL() :\
         Send Receive failed with code %d", ret );
        return ret;
        };
	
    // copy data from the chunk
    RMemReadStream readBuf( iChunk.Base(), iChunk.Size() );
    TInt32 length ( 0 );

    aBuffer->Reset();
    length = readBuf.ReadInt32L();
	
    HBufC8* data = HBufC8::NewLC( length );
    TPtr8 dataPtr = data->Des();
	
    readBuf.ReadL( dataPtr, length );
    aBuffer->ExpandL( 0, length );
    aBuffer->Write ( 0, dataPtr );
	
    readBuf.Close();
	
    CleanupStack::PopAndDestroy(); // data;

    LOGGER_WRITE_1( "RSConPCConnSession::GetPacketL()\
     : returned %d", ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// RSConPCConnSession::Version()
// Forwards a Reset -message to the server
// -----------------------------------------------------------------------------
//	
EXPORT_C TInt RSConPCConnSession::ResetServer()
    {
    TRACE_FUNC_ENTRY;
    TInt ret ( KErrNone );
    TIpcArgs args;
    ret = SendReceive ( EResetMessage, args );
    LOGGER_WRITE_1( "RSConPCConnSession::ResetServerL(): ret %d", ret );
    return ret;
    }
    
// -----------------------------------------------------------------------------
// RSConPCConnSession::LaunchServer()
// Launches the server
// -----------------------------------------------------------------------------
//	
TInt RSConPCConnSession::LaunchServer()
	{
	TRACE_FUNC_ENTRY;
	TInt ret( KErrNone );
    
    // Create server
    RProcess p;
    ret = p.Create(KSConPCConnServerExe, KNullDesC);
    
    if ( ret != KErrNone )
        {
        // Loading failed.
        LOGGER_WRITE_1( "RProcess::Create failed, err: %d", ret );
        return ret;
        }
    
    
    TRequestStatus status;
    p.Rendezvous( status );
    
    if ( status != KRequestPending )
        {
        p.Kill(0);		// abort startup
        p.Close();
        LOGGER_WRITE("Abort startup, return KErrGeneral");
        return KErrGeneral;   
        }
    else
        {
        p.Resume();	// logon OK - start the server
        }
    
    User::WaitForRequest(status);
    
    p.Close();
    
	LOGGER_WRITE_1( "RSConPCConnSession::LaunchServerL(): returned %d", status.Int() );
    return status.Int();
	}
	
// -----------------------------------------------------------------------------
// RSConPCConnSession::CreateAndSendChunkHandle()
// Creates a chunk and sends a handle to server
// -----------------------------------------------------------------------------
//	
TInt RSConPCConnSession::CreateAndSendChunkHandle()
	{
	TRACE_FUNC_ENTRY;
	TInt err = iChunk.CreateGlobal( KNullDesC, 
                                    KSConPCConnChunkSize, 
                                    KSConPCConnChunkMaxSize );
    if ( err != KErrNone )
        {
        LOGGER_WRITE_1("iChunk.CreateGlobal failed, err: %d", err);
        return err;
        }                           
    TIpcArgs args;
 	args.Set( 0, iChunk );
 	err = SendReceive( EChunkMessage, args );
    
    LOGGER_WRITE_1("RSConPCConnSession::CreateAndSendChunkHandle : returned: %d", err);
    return err;
	}
	
// End of file