/*

* Copyright (c) 2006-2007 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 <aknappui.h>

#include <AknUtils.h> 

#include <AknIconUtils.h> 

#include <cntdef.h>

#include <AknsConstants.h>

#include <StringLoader.h>

#include <AudioPreference.h>

#include <vasmbasepbkhandler.h>

#include <secondarydisplay/vuisecondarydisplayapi.h>

#include <vuivoicerecognition.rsg>

#include "vuivoicerecognition.hrh"

#include "vuicstate.h"

#include "vuicplaystate.h"

#include "vuictutorialstate.h"

#include "vuicresultsstate.h"

#include "vuicverificationinitstate.h"

#include "vuicabortstate.h"

#include "vuicdatastorage.h"

#include "vuicvoicerecogdialogimpl.h"

#include "vuicpropertyhandler.h"

#include "vuictoneplayer.h"

#include "vuicttsplayer.h"

#include "vuicglobalprogressdialog.h"

#include "vuivoiceicondefs.h"

#include "rubydebug.h"

// Constants

_LIT( KStringPosition, "%U" );

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

// CPlayState::NewL

// Two-phased constructor.

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

//

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

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }       

// Destructor       

CPlayState::~CPlayState()

    {

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

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

    delete iProgressDialog;

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

    }

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

// CPlayState::HandleEventL

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

//       

void CPlayState::HandleEventL( TInt aEvent )

    {

    RUBY_DEBUG_BLOCK( "CPlayState::HandleEventL" );

    CState* nextState = NULL;

    switch( aEvent )

        {

        case KErrNone:

            if ( iInternalState == EStarted )

                {

                iInternalState = EInitialized;

                nextState = this;

                }

            else if ( iInternalState == EInitialized )

                {

                iInternalState = ECompleted;

                nextState = this;

                }

            break;

        case KErrPathNotFound:

            // Ignore mysterious path not found error when loading confirmation tone

            if ( iInternalState == EStarted )

                {

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

                }

            break;

        case EVoiceTagSoftKeySelect:

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

            break;

        case EShortKeypress:

        case EVoiceTagSoftKeyOther:

        case EAknSoftkeyOther:

        case EAknSoftkeyDone:

        case EStdKeyDevice2:

            if ( iInternalState != EStarted )

                {

                if ( DataStorage().VerificationMode() != EVoice )

                    {

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

                    }

                else

                    {

                    if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext &&

                         DataStorage().Tag()->RRD()->IntArray()->At( KVasExtensionRrdLocation ) == EDial )

                        {

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

                        }

                    }

                }

            break;

        case EEndCallKeypress:

            // Do nothing

            break;

        default:

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

            break;

        }

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

    }

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

// CPlayState::ExecuteL

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

//       

void CPlayState::ExecuteL()

    {

    RUBY_DEBUG_BLOCK( "CPlayState::ExecuteL" );

    if ( iInternalState == ENotStarted )

        {

        TBuf<KMaxFieldLength> phoneNumber;        

        TFieldType fieldType;        

        TName name;

        iInternalState = EStarted;

        if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext )

            {

            if ( DataStorage().VerificationMode() == EVoice &&

                 DataStorage().Tag()->RRD()->IntArray()->At( KVasExtensionRrdLocation ) == EDial )

                {

                FormatDataL( name, phoneNumber, fieldType );

                ShowPlaydialogL( name, phoneNumber, fieldType );

                }

            else

                {

                TRAP_IGNORE( HandleEventL( EVoiceTagSoftKeySelect ) );

                }

            }

        else

            {

            DataStorage().TonePlayer()->InitToneL( EAvkonSIDConfirmationTone );

            }                

        }

    else if ( iInternalState == EInitialized )

        {

        if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext &&

             DataStorage().Tag()->RRD()->IntArray()->At( KVasExtensionRrdLocation ) == EDial )

            {

            iTModel.iFinalValue = DataStorage().PlayDuration().Int64() / KKRecogInterval + 4 * KRecogDelay;

            StartTimerL( *this, KRecogDelay, KKRecogInterval * iTModel.iHundreths );

            }

        else

            {

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

            }

        }

    else  if ( iInternalState == ECompleted )

        {

        if ( DataStorage().Tag()->Context()->ContextName() != KVoiceDialContext ||

             DataStorage().Tag()->RRD()->IntArray()->At( KVasExtensionRrdLocation ) != EDial )

            {

            TRAP_IGNORE( HandleEventL( EVoiceTagSoftKeySelect ) );

            }

        }

    }

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

// CPlayState::CPlayState

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

//              

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

 : CState( aDataStorage, aUiModel ), iInternalState( ENotStarted ),

   iTickCount( 0 ), iPlaybackDelay( KPlaybackTimeout )

    {

    iTModel.iFinalValue = KRecogFinal;

    iTModel.iHundreths = KRecogInterval;

    iTModel.iIncrement = KRecogIncrement;

    iTModel.iRunning = EFalse;

    }

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

// CPlayState::ConstructL

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

//           

void CPlayState::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CPlayState::ConstructL" );

    CState::ConstructL();

    }

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

// CPlayState::DoTimedEventL

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

//

void CPlayState::DoTimedEventL()

    {

    if ( ( ++iTickCount < iTModel.iFinalValue + iPlaybackDelay ) && iProgressDialog )

        {

        iProgressDialog->UpdateProgressDialogL( iTickCount, iTModel.iFinalValue ); 

        }

    else 

        {

        HandleEventL( EVoiceTagSoftKeySelect );

        } 

    }

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

// CPlayState::FormatName

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

//           

void CPlayState::FormatName( TDes& aName )

    {

    RUBY_DEBUG0( "CPlayState::FormatName START" );

    const CFont* font = CEikonEnv::Static()->NormalFont();

    if ( AknLayoutUtils::Variant() == EApacVariant )

        {

        font = ApacPlain16();

        }

    TRect rect = iAvkonAppUi->ClientRect();

    TAknLayoutText layoutText;

    layoutText.LayoutText( rect, AKN_LAYOUT_TEXT_Wait_or_progress_note_pop_up_window_texts_Line_1(0,0,0) );

    TInt maxWidth = layoutText.TextRect().Width();

    AknTextUtils::ClipToFit( aName, *font, maxWidth, AknTextUtils::EClipFromEnd );

    RUBY_DEBUG0( "CPlayState::FormatName EXIT" );

    }     

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

// CPlayState::PlayVoiceTagL

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

//

void CPlayState::PlayVoiceTagL()

    {

    RUBY_DEBUG_BLOCK( "CPlayState::PlayVoiceTagL" );

    // if TTS is used

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

         DataStorage().DeviceLockMode() )

        {            

        // Add text "dialling" in front of the name if using voice dialing

        if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext &&

             DataStorage().Tag()->RRD()->IntArray()->At( KVasExtensionRrdLocation ) == EDial )

            {

            HBufC* ttsText = StringLoader::LoadLC( R_QAN_VC_TTS_DIALLING );

            TInt position = ttsText->FindC( KStringPosition );

            User::LeaveIfError( position );            

            CleanupStack::PopAndDestroy( ttsText );

            ttsText = StringLoader::LoadLC( R_QAN_VC_TTS_DIALLING,

                                            DataStorage().Tag()->SpeechItem()->Text() );

            HBufC* text = DataStorage().Tag()->SpeechItem()->PartialTextL( KNameTrainingIndex );        

            CleanupStack::PushL( text ); 

            DataStorage().TtsPlayer()->PlayL( *ttsText, position,

                                              DataStorage().Tag()->SpeechItem()->Text().Length(),

                                              *text );

            CleanupStack::PopAndDestroy( text );

            CleanupStack::PopAndDestroy( ttsText );

            }

        else if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext )

            {           

            HBufC* text = DataStorage().Tag()->SpeechItem()->PartialTextL( KNameTrainingIndex );        

            CleanupStack::PushL( text ); 

            DataStorage().TtsPlayer()->PlayL( DataStorage().Tag()->SpeechItem()->Text(), 0,

                                              DataStorage().Tag()->SpeechItem()->Text().Length(),

                                              *text );

            CleanupStack::PopAndDestroy( text );

            }

        else

            {            

            DataStorage().TtsPlayer()->PlayL( DataStorage().Tag()->SpeechItem()->Text() );

            }

        }

    else

        {

        // Set playback delay so that dialog will be dismissed immediately when

        // progess bar reaches final value

        iPlaybackDelay = 1;

        // Show playback dialog without TTS.

        DataStorage().SetPlayDuration( KTimeoutMicroseconds );

        HandleEventL( KErrNone );

        }

    }

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

// CPlayState::FormatDataL

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

//

void CPlayState::FormatDataL( TDes& aName, TDes& aPhoneNumber, TFieldType& aFieldType )

    {

    RUBY_DEBUG_BLOCK( "CPlayState::FormatDataL" );

    TPtrC phoneNumber( KNullDesC );

    aPhoneNumber = (TDes&) phoneNumber;

    aFieldType = KNullUid;

    aName.Zero();

    if ( DataStorage().Tag()->Context()->ContextName() == KVoiceDialContext )

        {

        HBufC* name = DataStorage().Tag()->SpeechItem()->PartialTextL( KNameTrainingIndex );

        CleanupStack::PushL( name );

        aName.Copy( *name );

        CleanupStack::PopAndDestroy( name );

        // Format name so that it fits on one line

        FormatName( aName );

        DataStorage().PbkHandler()->FindContactFieldL( DataStorage().Tag() );

        // Format phone number

        phoneNumber.Set( DataStorage().PbkHandler()->TextL() );

        aPhoneNumber = (TDes&) phoneNumber;

        AknTextUtils::LanguageSpecificNumberConversion( aPhoneNumber );

        aFieldType = DataStorage().PbkHandler()->FieldTypeL();      

        }

    else

        {

        aName.Copy( DataStorage().Tag()->SpeechItem()->Text() );

        }

    }  

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

// CPlayState::ShowPlaydialogL

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

//

void CPlayState::ShowPlaydialogL( const TDesC& aName, const TDesC& aPhoneNumber,

                                  const TFieldType aFieldType )

    {

    RUBY_DEBUG_BLOCK( "CPlayState::ShowPlaydialogL" );

    // Get icon information

    TInt iconId;

    TInt iconMaskId;

    TAknsItemID iconSkinId;

    GetDialogIcon( aFieldType, iconId, iconMaskId, iconSkinId );

    iProgressDialog = CGlobalProgressDialog::NewL();

    // Set icon, image and skin for the playback dialog

    iProgressDialog->SetIconL( AknIconUtils::AvkonIconFileName(),

                               iconId, iconMaskId );

    iProgressDialog->SetImageL( AknIconUtils::AvkonIconFileName(),

                                EMbmAvkonQgn_note_voice_found,

                                EMbmAvkonQgn_note_voice_found_mask );

    iProgressDialog->SetSkinIds( KAknsIIDQgnNoteVoiceFound, EMbmAvkonQgn_note_voice_found,

                                 EMbmAvkonQgn_note_voice_found_mask, iconSkinId );

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

    // Package dialog data for coverui

    SecondaryDisplay::TMatchData matchData;

    matchData.iType = aFieldType;

    matchData.iName.Append( aName );

    matchData.iNumber.Append( aPhoneNumber );

    // Publish the data for the secondary display

    iProgressDialog->SetSecondaryDisplayDataL( SecondaryDisplay::KCatVoiceUi,

                                               SecondaryDisplay::ECmdShowMatchedItemNote,

                                               &matchData );

    BringToForeground();

    iProgressDialog->ShowProgressDialogL( aName, aPhoneNumber, R_AVKON_SOFTKEYS_OTHER_QUIT );

    // Play selected name using TTS

    PlayVoiceTagL();

    }    

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

// CPlayState::GetDialogIcon

// Chooses appropriate dialog icon

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

//

void CPlayState::GetDialogIcon( const TFieldType& aType, TInt& aIcon,

                                TInt& aIconMask, TAknsItemID& aIconId )

   {   

   // select a phone type bitmap

   if ( aType == KUidContactFieldVCardMapVOICE )

      {

      aIcon = KBitmapId[ EIconPhone ];

      aIconMask = KMaskId[ EIconPhone ];

      aIconId = *KIconId[ EIconPhone ];

      }

   else if ( aType == KUidContactFieldVCardMapCELL )

      {

      aIcon = KBitmapId[ EIconMobile ];

      aIconMask = KMaskId[ EIconMobile ];

      aIconId = *KIconId[ EIconMobile ];

      }

   else if ( aType == KUidContactFieldVCardMapFAX )

      {

      aIcon = KBitmapId[ EIconFax ];

      aIconMask = KMaskId[ EIconFax ];

      aIconId = *KIconId[ EIconFax ];

      }

   else if ( aType == KUidContactFieldVCardMapEMAILINTERNET )

      {

      aIcon = KBitmapId[ EIconEmail ];

      aIconMask = KMaskId[ EIconEmail ];

      aIconId = *KIconId[ EIconEmail ];

      }

   else if ( aType == KUidContactFieldVCardMapVIDEO )

      {

      aIcon = KBitmapId[ EIconVideo ];

      aIconMask = KMaskId[ EIconVideo ];

      aIconId = *KIconId[ EIconVideo ];

      }

   else if ( aType == KUidContactFieldVCardMapVOIP )

      {

      aIcon = KBitmapId[ EIconVoip ];

      aIconMask = KMaskId[ EIconVoip ];

      aIconId = *KIconId[ EIconVoip ];

      }   

   else

      {

      aIcon = KBitmapId[ EIconBlank ];

      aIconMask = KMaskId[ EIconBlank ];

      aIconId = *KIconId[ EIconBlank ];

      }

   }

// End of File