diff -r cad71a31b7fc -r e36f3802f733 voiceui/voiceuivoicerecognition/src/vuicverificationstate.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/voiceui/voiceuivoicerecognition/src/vuicverificationstate.cpp	Wed Sep 01 12:29:17 2010 +0100
@@ -0,0 +1,402 @@
+/*
+* 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
+