/*
* Copyright (c) 2004-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 <featmgr.h>

#include <AknMediatorFacade.h>

#include <SecondaryDisplay/AknSecondaryDisplayDefs.h>

#include <vuivoicerecognition.rsg>
#include <vuivoicerecogdefs.h>

#include "vuivoicerecognition.hrh"

#include "vuiclistquerydialog.h"
#include "vuicverificationdialog.h"

#include "vuimkeycallback.h"

#include "rubydebug.h"

// CONSTANTS

// ================= MEMBER FUNCTIONS =======================

// -----------------------------------------------------------------------------
// CVerificationDialog::CVerificationDialog
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVerificationDialog::CVerificationDialog() 
 : iCurrentIndex( 0 )
    {
    }


// Destructor
CVerificationDialog::~CVerificationDialog()
    {
    RUBY_DEBUG0( "CVerificationDialog::~CVerificationDialog START" );
     
    RegisterForKeyCallback( NULL );
    
    delete iDialog;
    iDialog = NULL;
    
    iEikonEnv->EikAppUi()->RemoveFromStack( this );
        
    RUBY_DEBUG0( "CVerificationDialog::~CVerificationDialog EXIT" );          
    }


// -----------------------------------------------------------------------------
// CVerificationDialog::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVerificationDialog::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationDialog::ConstructL" );
      
    iEikonEnv->EikAppUi()->AddToStackL( this, ECoeStackPriorityAlert );
    }


// ---------------------------------------------------------
// CVerificationDialog::NewL
// Two-phased constructor.
// ---------------------------------------------------------
//
CVerificationDialog* CVerificationDialog::NewL()                                                           
    {
    CVerificationDialog* self = new (ELeave) CVerificationDialog();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// -----------------------------------------------------------------------------
// CVerificationDialog::RegisterForKeyCallback
// -----------------------------------------------------------------------------
//
void CVerificationDialog::RegisterForKeyCallback( MKeyCallback* aKeyCallback )
    {
    iKeyCallback = aKeyCallback;
    }

// ---------------------------------------------------------
// TKeyResponse CVerificationDialog::OfferKeyEventL
// ---------------------------------------------------------
//
TKeyResponse CVerificationDialog::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode /*aType*/ )
    {
    RUBY_DEBUG_BLOCK( "CVerificationDialog::OfferKeyEventL" );

    TKeyResponse keyStatus = EKeyWasNotConsumed;

    TInt event = ConvertKeyEventL( aKeyEvent );
    
    if ( event != ENoKeypress )
        {
        switch( event )
            {
            case ESelectKeypress:
                {                   
                keyStatus = EKeyWasConsumed;
                break;
                }
            
            case EUpKeypress:
                {
                --iCurrentIndex;
                if ( iCurrentIndex <= -1 )
                    {
                    iCurrentIndex = KVerificationCommands - 1;    
                    }
                break;
                }
                        
            case EDownKeypress:
                {
                ++iCurrentIndex;
                if ( iCurrentIndex >= KVerificationCommands )
                    {
                    iCurrentIndex = 0;
                    }
                break;
                }
                
            case EVoiceTagSoftKeyCancel:
                {
                iEikonEnv->EikAppUi()->RemoveFromStack( this );
                break;
                }
        
            default:
                break;            
            }
         
         if ( iKeyCallback )
             {
             iKeyCallback->HandleKeypressL( event );
            }
         }
         
    return keyStatus;
    }
    
// ---------------------------------------------------------------------------
// CVerificationDialog::MediatorCommandL
// ---------------------------------------------------------------------------
//
TAknDialogMediatorObserverCommand CVerificationDialog::MediatorCommandL( TUid /*aDomain*/, 
                                                                         TUid aCategory, 
                                                                         TInt aCommandId, 
                                                                         const TDesC8& aData )
    { 
    RUBY_DEBUG_BLOCK( "CVerificationDialog::MediatorCommandL" );
    
    TAknDialogMediatorObserverCommand retValue = EHandleAsNormal;
    
    if ( aCategory == SecondaryDisplay::KCatVoiceUi && 
         aCommandId == SecondaryDisplay::ECmdShowVoiceVerificationQuery )
        {
        if ( aData.Length() == sizeof( SAknDialogFeedback ) ) 
            {
            const SAknDialogFeedback& params = 
                reinterpret_cast<const SAknDialogFeedback&>( *( aData.Ptr() ) );
            
            if ( params.iKey.iCode == EKeyCBA1 )
                {
                // LSK should select current selection
                iKeyCallback->HandleKeypressL( ESelectKeypress );
                
                retValue = EDoNothingWithThisCommand;
                }
            }
        else
            {
            SAknIntegerUpdate* params = (SAknIntegerUpdate*) &aData;
        
            if ( params->iCmd == EAknListQueryUpdateSelection )
                {
                iCurrentIndex = params->iId;
                iDialog->ListControl()->Listbox()->SetCurrentItemIndexAndDraw( iCurrentIndex );

                // Just send EUpKeypress or EDownKeypress event to notify that selection
                // has changed
                iKeyCallback->HandleKeypressL( EDownKeypress );
                }
            }
        }
    return retValue;
    } 

// ---------------------------------------------------------------------------
// CVerificationDialog::NotifyMediatorExit
// ---------------------------------------------------------------------------
//
void CVerificationDialog::NotifyMediatorExit() 
    { 
    RUBY_DEBUG0( "CVerificationDialog::NotifyMediatorExit" );
    // Do nothing
    } 

// -----------------------------------------------------------------------------
// CVerificationDialog::CreateVerificationPopupLC
// -----------------------------------------------------------------------------
//
void CVerificationDialog::CreateVerificationPopupLC( const TDesC& aHeader )
    {
    RUBY_DEBUG0( "CVerificationDialog::CreateVerificationPopupLC START" );
       
    iDialog = CListQueryDialog::NewL( &iCurrentIndex, &iDialog );
    iDialog->PrepareLC( R_VERIFICATION_QUERY );
    
    iDialog->QueryHeading()->SetTextL( aHeader );
    
    SecondaryDisplay::TVerificationData data;
    data.iName.Append( aHeader );
    
    SetSecondaryDisplayDataL( data );
    
    RUBY_DEBUG0( "CVerificationDialog::CreateVerificationPopupLC EXIT" );
    }

// -----------------------------------------------------------------------------
// CVerificationDialog::ShowVerificationPopupL
// -----------------------------------------------------------------------------
//
TInt CVerificationDialog::ShowVerificationPopupL()
    {
    RUBY_DEBUG0( "CVerificationDialog::ShowVerificationPopupL START" );

    // Show verification dialog
    TInt returnValue = iDialog->RunLD();
    
    // Touch selection returns EAknSoftkeyOk
    if ( returnValue == EAknSoftkeyOk )
        {
        returnValue = EVoiceTagSoftKeySelect;
        }
            
    RUBY_DEBUG0( "CVerificationDialog::ShowVerificationPopupL EXIT" );

    return returnValue;
    }
        
// -----------------------------------------------------------------------------
// CVerificationDialog::ConvertKeyEventL
// -----------------------------------------------------------------------------
// 
TInt CVerificationDialog::ConvertKeyEventL( const TKeyEvent& aKeyEvent )
    {
    TInt event = ENoKeypress;
    
    switch( aKeyEvent.iCode )
        {
        case EKeyNo:
        case EKeyEscape:
            {
            event = EVoiceTagSoftKeyCancel;
            break;
            }

        case EKeyDevice3:
        case EKeyYes:
            {
            event = ESelectKeypress;
            break;
            }

        case EKeyUpArrow:
            {
            event = EUpKeypress;
            break;
            }
                        
        case EKeyDownArrow:
            {
            event = EDownKeypress;
            break;
            }
                                        
        default:
            {
            event = ENoKeypress;
            break;            
            }
        }
    return event;
    }
    
// ---------------------------------------------------------------------------
// CVerificationDialog::SelectedCommand
// ---------------------------------------------------------------------------
//    
TInt CVerificationDialog::SelectedCommand( TInt aId )
    {
    RUBY_DEBUG0( "CVerificationDialog::SelectedCommand START" );
    
    TInt command;
    TInt index = iCurrentIndex;
    
    if ( aId != KErrGeneral )
        {
        index = aId;
        }
        
    switch( index )
        {
        case 0:
            command = EVoiceTagSoftKeySelect;
            break;

        case 1:
            command = EVoiceTagSoftKeyOther;
            break;

        case 2:
            command = EVoiceTagSoftKeyCancel;
            break;
                                        
        default:
            command = KErrGeneral;
            break;            
        }
    
    RUBY_DEBUG0( "CVerificationDialog::SelectedCommand EXIT" );
    
    return command;
    }
    
// ---------------------------------------------------------
// CVerificationDialog::SetSecondaryDisplayDataL
// Sets additional information to be sent to secondary display
// ---------------------------------------------------------
//
void CVerificationDialog::SetSecondaryDisplayDataL( SecondaryDisplay::TVerificationData& aData )
    {
    RUBY_DEBUG_BLOCK( "CVerificationDialog::SetSecondaryDisplayDataL" );
   
    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
        {
        // Create dummy id list (needed for list query automation)
        CArrayFixFlat<TInt>* array = new ( ELeave ) CArrayFixFlat<TInt>( 1 );
        CleanupStack::PushL( array );
        for( TInt i = 0; i < 3; ++i )
            {
            array->AppendL( i );
            }
            
        iDialog->PublishDialogL( SecondaryDisplay::ECmdShowVoiceVerificationQuery,
                                 SecondaryDisplay::KCatVoiceUi,
                                 array );
                                 
        iDialog->SetMediatorObserver( this );
        
        CleanupStack::Pop( array ); // Dialog takes ownership of array
   
        // fetch akn utility for mediator support, \oem\aknmediatorfacade.h
        CAknMediatorFacade* covercl = AknMediatorFacade( iDialog );

        if ( covercl )
            {
            covercl->BufStream() << aData.iName;
            covercl->BufStream().CommitL(); // no more data to send so commit buf
            }
        }
    }
    
//  End of File