/*

* Copyright (c) 2006 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:  Generic view class for vcommand app

*

*/

// INCLUDE FILES

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <AknGlobalNote.h>

#include <AknWaitDialog.h>

#include <hlplch.h>

#include <ctsydomainpskeys.h>

#include <vcommand.rsg>

#include "vcappui.h"

#include "vcgenericview.h"

#include "vcfolderview.h"

#include "vcgenericcontainer.h" 

#include "vcommandconstants.h"

#include "vcommand.hrh"

#include "vcommandconstants.h"

#include "vcplaybackdialog.h"

#include "voiceuibldvariant.hrh"

#include <vcommanddomaincrkeys.h>

#include <centralrepository.h>

#include <coemain.h>

#include <apgcli.h>

#include <apgtask.h>

#include <apacmdln.h>

#include "rubydebug.h"

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

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

// CVCGenericView::CVCGenericView

// C++ constructor

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

//

CVCGenericView::CVCGenericView( CVCModel& aModel ): 

    iModel( aModel )

    {   

    }

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

// CVCGenericView::ConstructL

// Two-phased constructor

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

//

void CVCGenericView::ConstructL( TInt aResourceId ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::ConstructL" );

    BaseConstructL( aResourceId );

    SetFolderTitleL( KNullDesC() );

    }

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

// CVCGenericView::~CVCGenericView

// Destructor

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

//

CVCGenericView::~CVCGenericView() 

    {

    delete iFolderName;

    if( iContainer ) 

        {  

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        iContainer = NULL;

        }

    }

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

// TUid CVCGenericView::Id

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

//

TUid CVCGenericView::Id() const 

    {

    return KUidVCMainView;

    }

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

// CVCGenericView::HandleCommandL

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

//

void CVCGenericView::HandleCommandL( TInt aCommand ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::HandleCommandL" );

    // We will only handle one event at a time

    if( !iContainer->IsHandlingKeyPressInProgress() )

        {

        iContainer->SetHandlingKeyPressInProgress( ETrue );

        DoHandleCommandL( aCommand );

        iContainer->SetHandlingKeyPressInProgress( EFalse );

        }

    }

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

// CVCGenericView::DoHandleCommandL

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

//

// Defines basic operations for listbox items. Those operations are: opening a folder,

// editing an item, playing an item and launching help. More sophisticated features

// can be defined in inherited classes.

//

void CVCGenericView::DoHandleCommandL( TInt aCommand ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::DoHandleCommandL" );

    switch ( aCommand ) 

        {

        case EAknSoftkeySelect: // Middle softkey

            {

            TInt current( iContainer->CurrentSelection() );

            // Msk can be pressed before the listbox is populated in which case

            // we ignore the key press

            if( current != KErrNotFound )

                {

                if( iContainer->IsItemFolderL( current ) )

                    {

                    DoHandleCommandL( EVCCmdOpen );

                    }

                else

                    {

                    DoHandleCommandL( EVCCmdEdit );

                    }                

                }

            break;

            }

        case EAknSoftkeyExit: // exit the application

            {

            static_cast<CVCAppUi*>( iEikonEnv->AppUi() )->ExitProgram();

            break;

            }

        case EAknSoftkeyBack: // back to main view from folder

            {

#ifdef __VCOMMAND_CONTROL_PANEL

            if( Id() == KUidVCMainView )

                {

                static_cast<CVCAppUi*>( iEikonEnv->AppUi() )->ExitProgram();

                break; 

                }

            else // Id() == KUidVCFolderView

                {

                AppUi()->ActivateLocalViewL( KUidVCMainView );

                break;

                }

#else

            AppUi()->ActivateLocalViewL( KUidVCMainView );

            break;

#endif

            }

        case EVCCmdOpen: // open folder

            {

            TInt current = iContainer->CurrentSelection();

            static_cast <CVCFolderView*>

                ( AppUi()->View( KUidVCFolderView ) )

                ->SetFolderTitleL( iContainer->GetFolderTitle( current ) );

            // Store the focused folder. Used when returning from folder view.

            iFocusedIndex = current;

            AppUi()->ActivateLocalViewL( KUidVCFolderView );

            break; 

            }

        case EVCCmdEdit: // edit voice command extra text

            {

            TRAPD(err,  iContainer->ShowEditTextL() );

            if ( err == KErrNoMemory || err == KErrDiskFull ) User::Leave(err);

            break;

            }

        case EVCCmdPlayback: // playback voice command

            {

            TRAP_IGNORE( PlaybackVoiceCommandL() );

            break;

            }

        case EVCCmdDelete: // delete a voice command

            {

            TRAP_IGNORE( iContainer->DeleteVCommandL() );

            break;

            }

        case EVCCmdSettings: // modify settings

            {

            iFocusedIndex = iContainer->CurrentSelection();

            AppUi()->ActivateLocalViewL( KUidVCSettingsView );

            break;

            }

        case EVCCmdStartVui: // start  in tutorial mode

            {

            TRAP_IGNORE( LaunchDemoVoiceUiL() );

            break;

            }

        case EAknCmdHelp: // launch help dialog 

            {

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), 

                                                 AppUi()->AppHelpContextL() );

            break;

            }

        case EVCCmdRemove: // item can not be removed

            {

            CannotDeleteNoteL();

            break;

            }

        case EVCCmdIgnore:

            {

            break; // do nothing

            }

        default: 

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }      

    }   

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

// CVCGenericView::LaunchDemoVoiceUiL

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

//

void CVCGenericView::LaunchDemoVoiceUiL() const

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::LaunchDemoVoiceUiL" );

    CRepository* client = CRepository::NewLC( KCRUidVCommandSettings );

    User::LeaveIfError( client->Set( KVuiDemoMode, ETrue ) );

    CleanupStack::PopAndDestroy( client );

    TApaTaskList apaTaskList( CCoeEnv::Static()->WsSession() );

    TApaTask apaTask = apaTaskList.FindApp( KVoiceUiUid );

    if ( apaTask.Exists() )

        {

        apaTask.BringToForeground();

        }

    else

        {

        RApaLsSession apaLsSession;

        User::LeaveIfError( apaLsSession.Connect() );

        TApaAppInfo appInfo;

        User::LeaveIfError( apaLsSession.GetAppInfo( appInfo, KVoiceUiUid ) );

        TFileName appName = appInfo.iFullName;

        CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();

        apaCommandLine->SetExecutableNameL( appName );

        apaCommandLine->SetCommandL( EApaCommandRunWithoutViews );

        User::LeaveIfError ( apaLsSession.StartApp( *apaCommandLine ) );

        CleanupStack::PopAndDestroy( apaCommandLine );

        apaLsSession.Close();

        }

    }

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

// CVCGenericView::CheckMiddleSoftkeyLabelL

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

//

void CVCGenericView::SetMiddleSoftkeyLabelL( TInt aIndex ) const

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::SetMiddleSoftkeyLabelL" );

    RemoveCommandFromMSK();

    if( iModel.Count() == 0 )

        {

        DoSetMiddleSoftKeyLabelL( R_TEXT_SOFTKEY_EMPTY, EVCCmdIgnore );

        }

    else if( iContainer->IsItemFolderL( aIndex ) )

        {

        DoSetMiddleSoftKeyLabelL( R_QTN_VC_OPEN, EVCCmdOpen );

        }

    else

        {

        DoSetMiddleSoftKeyLabelL( R_QTN_VC_EDIT, EVCCmdEdit );

        }

    }

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

// CVCGenericView::SetMiddleSoftKeyLabelL

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

//

void CVCGenericView::DoSetMiddleSoftKeyLabelL( const TInt aResourceId,

                                               const TInt aCommandId  ) const

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::DoSetMiddleSoftKeyLabelL" );

    CEikButtonGroupContainer* cbaGroup = Cba();

    if ( cbaGroup )

        {

        HBufC* mskText = StringLoader::LoadLC( aResourceId );

        TPtr mskPtr = mskText->Des();

        cbaGroup->AddCommandToStackL( KVcMskControlID, aCommandId, mskPtr );

        CleanupStack::PopAndDestroy( mskText );

        }

    }

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

// CVCGenericView::RemoveCommandFromMSK

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

//

void CVCGenericView::RemoveCommandFromMSK() const

    {

    if ( Cba() )

        {

        Cba()->RemoveCommandFromStack( KVcMskControlID, EVCCmdOpen );

        Cba()->RemoveCommandFromStack( KVcMskControlID, EVCCmdEdit );

        }

    }

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

// CVCGenericView::HandleClientRectChange

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

//

void CVCGenericView::HandleClientRectChange() 

    {

    if ( iContainer ) 

        {

        iContainer->SetRect( ClientRect() );

        }

    }

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

// CVCGenericView::DoActivateL

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

//

void CVCGenericView::DoActivateL( const TVwsViewId& aPrevViewId,

                                  TUid, const TDesC8& ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::DoActivateL" );

    if( !iContainer ) 

        {

        iContainer = new ( ELeave ) CVCGenericContainer( MenuBar(), iModel, *this );

        iContainer->SetMopParent( this );

        iContainer->ConstructL( ClientRect() );

        AppUi()->AddToStackL( *this, iContainer );

        iContainer->ActivateL();

        }

    // Returning from folder or settings view

    if( aPrevViewId.iViewUid.iUid == KUidVCFolderView.iUid ||

        aPrevViewId.iViewUid.iUid == KUidVCSettingsView.iUid )

        {

        // Set the focus on the folder that was opened previously

        iContainer->SetCurrentSelection( iFocusedIndex );

        }

    // Set msk label  

    SetMiddleSoftkeyLabelL( iContainer->CurrentSelection() );

    }

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

// CVCGenericView::DoDeactivate

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

//

void CVCGenericView::DoDeactivate() 

    {

    if( iContainer ) 

        {

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        iContainer = NULL;

        }

    }

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

//  CVCGenericView::DynInitMenuPaneL

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

void CVCGenericView::DynInitMenuPaneL( TInt aResourceId,

                                       CEikMenuPane* aMenuPane ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::DynInitMenuPaneL" );

    if( aMenuPane ) 

        {   

        // Check which menu item we are handling

        if( aResourceId == R_VCOMMAND_MENU ) 

            {

            // if help is not enabled, do not show "help"

            if( !FeatureManager::FeatureSupported( KFeatureIdHelp ) ) 

                {

                aMenuPane->SetItemDimmed( EAknCmdHelp, ETrue );

                }

            TInt listBoxIndex( iContainer->CurrentSelection() );

            if( listBoxIndex >= 0 )

                {

                TBool isFolder = iContainer->IsItemFolderL( listBoxIndex );

                if( isFolder ) // Folder is highlighted.

                    {

                    aMenuPane->SetItemDimmed( EVCCmdPlayback, ETrue );

                    aMenuPane->SetItemDimmed( EVCCmdEdit, ETrue );

                    aMenuPane->SetItemDimmed( EVCCmdDelete, ETrue );

                    }

                else // Folder is not highlighted.

                    { 

                    aMenuPane->SetItemDimmed( EVCCmdOpen, ETrue );

                    // Show delete item only if the command is user edited

                    TDesC* secondRow = iContainer->GetSecondRowNameLC(

                                       iContainer->CurrentSelection() );

                    if( secondRow->Length() == 0 )

                        {

                        aMenuPane->SetItemDimmed( EVCCmdDelete, ETrue );

                        }

                    CleanupStack::PopAndDestroy( secondRow );

                    }                

                }

            else // No items in listbox

                {

                aMenuPane->SetItemDimmed( EVCCmdPlayback, ETrue );

                aMenuPane->SetItemDimmed( EVCCmdEdit, ETrue );

                aMenuPane->SetItemDimmed( EVCCmdDelete, ETrue );

                aMenuPane->SetItemDimmed( EVCCmdOpen, ETrue );

                }

            }

        }

    }

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

//  CVCGenericView::PlaybackVoiceCommandL

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

//

void CVCGenericView::PlaybackVoiceCommandL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::PlaybackVoiceCommandL" );

    CVCAppUi* appUi = static_cast <CVCAppUi*> ( iEikonEnv->AppUi() );

    TInt state = appUi->CheckCallStateL();

    TBool videoCallState = appUi->IsVideoCallL();

    if( ( state == EPSCTsyCallStateNone || state == EPSCTsyCallStateUninitialized ||

           state == EPSCTsyCallStateHold || state == KErrNotFound ) && !videoCallState ) 

        {        

        TInt listboxIndex = iContainer->CurrentSelection();

        TDesC* listboxItem = iContainer->GetFirstRowNameLC( listboxIndex );

        const CVCommandUiEntry& vcommand = iModel.GetVCommandL( *listboxItem );

        CleanupStack::PopAndDestroy( listboxItem );

        CVCPlaybackDialog* dlg = new (ELeave) CVCPlaybackDialog(

            iModel.Service(), vcommand );

        dlg->PrepareLC( R_PLAYBACK_VOICE_COMMAND_DIALOG );

        dlg->RunLD();

        dlg = NULL;

        }

    else 

        {

        // Display call in progress note

        appUi->CallInProgressNoteL();

        }

    }

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

// CVCGenericView::CannotDeleteNoteL

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

//

void CVCGenericView::CannotDeleteNoteL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::CannotDeleteNoteL" );

    TDesC* name;

    name = iContainer

        ->GetSecondRowNameLC( iContainer->CurrentSelection() );

    if( name->Length() == 0 )

        {

        CleanupStack::PopAndDestroy( name );

        name = iContainer

            ->GetFirstRowNameLC( iContainer->CurrentSelection() );

        }

    HBufC* stringholder = StringLoader::LoadL( R_QTN_VC_INFO_CANNOT_DEL,

                                               *name, iEikonEnv );

    CleanupStack::PopAndDestroy( name );

    CleanupStack::PushL( stringholder );

    CAknNoteWrapper* note = new ( ELeave ) CAknNoteWrapper();

    note->ExecuteLD( R_CANNOT_DELETE_NOTE, *stringholder );

    CleanupStack::PopAndDestroy( stringholder );

    }

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

// CVCGenericView::HandleSizeChange

// Handle screen size change.