/*

* 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:

*

*/

#include <e32base.h>

#include <ecom/ecomresolverparams.h>

#include <ecom/ecom.h>

#include "DataDealer.h"

#include "DataDealerParams.h"

// We cannot use UIDs that are reserved from Symbian (neither protected

// nor unprotected) since Publish&Subscribe properties require that

// the running process they are defined in has the secure id that matches

// the id of the P&S property (secure id check is not made for legacy UIDs

// which are < 0x10273357).

// So we use a UID from development range: 0x00000000 - 0x0FFFFFFF

const TUid KPropertyCategory = { 0x077A5355 };

//const TUid KPropertyCategory = { 0xA00023E0 };

// Time to wait before re-checking property values

const TInt KWaitForPropertyTime( 100000 );

const TUid KDataDealerImplUID1 = {0xA00023E2};

/**

 * @param aProducer Set to ETrue if this is a producer instance.

 * @param aKey The Publish&Subscribe key that is used for data passing.

 */

CDataDealer* CDataDealer::NewL( const TBool aProducer, const TUint aKey )

	{

	TDataDealerParams params( aProducer, aKey );

	TAny* implementation =

		REComSession::CreateImplementationL( KDataDealerImplUID1,

		                                    _FOFF( CDataDealer, iDtorID ),

											&params );

	CDataDealer* self = new (ELeave) CDataDealer( params.iProducer, params.iKey );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CDataDealer::~CDataDealer()

	{

	// wait that the property is empty (= data consumed)

	TRAPD( err, WaitForConsumerL() );

	if( err != KErrNone )

		{

		// WaitForConsumerL error!

		}

	// The producer is responsible of creating and destroying the property

	if( iProducer )

		{

		// CDataDealer: This is a producer instance, delete the P&S property

		TInt err = iProperty.Delete( KPropertyCategory, iKey );

		if( err != KErrNone )

			{

			// CDataDealer: Could not delete property

			}

		iProperty.Close();

		}

	// Notify the ECom server that we released one implementation of some

	// DLL. When the counter hits zero ECom server may unload the DLL.

	REComSession::DestroyedImplementation( iDtorID );

	}

void CDataDealer::ConstructL()

	{

	// The producer is responsible of creating and destroying the property

	if( iProducer )

		{

		// CDataDealer: This is a producer instance, create the P&S property

		TInt err = iProperty.Define( KPropertyCategory,

											  iKey,

											  RProperty::EByteArray,

											  iPropertySize );

		if( err == KErrAlreadyExists )

			{

			// Property already exists. Clear contents.

			User::LeaveIfError( iProperty.Set( KPropertyCategory, iKey, KNullDesC8 ) );

			}

		else if( err != KErrNone )

			{

			// Could not create pub&sub property

			User::Leave( err );

			}

		}

	// Consumer waits that the property is created by producer

	else

		{

		WaitForPropertyToBeCreatedL();

		}

	}

/**

 * Consumer uses this to wait for the property to be created by producer

 * when DataDealer is constructed.

 */

void CDataDealer::WaitForPropertyToBeCreatedL()

	{

	const TInt KTempPropertyValueLength(2);

	TBuf8<KTempPropertyValueLength> tempValue;

	TInt err = iProperty.Get( KPropertyCategory, iKey, tempValue );

	while( err == KErrNotFound )

		{

		// Property did not created yet, wait

		const TInt KWaitForProperty( 500000 );

		// User::After here is not a critical error. It is used here to wait for the RProperty instance

		// to be created. The best solution would be to use RProperty notifications to do that but it is

		// currently too heavy considering how DataDealer is used: in testing context without any UI

		User::After( KWaitForProperty );

		err = iProperty.Get( KPropertyCategory, iKey, tempValue );

		}

	if( err != KErrNone && err != KErrOverflow )

		{

		// Unexpected error!

		User::Leave( err );

		}

	}

CDataDealer::CDataDealer( const TBool aProducer, const TUint aKey )

: 	CBase(),	

	// Use KMaxPropertySize as default size to ensure "real time" setting of a value

	iPropertySize( RProperty::KMaxPropertySize ),

	iProducer( aProducer ),

	iKey( aKey ),

	iDtorID()

	{

	}

/**

 * Produce data to the data storage defined in the constructor.

 */

void CDataDealer::ProduceDataL( const TDesC8& aData )

	{

	// "CDataDealer::ProduceDataL: %S", &aData

	// Check for misuse

	if( !iProducer ) User::Leave( KErrNotSupported );

	for( TInt i(0); i < aData.Length(); i += iPropertySize )

		{

		// wait that the property is empty (= data consumed)

		WaitForConsumerL();

		// Then write data block-by-block

		TPtrC8 dataBlock( KNullDesC8 );

		if( ( i + iPropertySize ) < aData.Length() )

			dataBlock.Set( aData.Mid( i, iPropertySize ) );

		else

			dataBlock.Set( aData.Mid( i, aData.Length() - i ) );

		// Write single block

		User::LeaveIfError( iProperty.Set( KPropertyCategory, iKey, dataBlock ) );

		}

	}

/**

 * Wait synchronously until the consumer has deleted the data we have produced.

 * Used by data dealer that is producing data.

 */

void CDataDealer::WaitForConsumerL()

	{

	const TInt KTempPropertyValueLength(2);

	TBuf8<KTempPropertyValueLength> tempValue;

	TInt err = iProperty.Get( KPropertyCategory, iKey, tempValue );

	if( err != KErrOverflow && err != KErrNone )

		{

		// un-expected error

		// CDataDealer: Could not get property value.

		User::Leave( err );

		}

	while( err == KErrOverflow || tempValue != KNullDesC8 )

		{

		// Not empty yet, wait

		// User::After here is not a critical error. It is used here to wait for the RProperty instance

		// to be created. The best solution would be to use RProperty notifications to do that but it is

		// currently too heavy considering how DataDealer is used: in testing context without any UI

		User::After( KWaitForPropertyTime ); // CSI: 92 #

		err = iProperty.Get( KPropertyCategory, iKey, tempValue );

		}

	}

/**

 * @param aData On return contains a pointer to heap descriptor containing the received data.

 */

void CDataDealer::ConsumeDataL( HBufC8*& aData )

	{

	// Check for misuse

	if( iProducer ) User::Leave( KErrNotSupported );

	TInt err( KErrNone );

	HBufC8* data = HBufC8::NewLC( iPropertySize );

	TPtr8 dataPtr = data->Des();

	const TInt KMinHBufCLength(1);

	HBufC8* wholeData = HBufC8::NewLC( KMinHBufCLength );

	// Loop until the property is destroyed by the producer

	for( TInt i(0); err != KErrNotFound; )

		{

		// check if the property exists and has data

		err = iProperty.Get( KPropertyCategory, iKey, dataPtr );

		TBool empty = ( dataPtr == KNullDesC8 );

		if( err == KErrNone )

			{

			if( empty )

				{

				// Property empty, cannot consume, wait

				// If the property exists but is empty, wait for data

				// User::After here is not a critical error. It is used here to wait for the RProperty instance

				// to be created. The best solution would be to use RProperty notifications to do that but it is

				// currently too heavy considering how DataDealer is used: in testing context without any UI

				User::After( KWaitForPropertyTime ); // CSI: 92 #

				}

			else

				{

				// Clear the property...

				User::LeaveIfError( iProperty.Set( KPropertyCategory, iKey, KNullDesC8 ) );

				// Append the retrieved data to the buffer that will be returned

				// CDataDealer: Data ready, consumed

				HBufC8* newWholeData = wholeData->ReAllocL( wholeData->Length() + iPropertySize );

				CleanupStack::Pop( wholeData );

				wholeData = newWholeData;

				CleanupStack::PushL( wholeData );

				wholeData->Des().Append( *data );

				// Clear the buffer

				dataPtr.Zero();

				// ..and set new storage index

				i += iPropertySize;

				}

			}

		// If the property is not found, it means that there is (no more) data to be consumed available

		else if( err != KErrNotFound )

			{

			// CDataDealer: Could not open the property.

			User::Leave( err );

			}

		}

	// "CDataDealer::ConsumeDataL: %S", wholeData

	// Ownership transferred

	CleanupStack::Pop( wholeData );

	aData = wholeData;

	CleanupStack::PopAndDestroy( data );

	}

/**

 * Consume data that is produced to the data storage defined in the constructor.

 * @param aData On return contains a pointer to heap descriptor containing the received data.

 * @param aMaxSize The maximum size of the data block.

 * @param aMore ETrue if there is more data to be consumed.

 */

void CDataDealer::ConsumeDataL( HBufC8*& aData, const TInt aMaxSize, TBool& aMore )

	{

	// Check for misuse

	if( iProducer ) User::Leave( KErrNotSupported );

	HBufC8* data = HBufC8::NewLC( iPropertySize );

	TPtr8 dataPtr = data->Des();

	// Loop until data is produced to the property

	TInt err( KErrNone );

	while( err != KErrNotFound && dataPtr.Length() == 0 )

		{

		// check if the property exists and has data

		err = iProperty.Get( KPropertyCategory, iKey, dataPtr );

		TBool empty = ( dataPtr == KNullDesC8 );

		if( err == KErrNone )

			{

			if( empty )

				{

				// If the property exists but is empty, wait for data

				// User::After here is not a critical error. It is used here to wait for the RProperty instance

				// to be created. The best solution would be to use RProperty notifications to do that but it is

				// currently too heavy considering how DataDealer is used: in testing context without any UI

				User::After( KWaitForPropertyTime ); // CSI: 92 #

				}

			else if( dataPtr.Length() > aMaxSize )

				{

				// Too long data (%i, max: %i): consuming only the first block", dataPtr.Length(), aMaxSize

				// Consuming only the first aMaxSize characters; save the rest of the data to the property

				iProperty.Set( KPropertyCategory, iKey, dataPtr.Right( dataPtr.Length() - aMaxSize ) );

				// Take the first aMaxSize characters and ignore the rest

				data->Des().Copy( dataPtr.Left( aMaxSize ) );

				}

			else

				{

				// Clear the property...

				User::LeaveIfError( iProperty.Set( KPropertyCategory, iKey, KNullDesC8 ) );

				}

			}

		// If the property is not found, it means that there is (no more) data to be consumed available

		else if( err == KErrNotFound )

			{

			// CDataDealer: No more data in the property (KErrNotFound)

			aMore = EFalse;

			}

		else

			{

			// CDataDealer: Could not open the property.

			aMore = EFalse;

			User::Leave( err );

			}

		}

	CleanupStack::Pop( data );

	aData = data;

	}