/*

* 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:  Array of tags and corresponding spoken texts

*

*/

#include "rubydebug.h"

#include "tagnameset.h"

#include <nssvasmspeechitem.h>

#include <nssvasmtag.h>

#include <nssvasmtagmgr.h>

_LIT( KTagNameSetPanic, "TNS" );

CTagNameSet* CTagNameSet::NewLC()

    {

    CTagNameSet* self = new (ELeave) CTagNameSet;

    CleanupStack::PushL( self );

    return self;

    }

CTagNameSet::~CTagNameSet()

    {

    iTags.ResetAndDestroy();

    iTexts.ResetAndDestroy();

    }

/**

* Adds a tag-text pair to be trained

* @param aTag tag to be trained and saved. This objects takes ownership

*        on the aTag

* @param aTrainingText text to be recognized. This object doesn't

*        take ownership on aTrainingText, but makes an own copy

*/

void CTagNameSet::AppendL( const MNssTag* aTag, const TDesC& aTrainingText )

    {

    HBufC* text = aTrainingText.AllocL();

    iTexts.Append( text );

    iTags.Append( aTag );    

    }

/**

* Train and save to VAS all the stored tags. It is not specified what happens

* to VAS if this method leaves

* @param aParams

* @param aTagMgr

* @param aIgnoreErrors If ETrue, doesn't fail the whole operation if some

*        individual trainings/savings failed. Trains and saves as much as

*        possible

*/

void CTagNameSet::TrainAndSaveL( const CNssTrainingParameters& aParams, 

                                 MNssTagMgr& aTagMgr, TBool aIgnoreErrors )

    {

    RUBY_DEBUG_BLOCK( "CTrainingPack::TrainAndSaveL" );

    iIgnoreErrors = aIgnoreErrors;

    RUBY_DEBUG1( "CTrainingPack::TrainAndSaveL Processing [%d] pairs", iTags.Count() );

    TrainTagsL( aParams );

    SaveTagsL( aTagMgr );

    }

/**

* Remove all the stored tags from VAS. It is not specified what happens

* to VAS if this method leaves

* @param aTagMgr

* @param aIgnoreErrors If ETrue, doesn't fail the whole operation if some

*        individual removals failed. Removes as many tags as

*        possible

*/                            

void CTagNameSet::UntrainL( MNssTagMgr& aTagMgr, TBool aIgnoreErrors )

    {

    RUBY_DEBUG_BLOCK("");

    iIgnoreErrors = aIgnoreErrors;

    RUBY_DEBUG1( "Removing [%d] tags from VAS", iTags.Count() );

    SetCallbacksExpected( iTags.Count() );

    if( iCallbacksExpected > 0 )

        {

       	for( TInt i = 0; i < iTags.Count(); i++ )

        	{

            DeleteTagL( aTagMgr, *iTags[i] );

    	    }  // for

        WaitUntilOperationsAreCompletedL();

        }

    }

/**

* @return Number of tag-name pairs stored

*/

TInt CTagNameSet::Count() const

    {

    return iTags.Count();

    }

/**

* @param aIndex must be >= 0 and < Count()

* @return Voice tag at the given position

* @panic KErrArgument if aIndex is out of bounds

*/    

const MNssTag& CTagNameSet::TagAt( TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < iTags.Count(), 

                    User::Panic( KTagNameSetPanic, KErrArgument ));

    return *iTags[aIndex];

    }

/**

* @param aIndex must be >= 0 and < Count()

* @return Recognition text at the given position

* @panic KErrArgument if aIndex is out of bounds

*/        

const TDesC& CTagNameSet::TextAt( TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < iTexts.Count(), 

                    User::Panic( KTagNameSetPanic, KErrArgument ));

    return *iTexts[aIndex];

    }

/**

* Train all the stored tag-name pairs. Synchronous

*/

void CTagNameSet::TrainTagsL( const CNssTrainingParameters& aParams )

    {

    __ASSERT_ALWAYS( iCallbacksExpected == 0, User::Leave( KErrInUse) );

    SetCallbacksExpected( Count() );

    if( iCallbacksExpected > 0 )

        {

        for( TInt i = 0; i < Count(); i++ )

            {

            TrainTagL( TagAt( i ), aParams, TextAt( i ) );

            }  // for

        WaitUntilOperationsAreCompletedL();

        }  // if

    }

/**

* Trains the voice tag. Asynchronous

* @leave VAS error code

* @todo Is it ok to mix system-wide codes with the TNssSpeechItemResult codes

*/

void CTagNameSet::TrainTagL( const MNssTag& aTag, 

		const CNssTrainingParameters& aParams, const TDesC& aSpokenText )

	{

	RUBY_DEBUG_BLOCKL( "CTagNameSet::TrainTagL" );

    RUBY_DEBUG1( "Training for spoken text [%S]", &aSpokenText )

    MNssSpeechItem* speechItem = const_cast<MNssTag&>(aTag).SpeechItem();

    speechItem->SetTextL( aSpokenText );

    MNssSpeechItem::TNssSpeechItemResult nssErr = 

		speechItem->TrainTextL( this, const_cast<CNssTrainingParameters*>( &aParams ) );

    if ( nssErr != MNssSpeechItem::EVasErrorNone )

        {

        RUBY_ERROR1( "CTagNameSet::TrainTagL training start failed with the nss code [%d]", 

                    nssErr );

        if( iIgnoreErrors )

            {

            RUBY_DEBUG0( "CTagNameSet::TrainTagL ignoring error" );

            DecreaseCallbacksExpected();

            }

        else 

            {

            // Wait for started operations before leaving

            DecreaseCallbacksExpected();

            WaitUntilOperationsAreCompletedL();

            switch( nssErr )

                {

                case MNssSpeechItem::EVasInvalidParameter:

                    User::Leave( KErrArgument );

                case MNssSpeechItem::EVasTrainFailed:

                    User::Leave( KErrGeneral );

                default:

                    User::Leave( nssErr );

                } 

            }        

        }

    RUBY_DEBUG0( "CTagNameSet::TrainTagL Tag training has been initiated" );

	}			

/**

* Train Complete Event - Voice tag training completed

* @param aErrorCode KErrNone if training was successfull

*/       

void CTagNameSet::HandleTrainComplete( TInt aErrorCode )

	{

	//RUBY_DEBUG0( "Start" );

	ProcessCallback( aErrorCode );

	//RUBY_DEBUG0( "End" );

	}

/**

* Saves the trained voice tag to VAS. Synchronous

*/

void CTagNameSet::SaveTagsL( MNssTagMgr& aTagManager )

	{

	RUBY_DEBUG_BLOCK( "CTagSaver::SaveTagsL" );

	__ASSERT_ALWAYS( iCallbacksExpected == 0, User::Leave( KErrInUse) );

    SetCallbacksExpected( Count() );

    if( iCallbacksExpected > 0 )

        {

        for( TInt i = 0; i < Count(); i++ )

            {

            SaveTagL( aTagManager, TagAt( i ) );

            }  // for

        WaitUntilOperationsAreCompletedL();

        }  // if

	}

/**

* Saves the trained voice tag to VAS. 

*/

void CTagNameSet::SaveTagL( MNssTagMgr& aTagManager, const MNssTag& aTag )

	{

	RUBY_DEBUG_BLOCKL( "CTagNameSet::SaveTagL" );

    TInt nssErr = 

            aTagManager.SaveTag( this, const_cast<MNssTag*>( &aTag ) );

    if( nssErr != KErrNone ) 

        {

        RUBY_ERROR1( "CTagNameSet::SaveTagL Savetag start failed with the nss code [%d]", nssErr );

        if( iIgnoreErrors )

            {

            RUBY_DEBUG0( "CTagNameSet::SaveTagL ignoring error" );

            DecreaseCallbacksExpected();

            }

        else 

            {

            // Wait for started operations before leaving

            DecreaseCallbacksExpected();

            WaitUntilOperationsAreCompletedL();

            User::Leave( KErrGeneral );

            }        

        }

    RUBY_DEBUG0( "CTagNameSet::SaveTagL Savetag sequence started" );

	}

/**

* Callback to indicate that SaveTag sequence has been completed

* @param aErrorCode KErrNone if saving of tag was successfull

*/

void CTagNameSet::SaveTagCompleted( TInt aErrorCode )

	{

	RUBY_DEBUG0( "Start" );

    ProcessCallback( aErrorCode );

    RUBY_DEBUG0( "End" );

    }

/**

* Deletes the voice tag from VAS. Asynchronous

* @leave VAS error codes

*/

void CTagNameSet::DeleteTagL( MNssTagMgr& aTagManager, MNssTag& aTag )

    {

    User::LeaveIfError( aTagManager.DeleteTag( this, &aTag ) );

    }

/**

* Callback to indicate a tag was deleted successfully.

* @param aErrorCode KErrNone if deletion of tag was successfull

*/

void CTagNameSet::DeleteTagCompleted( TInt aErrorCode )

    {

    RUBY_DEBUG0( "Start" );

    ProcessCallback( aErrorCode );

    RUBY_DEBUG0( "End" );

    }

/**

* Handles the common part of the callback processing

* Decrements the number of still expected callbacks and

* handles the errors according to aIgnoreErrors from the 

* public methods

*/

void CTagNameSet::ProcessCallback( TInt aErrorCode )

    {

    //RUBY_DEBUG0( "Start" );

    if( iIgnoreErrors || aErrorCode == KErrNone )

        {

        if( DecreaseCallbacksExpected() == 0 )

            {

            StopAsyncWaitingOrPanic( KErrNone );

            }  

        }

    else

        {

        RUBY_ERROR1( "Callback reported error [%d] ", aErrorCode );

        if( DecreaseCallbacksExpected() == 0 )

            {

            StopAsyncWaitingOrPanic( aErrorCode );

            }

        }

    //RUBY_DEBUG0( "End" );    

    }

/**

* Sets the number of callbacks to expect

*/

void CTagNameSet::SetCallbacksExpected (TUint aCallbacksExpected )

    {

    RUBY_DEBUG2( "Changing from [%d] to [%d]", iCallbacksExpected, aCallbacksExpected );

    iCallbacksExpected = aCallbacksExpected;

    }

/**

* Decreases the number of callbacks to expect by one

* @return Number of callbacks expected after decreasing        

*/

TUint CTagNameSet::DecreaseCallbacksExpected()

    {

    __ASSERT_ALWAYS( iCallbacksExpected > 0, User::Panic( KTagNameSetPanic, KErrNotReady ) );

    RUBY_DEBUG2( "Changing from [%d] to [%d]", iCallbacksExpected, iCallbacksExpected - 1 );

    return --iCallbacksExpected;

    }

/**

* Waits until all the expected callbacks are received

* If no callbacks are expected returns immediately

* @leave @see CAsyncWorker::WaitForAsyncCallbackL

*/

void CTagNameSet::WaitUntilOperationsAreCompletedL()

    {

    RUBY_DEBUG_BLOCK( "" );

    if( iCallbacksExpected > 0 )

        {

        RUBY_DEBUG1( "[%d] callbacks expected. Waiting for them", iCallbacksExpected );

        WaitForAsyncCallbackL();

        }

    else 

        {

        RUBY_DEBUG0( "no callbacks expected. Returning immediately" );

        }

    }

//End of file