/*

* 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:  Converts VCommands into tags and vise veraa

*

*/

#include <e32def.h>

#include <s32mem.h>  // memory streams

#include <vcommandapi.h>

#include "rubydebug.h"

#include "desarrayconverter.h"

#include "tagcommandconverter.h"

#include "vcommandinternalapi.h"

// For CleanupResetAndDestroy

#include <mmfcontrollerpluginresolver.h>  

/** The index of the first element of the tag RRD text array, that is used to 

 * store the streamed VCommand

 */

const TInt KStreamStartIndex = 1;

/** 

 * Streamimg the VCommand might take arbitrary amount of space.

 * Every time the streaming buffer needs to be increased it grows up

 * this amount of bytes

 */

const TInt KCommandBufferSizeExpansion = 500;

/** 

* Granularity for the returned tag array

*/ 

const TInt KDefaultTagsPerCommand = 2;

/**

* Converts given tag to the VCommand

* @leave KErrTotalLossOfPrecision if the aTag's intArray is empty

*/

CStoredVCommand* CTagCommandConverter::TagToCommandLC( const MNssTag& aTag )

	{

    MNssTag& varTag ( const_cast<MNssTag&>(aTag) );

    CArrayFixFlat<TInt>& intArray = *( varTag.RRD()->IntArray() );

    __ASSERT_ALWAYS( intArray.Count() > 0, User::Leave( KErrTotalLossOfPrecision  ) );

    CArrayFixFlat<NssRRDText>& tagArray = *(varTag.RRD()->TextArray());

    TDesC8* storage = CDesArrayConverter::ArrayToDesC8LC( tagArray, KStreamStartIndex, 

                            tagArray.Count() - KStreamStartIndex );

    TInt commandId = intArray[KCommandIdRrdIntIndex];

    RDesReadStream readStream( *storage );

    CleanupClosePushL( readStream );

    CStoredVCommand* command = CStoredVCommand::NewL( readStream, commandId );

    CleanupStack::PopAndDestroy( &readStream );    

    CleanupStack::PopAndDestroy( storage );

    CleanupStack::PushL( command );

    return command;

	}

/**

* Constructs a new VAS tag from a command and a context. 

* Does not save to VAS, just creates. Created tag stores the streamed

* VCommand in its RRDText array. The tag's rrd int array is empty

*/

MNssTag* CTagCommandConverter::CommandToTagLC( const CVCommand& aCommand, 

						const MNssContext& aContext, MNssTagMgr& aTagMgr )

    {

    MNssTag* tag = aTagMgr.CreateTagL( const_cast<MNssContext*>( &aContext ) );

    CleanupDeletePushL( tag );

    // the first (and only) element of the rrdint array is the application uid

    // the first element of the rrdtext array is the command line arguments 

    // converted to 16 bit representation (on 16-bit systems)

    /** @todo consider removing this "simple" shortcut of saving the arguments 

     *        into the first RRD text element. This information is 

     *        anyway streamed into the other rrdtext slots

     */

    CArrayFixFlat<TInt> *theId = new (ELeave) CArrayFixFlat<TInt>( 1 );

    CleanupStack::PushL( theId );

    CBufFlat* storage = CBufFlat::NewL( KCommandBufferSizeExpansion );

    CleanupStack::PushL( storage );

    RBufWriteStream writeStream( *storage);

    CleanupClosePushL( writeStream );

    writeStream << aCommand;    

    CleanupStack::PopAndDestroy( &writeStream );

    CArrayFixFlat<NssRRDText>* streamChunks = 

                        CDesArrayConverter::DesC8ToArrayLC( storage->Ptr( 0 ) );

    // 1 for the command line args. They are saved separately

    CArrayFixFlat<NssRRDText>* theText = 

    	new (ELeave) CArrayFixFlat<NssRRDText>( streamChunks->Count() + 1 );

    CleanupStack::PushL(theText);

    NssRRDText bufArguments;

    // converts to 16-bits in unicode builds

    bufArguments.Copy( aCommand.Runnable().Arguments() );

    theText->AppendL( bufArguments );

    for( TInt i(0); i < streamChunks->Count(); i++ )

        {

        // the last piece

        theText->AppendL( streamChunks->At( i ) );

        }

    RUBY_DEBUG0( "CTagCommandConverter::CommandToTagLC Saved command to the rrd text array" );

    tag->RRD()->SetIntArrayL( theId );

    tag->RRD()->SetTextArrayL( theText );

    CleanupStack::PopAndDestroy( theText );

    CleanupStack::PopAndDestroy( streamChunks );

    CleanupStack::PopAndDestroy( storage );

    CleanupStack::PopAndDestroy( theId );

    return tag;

    }    

/**

* Converts given tags to the VCommand. This tags must have been generated

* from a single VCommand (via CommandToTagsLC2 ) 

* @leave KErrOverflow if given array has more, than two elements

* @leave KErrUnderflow if given array is empty

* @leave KErrArgument if given tags correspond to the different VCommands

*/

CStoredVCommand* CTagCommandConverter::TagsToCommandLC( const CArrayPtr<MNssTag>& aTags )

    {

    __ASSERT_ALWAYS( aTags.Count() <= KMaxTagsPerCommand, User::Leave( KErrOverflow ) );

    __ASSERT_ALWAYS( aTags.Count() > 0, User::Leave( KErrUnderflow ) );

    CStoredVCommand* firstCommand = TagToCommandLC( *aTags[0] );

    // Comparing tags is complex. Comparing VCommands is simple

    if( aTags.Count() == KMaxTagsPerCommand )

        {

        CStoredVCommand* secondCommand = TagToCommandLC( *aTags[1] );

        if( !( *firstCommand == *secondCommand ) )

            {

            RUBY_ERROR0( "CTagCommandConverter::TagsToCommandLC firstCommand is NOT equal to second command. Leaving with KErrArgument");

            User::Leave( KErrArgument );

            }

        CleanupStack::PopAndDestroy( secondCommand );

        }

    return firstCommand;    

    }

/**

* Constructs new VAS tags from a command and a context. 

* Does not save to VAS, just creates. At the end of this function two

* items are pushed to the cleanup stack. The first PopAndDestroy will

* ResetAndDestroy the generated tags, the second one will delete the

* CArrayPtr itself

*

* @return array of one or two VAS tags. Two tags are created if a given 

*         command has a UserText set. The created tags bear the identical

*         data

*/

CArrayPtr<MNssTag>* CTagCommandConverter::CommandToTagsLC2( const CVCommand& aCommand, 

				const MNssContext& aContext, MNssTagMgr& aTagMgr )

    {

    CArrayPtr<MNssTag>* array = new (ELeave) CArrayPtrFlat<MNssTag>( KDefaultTagsPerCommand );

    CleanupStack::PushL( array );

    CleanupResetAndDestroyPushL( *array );

    MNssTag* firstTag = CommandToTagLC( aCommand, aContext, aTagMgr );

    array->AppendL( firstTag );

    CleanupStack::Pop( firstTag );

    if( aCommand.AlternativeSpokenText() != KNullDesC )

        {

        // Second tag is needed

        MNssTag* secondTag = CommandToTagLC( aCommand, aContext, aTagMgr );

        array->AppendL( secondTag );

        CleanupStack::Pop( secondTag );

        }

    return array;    

    }

//End of file