/*
* Copyright (c) 2004-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:  Private serialization functions for Custom Commands
*
*/


// INCLUDE FILES
#include <s32mem.h>
#include "nsssicustomcommanddata.h"
#include "rubydebug.h"

// LOCAL FUNCTION PROTOTYPES
void CleanupForPointerArrays( TAny* anArray );
void CleanupResetAndDestroyAndDeletePushL( RPointerArray<MDesCArray>* anArray );


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

// -----------------------------------------------------------------------------
// CleanupForPointerArrays
//
// Cleanup function for RPointerArray, which calls ResetAndDestroy()
// before deleting.
//
// Returns: None
// -----------------------------------------------------------------------------
//
void CleanupForPointerArrays(
    TAny* anArray) // Pointer to RPointerArray<MDesCArray>
    {
    RPointerArray<MDesCArray> *array = (RPointerArray<MDesCArray> *)anArray;
    array->ResetAndDestroy();
    delete array;
    }

// -----------------------------------------------------------------------------
// CleanupResetAndDestroyAndDeletePushL
//
// Pushes the RPointerArray to the cleanup stack, so that
// both the container and its contents are deleted in case of a leave.
//
// Returns: None
// -----------------------------------------------------------------------------
//
void CleanupResetAndDestroyAndDeletePushL(
    RPointerArray<MDesCArray> *anArray) // Array to be destroyed and deleted
    {
    TCleanupItem cleanupItem( CleanupForPointerArrays, (TAny *)anArray );
    CleanupStack::PushL( cleanupItem );
    }


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

// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::ExternalizeDesCArrayL
// Externalizes a string array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
CBufFlat* SICustomCommandData::ExternalizeDesCArrayL(
	const MDesCArray& aArray)
	{

	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KExpandSize);
	CleanupStack::PushL(dataCopyBuffer);
	RBufWriteStream stream;
	stream.Open(*dataCopyBuffer);
	CleanupClosePushL(stream);

    // Write the number of strings
	stream.WriteInt32L(aArray.MdcaCount());

    // Write strings: First string length, then the characters
    for( TInt k = 0; k < aArray.MdcaCount(); k++ )
        {
        TPtrC text( aArray.MdcaPoint( k ) );

        stream.WriteInt32L( text.Length() );

        if ( text.Length() > 0 )
            {
            stream.WriteL( text );
            }
        }

	CleanupStack::PopAndDestroy(1); //stream
	CleanupStack::Pop(); //dataCopyBuffer;
	return dataCopyBuffer;	
	}

// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::InternalizeDesCArrayL
// Internalizes a string array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
MDesCArray *SICustomCommandData::InternalizeDesCArrayL(
	const TDesC8& aBuffer)
	{
	CDesCArrayFlat* phraseArray = new CDesCArrayFlat(KExpandSize);
	CleanupStack::PushL(phraseArray);

	RDesReadStream stream;
	stream.Open(aBuffer);
	CleanupClosePushL(stream);

	TInt count = stream.ReadInt32L();

    TInt   phraseBufLength = KDefaultPhraseLen;
    HBufC *phraseBuf = HBufC::NewLC( phraseBufLength );
    TPtr   phrase    = phraseBuf->Des();

    for( TInt k = 0; k < count; k++ )
        {
        TInt length = stream.ReadInt32L();

        if ( length > phraseBufLength )
            {
            CleanupStack::PopAndDestroy( phraseBuf );
            phraseBuf = HBufC::NewLC( length );
            phraseBufLength = length;
            phrase.Set( phraseBuf->Des() );
            }

        stream.ReadL( phrase, length );
        phraseArray->AppendL( phrase );
        phrase.Zero();
        }

	CleanupStack::PopAndDestroy(2); //phraseBuf, stream
	CleanupStack::Pop(phraseArray); //phraseArray;
	return phraseArray;	
	}

// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::ExternalizeDesCArrayArrayL
// Externalizes an array of string arrays.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
CBufFlat* SICustomCommandData::ExternalizeDesCArrayArrayL(
	const RPointerArray<MDesCArray>& aArrayArray)
	{
	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KExpandSize);
	CleanupStack::PushL(dataCopyBuffer);
	RBufWriteStream stream;
	stream.Open(*dataCopyBuffer);
	CleanupClosePushL(stream);

    stream.WriteInt32L(aArrayArray.Count());

    for( TInt arrayK = 0; arrayK < aArrayArray.Count(); arrayK++ )
        {
        const MDesCArray& aArray = *aArrayArray[ arrayK ];
        // Write the number of strings
	    stream.WriteInt32L(aArray.MdcaCount());

        // Write strings: First string length, then the characters
        for( TInt k = 0; k < aArray.MdcaCount(); k++ )
            {
            TPtrC text( aArray.MdcaPoint( k ) );

            stream.WriteInt32L( text.Length() );

            if ( text.Length() > 0 )
                {
                stream.WriteL( text );
                }
            }
        }

	CleanupStack::PopAndDestroy(1); //stream
	CleanupStack::Pop(); //dataCopyBuffer;
	return dataCopyBuffer;	
	
	}


// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::InternalizeDesCArrayArrayL
// Internalizes an array of string arrays array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
RPointerArray<MDesCArray> *SICustomCommandData::InternalizeDesCArrayArrayL(
	const TDesC8& aBuffer)
	{
    RPointerArray<MDesCArray>* phraseArrayArray = new (ELeave) RPointerArray<MDesCArray>(KExpandSize);
    CleanupResetAndDestroyAndDeletePushL(phraseArrayArray);

	RDesReadStream stream;
	stream.Open(aBuffer);
	CleanupClosePushL(stream);

	TInt arrayCount = stream.ReadInt32L();

    TInt   phraseBufLength = KDefaultPhraseLen;
    HBufC *phraseBuf = HBufC::NewL( phraseBufLength );
    TPtr   phrase    = phraseBuf->Des();
    CleanupStack::PushL( phraseBuf );

    for( TInt arrayK = 0; arrayK < arrayCount; arrayK++ )
        {
        
	    TInt count = stream.ReadInt32L();

    	CDesCArrayFlat* phraseArray = new CDesCArrayFlat(KExpandSize);
        CleanupStack::PushL( phraseArray );

        for( TInt k = 0; k < count; k++ )
            {
            TInt length = stream.ReadInt32L();

            if ( length > phraseBufLength )
                {
                HBufC* newPhraseBuf = HBufC::NewL( length );

                CleanupStack::Pop( phraseArray );
                CleanupStack::PopAndDestroy( phraseBuf );

                phraseBuf = newPhraseBuf;
                phraseBufLength = length;
                phrase.Set( phraseBuf->Des() );

                CleanupStack::PushL( phraseBuf );
                CleanupStack::PushL( phraseArray );
                }

            stream.ReadL( phrase, length );
            phraseArray->AppendL( phrase );
            phrase.Zero();
            }

        User::LeaveIfError( phraseArrayArray->Append( phraseArray ) );
        CleanupStack::Pop( phraseArray );
        }

	CleanupStack::PopAndDestroy(2); //phraseBuf, stream
	CleanupStack::Pop(1); //phraseArrayArray
	return phraseArrayArray;	
	}


// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::InternalizeDesCArrayArrayL
// Internalizes an array of string arrays array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
HBufC8* SICustomCommandData::ReadMessageDataLC( TMMFMessage& aMessage, TInt aSlot )
    {
    // MMF messages have 2 slots
    if ( aSlot != 1 && aSlot != 2 )
    	{
        RUBY_DEBUG0( "SICustomCommandData::ReadMessageDataLC Leaving with KErrArgument" );
    	User::Leave( KErrArgument );
    	}
        

    TInt size = 0;

    if ( aSlot == 1 )
        {
        size = aMessage.SizeOfData1FromClient();
        }
    else
        {
        size = aMessage.SizeOfData2FromClient();
        }

    HBufC8* data = HBufC8::NewLC( size );
    TPtr8 ptr = data->Des();

    if ( aSlot == 1 )
        {
        aMessage.ReadData1FromClientL( ptr );
        }
    else{
        aMessage.ReadData2FromClientL( ptr );
        }

    return( data );
    }


// -----------------------------------------------------------------------------
// CSpeakerIndependentCustomCommandParser::InternalizePronunArrayL
// Internalizes an array of string arrays array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void SICustomCommandData::InternalizePronunArrayL(
    const TDesC8& aData,
    TInt aCount,
    RArray<TSIPronunciationID>& aArray )
    {
    const TSIPronunciationID* pronunPtr = (const TSIPronunciationID*)aData.Ptr();

    for ( TInt k = 0; k < aCount; k++ )
        {
        User::LeaveIfError( aArray.Append( *pronunPtr ) );
        pronunPtr++;
        }
    }


// End of File