/*
* Copyright (c) 2004-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:  Handles the global progress dialog for voice recognition
*
*/


// INCLUDE FILES
#include <featmgr.h>

#include <data_caging_path_literals.hrh>

#include <AknProgressDialog.h>
#include <AknsItemID.h>
#include <eikprogi.h>
#include <eikbtgpc.h>
#include <eikimage.h> 
#include <AknsUtils.h> 

#include <AknMediatorFacade.h>

#include <SecondaryDisplay/AknSecondaryDisplayDefs.h>

#include <vuivoicerecognition.rsg>

#include "vuivoicerecognition.hrh"

#include "vuicglobalprogressdialog.h"
#include "vuimkeycallback.h"

#include "vuivoiceicondefs.h"

#include "rubydebug.h"

_LIT( KNewLine, "\n" );

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

// -----------------------------------------------------------------------------
// CGlobalProgressDialog::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CGlobalProgressDialog* CGlobalProgressDialog::NewL()
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::NewL" );
    
    CGlobalProgressDialog* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CGlobalProgressDialog::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CGlobalProgressDialog* CGlobalProgressDialog::NewLC()
    { 
    CGlobalProgressDialog* self = new ( ELeave ) CGlobalProgressDialog();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// Destructor
CGlobalProgressDialog::~CGlobalProgressDialog()
    {
    RUBY_DEBUG0( "CGlobalProgressDialog::~CGlobalProgressDialog START" );
   
    RegisterForKeyCallback( NULL );
    
    if ( iInternalState == EStarted || iInternalState == ERunning )
        {
        if ( iProgressDialog )
            {
            iProgressDialog->MakeVisible( EFalse );
            }        
        delete iProgressDialog;
        }
    
    RUBY_DEBUG0( "CGlobalProgressDialog::~CGlobalProgressDialog EXIT" );
    }

// ---------------------------------------------------------
// CGlobalProgressDialog::RegisterForKeyCallback
// Register for callback to receive notification when a softkey 
// is pressed
// ---------------------------------------------------------
//
void CGlobalProgressDialog::RegisterForKeyCallback( MKeyCallback* aKeyCallback )
    {
    RUBY_DEBUG0( "CGlobalProgressDialog::RegisterForKeyCallback START" );
    
    if ( iInternalState != EFinished )
        {
        if ( aKeyCallback )
            {
            iProgressDialog->SetCallback( this );
            }
        else
            {
            iProgressDialog->SetCallback( NULL );
            }
        }
    iKeyCallback = aKeyCallback;
    
    RUBY_DEBUG0( "CGlobalProgressDialog::RegisterForKeyCallback EXIT" );
    }            

// ---------------------------------------------------------
// CGlobalProgressDialog::SetIconL
// Set icon on the dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::SetIconL( const TDesC& aIconFile,
                                      TInt aIconId, TInt aIconMaskId )
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::SetIconL" );
    
    // If icon should be left bland do not set it at all
    if ( aIconId != EMbmAvkonQgn_stat_bt_blank )
        {
        CEikImage* image = new ( ELeave ) CEikImage();
        CleanupStack::PushL( image );
        
        image->CreatePictureFromFileL( aIconFile, aIconId, aIconMaskId );
   
        iProgressDialog->SetIconL( image ); // ownership of the image is transferred to dialog
        
        CleanupStack::Pop( image );
        }
    }

// ---------------------------------------------------------
// CGlobalProgressDialog::SetImageL
// Set image on the dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::SetImageL( const TDesC& aImageFile, TInt aImageId,
                                       TInt aImageMaskId )
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::SetImageL" );
    
    CEikImage* image = new ( ELeave ) CEikImage();
    CleanupStack::PushL( image );
    
    image->CreatePictureFromFileL( aImageFile, aImageId, aImageMaskId );
      
    iProgressDialog->SetImageL( image ); // ownership of the image is transferred to dialog
    
    CleanupStack::Pop( image );
    }

// ---------------------------------------------------------
// CGlobalProgressDialog::SetSecondaryDisplayDataL
// Sets additional information to be sent to secondary display
// ---------------------------------------------------------
//
void CGlobalProgressDialog::SetSecondaryDisplayDataL( TUid aCategory, TInt aDialogIndex,
                                                      const SecondaryDisplay::TMatchData* aData )
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::SetSecondaryDisplayDataL" );
   
    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
        {
        iProgressDialog->PublishDialogL( aDialogIndex, aCategory );
   
        if ( aData )
            {
            // fetch akn utility for mediator support, \oem\aknmediatorfacade.h
            CAknMediatorFacade* covercl = AknMediatorFacade( iProgressDialog );

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

// ---------------------------------------------------------
// CGlobalProgressDialog::ShowProgressDialogL
// Shows progress dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::ShowProgressDialogL( const TDesC& aPrompt, const TDesC& aIconText, TInt aSoftkeys )
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::ShowProgressDialogL" );
    
    iProgressDialog->PrepareLC( R_PROGRESSNOTE );
   
    HBufC* string = HBufC::NewLC( aPrompt.Length() + aIconText.Length() + KNewLine.iTypeLength );
            
    string->Des() = aPrompt;
    string->Des() += KNewLine;
    string->Des() += aIconText;
   
    iProgressDialog->SetTextL( *string );
   
    CleanupStack::PopAndDestroy( string );
   
    CEikButtonGroupContainer* cba = &iProgressDialog->ButtonGroupContainer();
    cba->SetCommandSetL( aSoftkeys );

    iProgressDialog->RunLD();

    iInternalState = ERunning;
    }

// ---------------------------------------------------------
// CGlobalProgressDialog::UpdateProgressDialogL
// Updates the progress dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::UpdateProgressDialogL( TInt aValue, TInt aFinalValue )
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::UpdateProgressDialogL" );
    
    if ( iProgressDialog )
        {
        CEikProgressInfo* progressInfo = iProgressDialog->GetProgressInfoL();
        progressInfo->SetFinalValue( aFinalValue );   	
        progressInfo->SetAndDraw( aValue );
            
        if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
            {
            CAknMediatorFacade* coverData = AknMediatorFacade( iProgressDialog );
            if( coverData )
                {
                coverData->ResetBuffer();
                coverData->BufStream().WriteInt32L( EAknGlobalPDialogValuesUpdate );
                coverData->BufStream().WriteInt32L( aValue );
                coverData->BufStream().WriteInt32L( aFinalValue );
                coverData->BufStream().CommitL();
                coverData->PostUpdatedDataL();
                }
            }
        }
   	}

// ---------------------------------------------------------
// CGlobalProgressDialog::SetSkinIds
// Set skin ids on the dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::SetSkinIds( TAknsItemID aImageId, TInt aImageBitmapId,
                                        TInt aImageMaskId, TAknsItemID aIconId )
    {
    RUBY_DEBUG0( "CGlobalProgressDialog::SetSkinIds START" );
    
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    CEikImage* image = NULL;
    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;
    TBuf<KMaxFileName> fileName = AknIconUtils::AvkonIconFileName();
    
    if ( skin )
        {
        TRAP_IGNORE(
            AknsUtils::CreateIconL( skin, aImageId, bitmap, mask, fileName,
                                    aImageBitmapId, aImageMaskId );
            CleanupStack::PushL( bitmap );
            CleanupStack::PushL( mask );
            
            image = new ( ELeave ) CEikImage();
            CleanupStack::PushL( image );
            
            image->SetBitmap( bitmap ); // ownership of the bitmap is transferred to image
            image->SetMask( mask ); // ownership of the mask is transferred to image
        
            iProgressDialog->SetImageL( image ); // ownership of the image is transferred to dialog
            
            CleanupStack::Pop( image );
            CleanupStack::Pop( mask );
            CleanupStack::Pop( bitmap );
            );

        TInt iconId = 0;
        for ( ; iconId < KSindNumberOfIcons; ++iconId )
            {
            if ( aIconId == *KIconId[ iconId ] )
                {
                break;
                }
            }
            
        if ( aIconId == *KIconId[ EIconProfile ] || aIconId == *KIconId[ EIconApplication ] )
            {
            TRAP_IGNORE(
                TParse* fp = new ( ELeave ) TParse();
                CleanupStack::PushL( fp );
                User::LeaveIfError( fp->Set( KDirAndFile, &KDC_BITMAP_DIR, NULL ) );

                fileName = fp->FullName();
                CleanupStack::PopAndDestroy( fp );
                );
            }
        
        // Don't set blank icon
        if ( aIconId != KAknsIIDQgnStatBtBlank )
            {
            ASSERT ( iconId < KSindNumberOfIcons );
            TRAP_IGNORE(
                AknsUtils::CreateIconL( skin, aIconId, bitmap, mask, fileName,
                                        KBitmapId[ iconId ], KMaskId[ iconId ] );
                CleanupStack::PushL( bitmap );
                CleanupStack::PushL( mask );
                
                image = new ( ELeave ) CEikImage();
                CleanupStack::PushL( image );
                
                image->SetBitmap( bitmap ); // ownership of the bitmap is transferred to image
                image->SetMask( mask ); // ownership of the mask is transferred to image
            
                iProgressDialog->SetIconL( image ); // ownership of the image is transferred to dialog
                
                CleanupStack::Pop( image );
                CleanupStack::Pop( mask );
                CleanupStack::Pop( bitmap );
                );
            }
        }
    RUBY_DEBUG0( "CGlobalProgressDialog::SetSkinIds EXIT" );
    }
   
// ---------------------------------------------------------
// CGlobalProgressDialog::DialogDismissedL
//
// ---------------------------------------------------------
//
void CGlobalProgressDialog::DialogDismissedL( TInt aButtonId )
    {
    RUBY_DEBUG0( "CGlobalProgressDialog::DialogDismissedL START" );
        
    // Enter key selection returns EAknSoftkeyOk
    if ( aButtonId == EAknSoftkeyOk )
        {
        aButtonId = EVoiceTagSoftKeyOther;
        }
        
    if ( iInternalState == ERunning && iKeyCallback )
        {
        iInternalState = EFinished;
        iProgressDialog->SetCallback( NULL );
        iKeyCallback->HandleKeypressL( aButtonId );
        }
    
    RUBY_DEBUG0( "CGlobalProgressDialog::DialogDismissedL EXIT" );
    }    

// -----------------------------------------------------------------------------
// CGlobalProgressDialog::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CGlobalProgressDialog::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CGlobalProgressDialog::ConstructL" );
      
    iProgressDialog = new ( ELeave ) CAknProgressDialog(
        ( REINTERPRET_CAST( CEikDialog**, &iProgressDialog ) ), ETrue );
        
    iProgressDialog->SetGloballyCapturing( ETrue );
    }

    
// -----------------------------------------------------------------------------
// CGlobalProgressDialog::CGlobalProgressDialog
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CGlobalProgressDialog::CGlobalProgressDialog()
 : iInternalState( EStarted )
    {
    }
    
// ---------------------------------------------------------
// CGlobalProgressDialog::ProcessFinished
// Stops the progress dialog
// ---------------------------------------------------------
//
void CGlobalProgressDialog::ProcessFinished()
    {
    RUBY_DEBUG0( "CGlobalProgressDialog::ProcessFinished START" );
    
    if ( iInternalState == ERunning )
        {
        iInternalState = EFinished;
        iProgressDialog->SetCallback( NULL );
        TRAP_IGNORE( iProgressDialog->ProcessFinishedL() );
        }
    
    RUBY_DEBUG0( "CGlobalProgressDialog::ProcessFinished EXIT" );
    }

// End of File