/*

* Copyright (c) 2002-2004 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: Implementation of customization components

*

*/

// INCLUDE FILES

#include    "TestDmCallback.h"

#include "StifLogger.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CTestDmCallback::CTestDmCallback

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

// might leave.

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

//

CTestDmCallback::CTestDmCallback( CStifLogger *aLog )

	: iLog( aLog )

	, iMappingURI( 16 )

	, iMappingLuid( 16 )

//	RPointerArray<CBufBase> iResultObjects;

	, iResultTypes( 16 )

//	RArray<TInt> iStatusArray;

    {

    }

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

// CTestDmCallback::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTestDmCallback::ConstructL()

    {

//	CDesC8ArrayFlat *iMappingURI;

//	CDesC8ArrayFlat:: *iMappingURI;

//	CDesC8ArrayFlat *iMappingLuid;

	/* Containers for results */

//	RPointerArray<CBufBase> iResultObjects;

//	CDesC8ArrayFlat *iResultTypes;

	/* Container for status */

//	RArray<TInt> iStatusArray;

    }

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

// CTestDmCallback::NewL

// Two-phased constructor.

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

//

CTestDmCallback* CTestDmCallback::NewL( CStifLogger *aLog )

    {

    CTestDmCallback* self = new( ELeave ) CTestDmCallback( aLog );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CTestDmCallback::~CTestDmCallback()

    {

    }

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

// CTestDmCallback::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

/*?type CTestDmCallback::?member_function(

    ?arg_type arg,

    ?arg_type arg )

    {

    ?code

    }

*/

void CTestDmCallback::SetResultsL( 

	TInt aResultsRef, 

	CBufBase& aObject,

	const TDesC8& aType )

	{

	TPtrC8 obj = aObject.Ptr( 0 ).Left( 120 );

	iLog->Log( _L8( "SetResults, ref=%d, object='%S', type='%S'" ), aResultsRef, &obj, &aType );

	if (aResultsRef < 0 || aResultsRef >= iResultObjects.Count() || aResultsRef >= iResultTypes.Count())

		{

		User::Leave( KErrArgument );

		}

//sf-	iResultObjects[ aResultsRef ]->Copy( aObject );

	iResultObjects[ aResultsRef ]->Reset();

//sf-	iResultObjects[ aResultsRef ]->InsertL( 0, aObject.Ptr( 0 ) );

	for (TInt i = 0 ; i < aObject.Size() ; )

		{

		TPtrC8 ptr = aObject.Ptr( i );

		iResultObjects[ aResultsRef ]->InsertL( i, ptr );

		i += ptr.Length();

		}

//sf-	iResultTypes[ aResultsRef ] = aType;

	iResultTypes.Delete( aResultsRef );

	iResultTypes.InsertL( aResultsRef, aType );

	}

void CTestDmCallback::SetStatusL( TInt aStatusRef,

							 MSmlDmAdapter::TError aErrorCode ) 

	{

	iLog->Log( _L8( "SetStatusL, ref=%d, code=%d" ), aStatusRef, aErrorCode );

	if (aStatusRef < 0 || aStatusRef >= iStatusArray.Count() )

		{

		User::Leave( KErrArgument );

		}

	iStatusArray[ aStatusRef ] = aErrorCode;

	}

void CTestDmCallback::SetMappingL( const TDesC8& aURI, const TDesC8& aLUID ) 

	{

	TPtrC8 ptrUri = aURI;

	TPtrC8 ptrLuid = aLUID.Left( 80 );

	iLog->Log( _L8( "SetMappingL, aURI='%S', aLUID='%S'" ), &ptrUri, &ptrLuid );

	TInt idx = FindMappingURI( aURI );

	if (idx < 0)

		{

		iMappingURI.AppendL( aURI );

		iMappingLuid.AppendL( aLUID );

		}

	else

		{

//sf-		iMappingLuid[ idx ] = aLUID;

		iMappingLuid.Delete( idx );

		iMappingLuid.InsertL( idx, aLUID );

		}

	}

HBufC8* CTestDmCallback::GetLuidAllocL( const TDesC8& aURI ) 

	{

	iLog->Log( _L8( "GetLuidAllocL, aURI='%S'" ), &aURI );

	HBufC8* ptr = GetLuidL( aURI ).AllocL();

	return ptr;

/*	HBufC8* ptr = 0;

	TInt idx = FindMappingURI( aURI );

	if (idx < 0)

		{

		ptr = HBufC8::NewL(2);

		}

	else

		{

		ptr = iMappingLuid[ idx ].AllocL();

		}

	return ptr;

*/	}

TPtrC8 CTestDmCallback::GetLuidL( const TDesC8& aURI ) 

	{

	iLog->Log( _L8( "GetLuidL, aURI='%S'" ), &aURI );

	TPtrC8 ptr;

	TInt idx = FindMappingURI( aURI );

	if (idx < 0)

		{

		ptr.Set( KNullDesC8 );

		}

	else

		{

		ptr.Set( iMappingLuid[ idx ] );

		}

	return ptr;

	}

/* New functions */

TInt CTestDmCallback::FindMappingURI( const TDesC8& aURI )

	{

	TInt idx = iMappingURI.Count() - 1;

	while (idx >= 0 && iMappingURI[ idx ] != aURI)

		{

		idx--;

		}

	return idx;

	}

TInt CTestDmCallback::GetNewResultsRefL( )

	{

	CBufBase* obj = CBufFlat::NewL( 100 );

	obj->Reset();

	CleanupStack::PushL( obj );

	User::LeaveIfError( iResultObjects.Append( obj ) );

	CleanupStack::Pop( obj );

	iResultTypes.AppendL( KNullDesC8 );

	TInt ref = iResultObjects.Count() - 1;

	return ref;

	}

TInt CTestDmCallback::GetNewStatusRefL( )

	{

	User::LeaveIfError( iStatusArray.Append( -1 ) );

	TInt ref = iStatusArray.Count() - 1;

	return ref;

	}

/*TInt CTestDmCallback::GetResultsL( TInt aResultsRef, )

	CBufBase& aObject,

	const TDesC8& aType )

	{

	}

*/

CBufBase& CTestDmCallback::GetResultsObjectL( TInt aResultsRef )

	{

	if (aResultsRef < 0 || aResultsRef >= iResultObjects.Count() )

		{

		User::Leave( KErrArgument );

		}

	return *iResultObjects[ aResultsRef ];

	}

TPtrC8 CTestDmCallback::GetResultsTypeL( TInt aResultsRef )

	{

	if (aResultsRef < 0 || aResultsRef >= iResultTypes.Count() )

		{

		User::Leave( KErrArgument );

		}

	return iResultTypes[aResultsRef];

	}

MSmlDmAdapter::TError CTestDmCallback::GetStatusL( TInt aStatusRef )

	{

	if (aStatusRef < 0 || aStatusRef >= iStatusArray.Count() )

		{

		User::Leave( KErrArgument );

		}

	return (MSmlDmAdapter::TError ) iStatusArray[aStatusRef];

	}

void CTestDmCallback::FreeResultsRefsL( )

	{

	iResultObjects.ResetAndDestroy();

	iResultTypes.Reset();

	}

void CTestDmCallback::FreeStatusRefsL( )

	{

	iStatusArray.Reset();

	}

/*

// ========================== OTHER EXPORTED FUNCTIONS =========================

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

// ?function_name implements...

// ?implementation_description.

// Returns: ?value_1: ?description

//          ?value_n: ?description

//                    ?description

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

//

?type  ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg )  // ?description

    {

    ?code

    }

*/

//  End of File