/*

* Copyright (c) 2006 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: CBSClient.cpp

*

*/

//  INCLUDE FILES

#include "cbsclient.h"

#include "bsclientdefs.h"

#include "bsprocessstarter.h"

#include "bsserverdefs.h"

#include "mbselement.h"

#include "bselementfactory.h"

#include "cbsbitmap.h"

#include "cbsbrandobserver.h"

#include <e32base.h>

#include <s32mem.h>

#include "debugtrace.h"

// ==============================================================

// ======================== CLIENT ==============================

// ==============================================================

// Destructor

RBSClient::~RBSClient()

    {

#if _BullseyeCoverage

    cov_write();

#endif

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

RBSClient::RBSClient()

    {

    }

// -----------------------------------------------------------------------------

// RBSClient::Connect()

// -----------------------------------------------------------------------------

//

TInt RBSClient::Connect()

    {

    TRACE( T_LIT("RBSClient::Connect() begin") );

    TFileName fullExePath;

    BSProcessStarter::FullExePathForClienLocation( KBSServerExe,

                                                 fullExePath );

    return BSProcessStarter::ConnectToServer( fullExePath,

                                            KNullDesC,

                                            NULL,

                                            *this,

                                            KBSServerName,

                                            TVersion( KBSVersionMajor,

                                                      KBSVersionMinor,

                                                      KBSVersionBuild ),

                                            KBSMsgSlotCount );

    }

// -----------------------------------------------------------------------------

// RBSClient::Close()

// -----------------------------------------------------------------------------

//

void RBSClient::Close()

    {

    TRACE( T_LIT("RBSClient::Close() begin") );

    RSessionBase::Close();

    }

// -----------------------------------------------------------------------------

// RBSClient::Close()

// -----------------------------------------------------------------------------

//

void RBSClient::StartTransactionL(  const TDesC8& aApplicationId,

        				  const TDesC8& aBrandId,

        				  const TDesC8& aDefaultBrandId,

        				  TLanguage aLanguage,

        				  TTransactionType aType,

        				  TInt aReserved )

	{

	TRACE( T_LIT("RBSClient::StartTransactionL() begin") );

	InitClientL( aApplicationId, aBrandId, aDefaultBrandId, 

				 aLanguage, aType, aReserved );

	}

// -----------------------------------------------------------------------------

// RBSClient::Close()

// -----------------------------------------------------------------------------

//

TInt RBSClient::StopTransactionL( const TDesC8& /*aApplicationId*/,

        				  const TDesC8& /*aBrandId*/,

        				  TLanguage /*aLanguage*/,

        				  TInt /*aReserved*/ )

	{

	TRACE( T_LIT("RBSClient::StopTransactionL() begin") );

	TInt returnValue = 0;

    TPckg<TInt> pack( returnValue );

    TIpcArgs args( &pack );

    TInt err = SendReceive( EBSStopTransaction, args );

    User::LeaveIfError( err );

	return returnValue;

	}

// -----------------------------------------------------------------------------

// RBSClient::Close()

// -----------------------------------------------------------------------------

//

void RBSClient::CancelTransactionL( const TDesC8& aApplicationId,

        				  const TDesC8& aBrandId,

        				  TLanguage aLanguage,

        				  TInt aReserved )

	{

	TIpcArgs args = CreateArgumentsL( aApplicationId, aBrandId,

					  				  aLanguage, aReserved );

	TInt err = SendReceive( EBSCancelTransaction, args );

	User::LeaveIfError( err );

	}

// -----------------------------------------------------------------------------

// RBSClient::InitClientL()

// -----------------------------------------------------------------------------

//

void RBSClient::InitClientL( const TDesC8& aApplicationId,

        				  const TDesC8& aBrandId,

        				  const TDesC8& aDefaultBrandId,

        				  TLanguage aLanguage,

        				  TTransactionType aType,

        				  TInt aReserved )

	{

	TRACE( T_LIT("RBSClient::InitClientL() begin aAppId[%S],aBrandId[%S],TAType[%d]"),&aApplicationId,&aBrandId,aType );

	CBufFlat* flatBuf = CBufFlat::NewL( aDefaultBrandId.Length() + aBrandId.Length() + 2 );

	CleanupStack::PushL( flatBuf );

 	RBufWriteStream stream;

	CleanupClosePushL( stream );

	stream.Open( *flatBuf );

	stream.WriteInt16L( aBrandId.Length() );

	stream.WriteL( aBrandId );

	stream.WriteInt16L( aDefaultBrandId.Length() );

	stream.WriteL( aDefaultBrandId );

    TPtr8 ptrElement( flatBuf->Ptr(0) );

	// set the arguments for the message

	TIpcArgs args(  &aApplicationId );

    args.Set( 1,  &ptrElement );

    args.Set( 2, aLanguage );

    args.Set( 3, aReserved );

	TInt operation = 0;

	switch( aType )

		{

		case EBSTxInstall:

			{

			operation = EBSInitInstall;

			break;

			}

		case EBSTxUninstall:

			{

			operation = EBSInitUninstall;

			break;

			}

		case EBSTxAppend:

			{

			operation = EBSInitAppend;

			break;

			}

		case EBSTxReplace:

			{

			operation = EBSInitReplace;

			break;

			}

		case EBSTxAccess:

			{

			operation = EBSInitAccess;

			break;

			}

		default:

			{

			User::Leave( KErrArgument );

			break;

			}

		}		

	TInt err = SendReceive( operation, args );

	TRACE( T_LIT("RBSClient::InitClientL() 1st SendReceive err=%d"),err );

	CleanupStack::PopAndDestroy( 2, flatBuf ); // stream, flatBuf

	User::LeaveIfError( err );

	User::LeaveIfError( SendReceive( EBSStartTransaction ) );

	TRACE( T_LIT("RBSClient::InitClientL() end") );

	}

// -----------------------------------------------------------------------------

// RBSClient::CreateArgumentsL()

// -----------------------------------------------------------------------------

//

TIpcArgs RBSClient::CreateArgumentsL( const TDesC8& aApplicationId,

        				  const TDesC8& aBrandId,

        				  TLanguage aLanguage,

        				  TInt aReserved )

	{

	// set the arguments for the message

	TIpcArgs args(  &aApplicationId );

    args.Set( 1,  &aBrandId );

    args.Set( 2, aLanguage );

    args.Set( 3, aReserved );

    return args;

	}

// -----------------------------------------------------------------------------

// RBSClient::InsertL()

// -----------------------------------------------------------------------------

//

void RBSClient::InsertL( MBSElement* aElement )

	{

	SendUpdateL( aElement, EBSInstall );

	}

// -----------------------------------------------------------------------------

// RBSClient::ReplaceL()

// -----------------------------------------------------------------------------

//

void RBSClient::ReplaceL( MBSElement* aElement )

	{

	SendUpdateL( aElement, EBSReplace );

	}

// -----------------------------------------------------------------------------

// RBSClient::AppendL()

// -----------------------------------------------------------------------------

//

void RBSClient::AppendL( MBSElement* aElement )

	{

	SendUpdateL( aElement, EBSAppend );

	}

// -----------------------------------------------------------------------------

// RBSClient::SendUpdateL()

// -----------------------------------------------------------------------------

//

void RBSClient::SendUpdateL( MBSElement* aElement, TBSMessages aMessage )

	{

	// FIXME magic number

	CBufFlat* flatBuf = CBufFlat::NewL( 128 );

	CleanupStack::PushL( flatBuf );

 	RBufWriteStream elementStream;

	CleanupClosePushL( elementStream );

	elementStream.Open( *flatBuf );

	aElement->ExternalizeL( elementStream );

    TPtr8 ptrElement( flatBuf->Ptr(0) );

	TIpcArgs args( &ptrElement );

	TInt err = SendReceive( aMessage, args );

	CleanupStack::PopAndDestroy(); // elementStream

	CleanupStack::PopAndDestroy( flatBuf );

	User::LeaveIfError( err );

	}

// -----------------------------------------------------------------------------

// RBSClient::GetTextL()

// -----------------------------------------------------------------------------

//

void RBSClient::GetTextL( const TDesC8& aId, HBufC*& aValue )

    {

	TInt size = 0;

    TPckg<TInt> pack( size );

	TIpcArgs args( &aId );

	args.Set( 1, &pack );

    TInt err = SendReceive( EBSPrepareText, args );

    User::LeaveIfError( err );

	aValue = HBufC::NewL( size );

	TPtr ptrBuf( aValue->Des() );

    args.Set( 2, &ptrBuf );    

    err = SendReceive( EBSGetText, args );

    if( err )

    	{

    	delete aValue;

    	aValue = NULL;

    	User::Leave( err );

    	}

    }

// -----------------------------------------------------------------------------

// RBSClient::GetIntL()

// -----------------------------------------------------------------------------

//

void RBSClient::GetIntL( const TDesC8& aId, TInt& aValue )

    {

    TPckg<TInt> pack( aValue );

    TIpcArgs args( &aId);

    args.Set( 1, &pack );

    TInt err = SendReceive( EBSGetInt, args );

    User::LeaveIfError( err );

    }

void RBSClient :: isBrandUpdateRequiredL (TInt & aUpdateRequired)

{

	//TIpcArgs args;

    TPckg<TInt> pack (aUpdateRequired);

	//args.Set (0, &pack);

	TInt err = SendReceive (EBSIsBrandUpdateRequired, TIpcArgs (&pack));

	User :: LeaveIfError (err);

}

// -----------------------------------------------------------------------------

// RBSClient::GetTextL()

// -----------------------------------------------------------------------------

//

void RBSClient::GetBufferL( const TDesC8& aId, HBufC8*& aValue )

    {

	TInt size = 0;

    TPckg<TInt> pack( size );

	TIpcArgs args( &aId );

	args.Set( 1, &pack );

    TInt err = SendReceive( EBSPrepareBuffer, args );

    User::LeaveIfError( err );

	aValue = HBufC8::NewL( size );

	TPtr8 ptrBuf( aValue->Des() );

    args.Set( 2, &ptrBuf );    

    err = SendReceive( EBSGetBuffer, args );

    if( err )

    	{

    	delete aValue;

    	aValue = NULL;

    	User::Leave( err );

    	}

    }

// -----------------------------------------------------------------------------

// RBSClient::GetSeveralL()

// -----------------------------------------------------------------------------

//

MBSElement* RBSClient::GetSeveralL( MDesC8Array& aIds )

	{

	TInt size = 0;

    TPckg<TInt> pack( size );

    TIpcArgs args;

    args.Set( 0, &pack );

	// FIXME magic number

	CBufFlat* flatBuf = CBufFlat::NewL( 128 );

	CleanupStack::PushL( flatBuf );

 	RBufWriteStream idStream;

	CleanupClosePushL( idStream );

	idStream.Open( *flatBuf );

	ExternalizeIdArrayL( idStream, aIds );

	TPtr8 flatPtr = flatBuf->Ptr(0);

	args.Set( 1, &flatPtr );

	// get the size of the data

	TInt err = SendReceive( EBSPrepareSeveral, args );

	CleanupStack::PopAndDestroy(); // idStream

	CleanupStack::PopAndDestroy( flatBuf );

	User::LeaveIfError( err );

    HBufC8* buf = HBufC8::NewLC( size );

    TPtr8 ptrBuf( buf->Des() );

    TIpcArgs msgArgs;

    msgArgs.Set( 0, &ptrBuf );

	err = SendReceive( EBSGetSeveral, msgArgs );

	TInt length = buf->Size();

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( *buf );

	MBSElement* returnValue = InternalizeElementL( readStream );

	CleanupStack::PopAndDestroy(); // readStream

	CleanupStack::PopAndDestroy( buf ); // buf

	User::LeaveIfError( err );

	return returnValue;

	}

// -----------------------------------------------------------------------------

// RBSClient::GetFileL()

// -----------------------------------------------------------------------------

//

void RBSClient::GetFileL( const TDesC8& aId, RFile& aFile )

	{

	TInt fsh;

	TPckgBuf<TInt> fh;

	TIpcArgs args( &fh );

	args.Set( 2, &aId );

	fsh = SendReceive( EBSGetFile, args );

	TInt err = aFile.AdoptFromServer( fsh, fh() );

	User::LeaveIfError( err );

	}

// -----------------------------------------------------------------------------

// RBSClient::GetStructureL()

// -----------------------------------------------------------------------------

//

MBSElement* RBSClient::GetStructureL( const TDesC8& aId )

	{

	TInt size = 0;

    TPckg<TInt> pack( size );

    TIpcArgs args;

    args.Set( 0, &pack );

	args.Set( 1, &aId );

	// get the size of the data

	TInt err = SendReceive( EBSPrepareStructure, args );

	User::LeaveIfError( err );

    HBufC8* buf = HBufC8::NewLC( size );

    TPtr8 ptrBuf( buf->Des() );

    TIpcArgs msgArgs;

    msgArgs.Set( 0, &ptrBuf );

	err = SendReceive( EBSGetStructure, msgArgs );

	TInt length = buf->Size();

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( *buf );

	MBSElement* returnValue = InternalizeElementL( readStream );

	CleanupStack::PopAndDestroy(); // readStream

	CleanupStack::PopAndDestroy( buf ); // buf

	User::LeaveIfError( err );

	return returnValue;

	}

// -----------------------------------------------------------------------------

// RBSClient::InternalizeElementL()

// -----------------------------------------------------------------------------

//

MBSElement* RBSClient::InternalizeElementL( RReadStream& aStream )

    {

    MBSElement* returnValue= NULL;

    // Write common header for all elements

    TBSElementType type = (TBSElementType)aStream.ReadInt16L();

    TInt idSize = aStream.ReadInt16L();

	HBufC8* elementId = HBufC8::NewLC( idSize );

	TPtr8 elementIdPtr = elementId->Des();

    if( idSize > 0 )

        {

        // read ID only if it's defined

        aStream.ReadL( elementIdPtr, idSize );

        elementIdPtr.SetLength( idSize );// Set length

        }

// Ptr() returns a pointer to the start address of decriptor data,

// TPtrC constructor then parses the data until null terminator met.

// This results in wrong descriptor length & bad data!

// Solution is either 

// 1) to use PtrZ() which appends a zero terminator,

// or 2) pass to constructor an object that has length data.

// Option 2) is less prone to errors, so use it.

// In general, assignment operator with descriptors should be avoided!

// So use TPtrC16(const TDesC16 &aDes) instead 

// of TPtrC16(const TUint16 *aString)!

    TPtrC8 idPtrC( *elementId );//idPtrC creation moved here so it will be updated correctly.

	if( elementId->Length() == 0 )

		{

		CleanupStack::PopAndDestroy( elementId );

		elementId = NULL;

		idPtrC.Set( KNullDesC8 );

		}

    // Write element type specific data

    switch( type )

        {

        case EBSInt:

            {

            TInt intData = aStream.ReadInt16L();

			returnValue = BSElementFactory::CreateBSElementL( idPtrC,

															  EBSInt,