/*

* Copyright (c) 2006-2008 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 FILES

#include <avkon.hrh>

#include <StringLoader.h>

#include <vuivoicerecognition.rsg>

#include "vuivoicerecognition.hrh"

#include "vuicstate.h"

#include "vuicverificationstate.h"

#include "vuicverificationinitstate.h"

#include "vuicplaystate.h"

#include "vuicabortstate.h"

#include "vuicerrorstate.h"

#include "vuicexitstate.h"

#include "vuicdatastorage.h"

#include "vuicvoicerecogdialogimpl.h"

#include "vuicverificationdialog.h"

#include "vuicttsplayer.h"

#include "vuictoneplayer.h"

#include "rubydebug.h"

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

// CVerificationState::NewL

// Two-phased constructor.

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

//

CVerificationState* CVerificationState::NewL( CDataStorage& aDataStorage, CUiModel& aUiModel )

    {

    CVerificationState* self = new (ELeave) CVerificationState( aDataStorage, aUiModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }       

// Destructor       

CVerificationState::~CVerificationState()

    {

    RUBY_DEBUG0( "CVerificationState::~CVerificationState START" );

    if ( DataStorage().TtsPlayer() )

        {

        DataStorage().TtsPlayer()->Stop();

        }

    // If recording has not ended we should cancel recording

    if ( iInternalState != ECompleted &&

         DataStorage().VerificationRecognitionHandler() )

        {

        DataStorage().VerificationRecognitionHandler()->Cancel();

        }

    delete iVerificationDialog;

    RUBY_DEBUG0( "CVerificationState::~CVerificationState EXIT" );

    }

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

// CVerificationState::HandleEventL

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

//       

void CVerificationState::HandleEventL( TInt aEvent )

    {

    RUBY_DEBUG_BLOCK( "CVerificationState::HandleEventL" );

    CState* nextState = NULL;

    switch( aEvent )

        {

        case KErrNone:

            if ( iInternalState == EStarted )

                {

                iInternalState = ETtsInitialized;

                }

            else if ( iInternalState == ETtsInitialized )

                {

                iInternalState = ETtsCompleted;

                nextState = this;

                }

            else if ( iInternalState == ETtsCompleted )

                {

                iInternalState = EStartCompleted;

                nextState = this;

                }

            else if ( iInternalState == EStartCompleted )

                {

                iInternalState = ERecordStarted;

                }

            else if ( iInternalState == ERecordStarted )

                {

                iInternalState = ERecordEnded;

                }

            else if ( iInternalState == ERecordEnded )

                {

                iInternalState = ECompleted;

                nextState = this;

                }

            break;

        case EVoiceTagSoftKeySelect:

            nextState = CPlayState::NewL( DataStorage(), UiModel() );

            break;

        case KErrNoMatch:

        case KErrRecogFailed:

        case KErrNoSpeech:

        case KErrTooEarly:

        case KErrTooLong:

        case KErrTooShort:

            DataStorage().SetVerificationTryCount( DataStorage().VerificationTryCount() - 1 );

            nextState = CVerificationInitState::NewL( DataStorage(), UiModel() );

            break;

        case EVoiceTagSoftKeyOther:

            nextState = CVerificationInitState::NewL( DataStorage(), UiModel() );

            break;

        case EVoiceTagSoftKeyCancel:

        case EEndCallKeypress:

        case ELongKeypress:

        case KErrNoResults:

            nextState = CAbortState::NewL( DataStorage(), UiModel() );

            break;

        case EShortKeypress:

        case ESelectKeypress:

            iKeypress = aEvent;

            nextState = this;

            break;

        case EUpKeypress:

        case EDownKeypress:

            // Do nothing

            break;

        default:

            nextState = CErrorState::NewL( DataStorage(), UiModel(), aEvent );

            break;

        }

    DataStorage().VoiceRecognitionImpl()->ChangeState( nextState );

    }

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

// CVerificationState::ExecuteL

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

//       

void CVerificationState::ExecuteL()

    {

    RUBY_DEBUG_BLOCK( "CVerificationState::ExecuteL" );

    if ( HandleKeypressL() )

        {

        iKeypress = ENoKeypress;

        }

    else if ( iInternalState == ETtsCompleted )

        {

        DataStorage().TtsPlayer()->Stop();

        // Play the starting tone

        DataStorage().TonePlayer()->PlayTone( EAvkonSIDNameDiallerStartTone ); 

        }

    else if ( iInternalState == EStartCompleted )

        {

        MNssRecognitionHandler* handler = DataStorage().VerificationRecognitionHandler();

        User::LeaveIfError( handler->Recognize( DataStorage().VoiceRecognitionImpl() ) );

        }

    else if ( iInternalState == ECompleted )

        {

        SelectTag();

        DataStorage().SetVerificationTryCount( KVerificationTries );

        HandleEventL( SelectCommandById() );

        }

    else

        {

        TInt returnValue = KErrNoResults;

        if ( DataStorage().CompleteTagList()->Count() != KErrNone &&

             DataStorage().VerificationTryCount() > KErrNone )

            {

            iInternalState = EStarted;

            MNssTag* selectedTag = NULL;

            for ( int i = 0; i < DataStorage().CompleteTagList()->Count(); ++i )

                {

                MNssTag* tag = DataStorage().CompleteTagList()->At( i );

                if ( !DataStorage().DeviceLockMode() ||

                     ( tag->Context()->ContextName() == KVoiceDialContext &&

                     tag->RRD()->IntArray()->At( KVasExtensionRrdLocation ) == EDial ) )

                    {

                    iTagIndex = i;

                    selectedTag = tag;

                    break;

                    }

                }

            if ( selectedTag )

                {

                HBufC* header = selectedTag->SpeechItem()->Text().AllocLC();

                iVerificationDialog = CVerificationDialog::NewL();

                iVerificationDialog->CreateVerificationPopupLC( *header );

                PlayPromptL();

                BringToForeground();

                iVerificationDialog->RegisterForKeyCallback( DataStorage().VoiceRecognitionImpl() );            

                returnValue = iVerificationDialog->ShowVerificationPopupL(); // Pops things pushed in CreateVerificationPopupLC

                RUBY_DEBUG1( "CVerificationState::ExecuteL - Verification dialog returns [%d]", returnValue );

                CleanupStack::PopAndDestroy( header );

                }

            }

        if ( returnValue != KErrNone )

            {           

            SelectTag();

            DataStorage().SetVerificationTryCount( KVerificationTries );

            if ( returnValue == EVoiceTagSoftKeySelect )

                {

                HandleEventL( SelectCommandById() );

                }

            else

                {

                HandleEventL( returnValue );

                }            

            }

        }

    }

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

// CVerificationState::CVerificationState

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

//              

CVerificationState::CVerificationState( CDataStorage& aDataStorage, CUiModel& aUiModel )

 : CState( aDataStorage, aUiModel ), iKeypress( ENoKeypress ),

   iInternalState( ENotStarted )

    {

    }

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

// CVerificationState::ConstructL

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

//           

void CVerificationState::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CVerificationState::ConstructL" );

    CState::ConstructL();

    DataStorage().SetAdaptationEnabled( ETrue );

    }

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

// CVerificationState::HandleKeypressL

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

//           

TBool CVerificationState::HandleKeypressL()

    {

    RUBY_DEBUG_BLOCK( "CVerificationState::HandleKeypressL" );

    TBool handled = ETrue;

    if ( iKeypress == EShortKeypress )

        {

        SelectTag();

        HandleEventL( EVoiceTagSoftKeySelect );

        }

    else if ( iKeypress == ESelectKeypress )

        {        

        SelectTag();

        DataStorage().SetVerificationTryCount( KVerificationTries );

        HandleEventL( SelectCommandById() );

        }

    else

        {

        handled = EFalse;

        }

    return handled;

    }

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

// CVerificationState::PlayPromptL

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

//

void CVerificationState::PlayPromptL()

    {

    RUBY_DEBUG_BLOCK( "CVerificationState::PlayPromptL" );

    // if TTS is used

    if ( DataStorage().SynthesizerMode() != KErrNone ||

         DataStorage().DeviceLockMode() )

        {

        HBufC* text = NULL;

        if ( DataStorage().CompleteTagList()->At( iTagIndex )->Context()->ContextName() == KVoiceDialContext )

            {

            text = DataStorage().CompleteTagList()->At( iTagIndex )->SpeechItem()->PartialTextL( KNameTrainingIndex );

            }

        else

            {

            text = HBufC::NewL( 0 );

            }

        CleanupStack::PushL( text );

        HBufC* select = StringLoader::LoadLC( R_QAN_VC_VERIFICATION_SELECT );

        HBufC* other = StringLoader::LoadLC( R_QAN_VC_VERIFICATION_OTHER );

        HBufC* cancel = StringLoader::LoadLC( R_QAN_VC_VERIFICATION_CANCEL );

        DataStorage().TtsPlayer()->PlayL(

            DataStorage().CompleteTagList()->At( iTagIndex )->SpeechItem()->Text(), 0,

            DataStorage().CompleteTagList()->At( iTagIndex )->SpeechItem()->Text().Length(),

            *text, *select, *other, *cancel );

        CleanupStack::PopAndDestroy( cancel );

        CleanupStack::PopAndDestroy( other );

        CleanupStack::PopAndDestroy( select );

        CleanupStack::PopAndDestroy( text );

        }

    }

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

// CVerificationState::SelectTag

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

//   

void CVerificationState::SelectTag()

    {

    RUBY_DEBUG0( "CVerificationState::SelectTag START" );

    if ( DataStorage().CompleteTagList()->Count() > KErrNone )

        {

        DataStorage().SetTag( DataStorage().CompleteTagList()->At( iTagIndex ), ETrue );

        DataStorage().CompleteTagList()->Delete( iTagIndex );

        }

    RUBY_DEBUG0( "CVerificationState::SelectTag EXIT" );

    }

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

// CVerificationState::SelectTag

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

//       

TInt CVerificationState::SelectCommandById()

    {

    RUBY_DEBUG0( "CVerificationState::SelectCommandById START" );

    TInt index = KErrGeneral;

    if ( DataStorage().AdditionalTagList() &&

         DataStorage().AdditionalTagList()->Count() > KErrNone )

        {

        index = DataStorage().AdditionalTagList()->At( 0 )->RRD()->IntArray()->At( 0 );

        DataStorage().SetAdditionalTagList( NULL );

        }

    RUBY_DEBUG0( "CVerificationState::SelectCommandById EXIT" );

    return iVerificationDialog->SelectedCommand( index );

    }

// End of File