/*

* Copyright (c) 2005 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:  Mus Applications Event Observer Interface

*

*/

#include "musuigeneralview.h"     

#include "musui.hrh"

#include "musuiappui.h"         // Application UI class

#include "musuistatuspanehandler.h"

#include "musuieventcontroller.h"

#include "musuiviewcontainer.h"

#include "musuidefinitions.h"

#include "mussettings.h"

#include "mussettingskeys.h"

#include "muslogger.h" // debug logging

#include "musuiactivetimer.h"

#include "musuibackgroundviewcontainer.h"

#include <musui.rsg>

#include <musui.mbg>

#include <eikenv.h>               // Eikon enviroment

#include <aknViewAppUi.h>

#include <avkon.hrh>

#include <eikmenup.h>

#include <akntoolbar.h>

#include <aknbutton.h>

#include <AknIncallBubbleNotify.h>

#include <featmgr.h>

const TInt KBackgroundIntervalForClose = 10 * 1000 * 1000; // 10s

const TInt KMusFgBgEventFiltering = 200 * 1000; // 200 ms

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

// EPOC two-phased constructor

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

//

void CMusUiGeneralView::ConstructL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::ConstructL" );

    BaseConstructL( R_MUSUI_VIEW );

    TInt toolbarId = R_MUS_TOOLBAR;

    if (!AknLayoutUtils::PenEnabled())

	    {

	    toolbarId = R_MUS_TOOLBAR_NONTOUCH;

	    }

    CreateAndSetToolbarL(toolbarId);    

    // check if operator specific functionality is needed  

    iOperatorSpecificFunctionality = 

        ( MultimediaSharingSettings::OperatorVariantSettingL() == 

                                        MusSettingsKeys::EOperatorSpecific );

    iIncallBubble = CAknIncallBubble::NewL();

    iSessionEndTimer = CMusUiActiveTimer::NewL( this );

    iFgBgTimer = CMusUiActiveTimer::NewL( this );

    if( MUS_NO_TOOLBAR )

        {

        MUS_LOG( "mus: [MUSUI ] Operator variant hides toolbar!" );

        Toolbar()->SetToolbarVisibility( EFalse );

        Toolbar()->MakeVisible(EFalse);

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::ConstructL" );

    }

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

// Destructor

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

//

CMusUiGeneralView::~CMusUiGeneralView()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::~CMusUiGeneralView" );

    delete iSessionEndTimer; 

    delete iFgBgTimer;          

    if ( iIncallBubble )

        {

        TRAP_IGNORE( iIncallBubble->SetIncallBubbleAllowedInUsualL( ETrue ) )    

        }

    delete iIncallBubble; 

    /* Remove and delete background container */

    if ( iBackgroundContainer )

      {

      AppUi()->RemoveFromViewStack( *this, iBackgroundContainer );

      }

    delete iBackgroundContainer;

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::~CMusUiGeneralView" );

    }

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

// Fetches a pointer to the application's AppUi class ( CMusUiAppUi )

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

//

CMusUiAppUi* CMusUiGeneralView::MusAppUi() const

    {

    MUS_LOG( "mus: [MUSUI ]     CMusUiGeneralView::MusAppUi()" );

    return static_cast<CMusUiAppUi*>( iEikonEnv->AppUi() );

    }

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

// To be overridden in subclasses

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

//

void CMusUiGeneralView::HandleKeyUpEvent( TInt /*aKeyCode*/ )

    {

    // NOP

    }

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

//

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

//

void CMusUiGeneralView::SetToolbarVisibility( TBool aVisible )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiGeneralView::SetToolbarVisibility: %d",

                            aVisible );

    if( MUS_NO_TOOLBAR )

        {

        MUS_LOG( "mus: [MUSUI ] Operator variant hides toolbar!" );

        Toolbar()->SetToolbarVisibility( EFalse );

        Toolbar()->MakeVisible(EFalse);

        return;

        }

    // Show toolbar only after established session and before of exit procedure 

    if ( aVisible &&

         EventController() &&

         !EventController()->ExitOccured() &&

         EventController()->ConnectionEstablished() )

        {

        MUS_LOG( "mus: [MUSUI ] setting toolbar visible" );

        if ( SharingContainer().WaitDialogShown() )

            {

            // Cannot show toolbar at the moment as it would go over the dialog.

            // Instead, request container to set visibility once dialog

            // is dismissed.

            SharingContainer().RequestToolbarVisibilityOnceDialogDismissed( this );

            }

        else

            {

            Toolbar()->SetToolbarVisibility( ETrue );

			Toolbar()->MakeVisible(ETrue);

            }

        }

    else if ( !aVisible && EventController()->ExitOccured() )

        {

        Toolbar()->SetToolbarVisibility( EFalse );

		Toolbar()->MakeVisible(EFalse);

        }

    else

        {

        MUS_LOG( "mus: [MUSUI ] We do not set fixed toolbar invisible" );

        if (!AknLayoutUtils::PenEnabled())

        	{

        	Toolbar()->SetToolbarVisibility( EFalse );

			Toolbar()->MakeVisible(EFalse);

        	}

        SharingContainer().RequestToolbarVisibilityOnceDialogDismissed( NULL );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::SetToolbarVisibility" );

    }

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

//

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

//

void CMusUiGeneralView::AsyncQueryDialogAcceptedL( TBool aAccepted )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::AsyncQueryDialogAcceptedL" );

    EventControllerL().AsyncQueryDialogAcceptedL( aAccepted );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::AsyncQueryDialogAcceptedL" );

    }

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

// 

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

//

TInt CMusUiGeneralView::FocusedToolbarItem() const

    {

    MUS_LOG( "mus: [MUSUI ]  <-> CMusUiGeneralView::FocusedToolbarItem" );

    return Toolbar()->FocusedItem();

    }

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

//

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

//

void CMusUiGeneralView::DynInitToolbarL( TInt /*aResourceId*/,

                                         CAknToolbar* /*aToolbar*/ )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::DynInitToolbarL" );

    Toolbar()->SetWithSliding( EFalse );

    // Hide items according to states of speaker and microphone:

    Toolbar()->HideItem( EventControllerL().IsMicMutedL() ?

                            EMusuiCmdToolbarMute :

                            EMusuiCmdToolbarUnmute,

                        ETrue,

                        ETrue );

    TBool loudSpeakerEnabled( EventControllerL().IsLoudSpeakerEnabled() );

    Toolbar()->HideItem( loudSpeakerEnabled ?

                                EMusuiCmdToolbarSpeakerOn :

                                EMusuiCmdToolbarSpeakerOff,

                         ETrue,

                         ETrue );

    // Dim audio routing button if audio routing cannot be changed

    // or when some button is selected

    TBool dimAudioRouting( iToolbarItemSelected || 

                           !EventControllerL().AudioRoutingCanBeChanged() );

    Toolbar()->SetItemDimmed( loudSpeakerEnabled ?

                                    EMusuiCmdToolbarSpeakerOff :

                                    EMusuiCmdToolbarSpeakerOn,

                              dimAudioRouting,

                              ETrue );                 

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::DynInitToolbarL" );

    }

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

//

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

//

void CMusUiGeneralView::OfferToolbarEventL( TInt aCommand )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiGeneralView::OfferToolbarEventL: %d",

                            aCommand );

    EventControllerL().OfferToolbarEventL( aCommand );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::OfferToolbarEventL" );

    }

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

//

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

//

TBool CMusUiGeneralView::ShowWaitDialogL( const TDesC& aPrompt, 

                                       TInt aTimerInSeconds,

                                       TInt aExpirationMessageResourceId )

    {

    MUS_LOG_TDESC( "mus: [MUSUI ]    -> CMusUiGeneralView::ShowWaitDialogL: ",

                            aPrompt );

    TBool retVal = SharingContainer().RunWaitDialogL( 

                                                aPrompt, 

                                                aTimerInSeconds,

                                                aExpirationMessageResourceId );

    MUS_LOG1( "mus: [MUSUI ]  <- CMusUiGeneralView::ShowWaitDialogL: retVal = %d",

              retVal )

    return retVal;

    }

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

//

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

//

void CMusUiGeneralView::DismissWaitDialogL( TBool aReturnValue )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::DismissWaitDialogL" );

    SharingContainer().DismissWaitDialogL( aReturnValue );       

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::DismissWaitDialogL" );

    }

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

//

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

//

void CMusUiGeneralView::SetWaitDialogCallbackL( MProgressDialogCallback* aCallback )

    {

    SharingContainer().SetWaitDialogCallbackL( aCallback );

    }

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

//

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

//

void CMusUiGeneralView::ShowStatusPaneTitleL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::ShowStatusPaneTitleL" );

    MusAppUi()->MusStatusPane()->ActivateNaviPaneMediaL();

    // Status Pane Title:

    if ( EventControllerL().MusContactName().Length() > 0 )

        {

        MusAppUi()->MusStatusPane()->SetTitleL( 

                                        EventControllerL().MusContactName() );

        }

    else if ( EventControllerL().MusTelNumberValue().Length() > 0 )

        {

        MusAppUi()->MusStatusPane()->SetTitleL(

                                    EventControllerL().MusTelNumberValue() );

        }

    else

        {

        MusAppUi()->MusStatusPane()->SetTitleFromResourceL(

                                R_MUS_LIVE_SHARING_VIEW_TITLE );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::ShowStatusPaneTitleL" );

    }

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

//

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

//

void CMusUiGeneralView::EnableMiddleSoftkeyL( TInt aResourceId )

    {

    // Update Middle softkey

    CEikButtonGroupContainer* cba = Cba();

    if ( cba )

        {

        cba->SetCommandL( CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                          aResourceId );

        cba->DrawDeferred();

        }

    }

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

//

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

//

void CMusUiGeneralView::ActivateVolumeControlL( TInt aValue, TBool aOnlyIfVisible )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::ActivateVolumeControlL" );

    MusAppUi()->MusStatusPane()->ActivateVolumeControlL( aValue, aOnlyIfVisible );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::ActivateVolumeControlL" );

    }

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

//

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

//

void CMusUiGeneralView::HighlightSelectedToolbarItem( TInt aCommand )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::HightlightSelectedToolbarItem" );

    iToolbarItemSelected = !iToolbarItemSelected;

    CAknButton* button = static_cast<CAknButton*>( Toolbar()->ControlOrNull(

                                                                aCommand ) );

    button->SetCurrentState( iToolbarItemSelected ? 1 : 0, ETrue );

    TBool dimAudioRouting( iToolbarItemSelected || 

                           !( EventController() &&

                              EventController()->AudioRoutingCanBeChanged() ) );

    for ( TInt i = EMusuiCmdToolbarVolume; i < EMusUiCmdToolbarLastIndex; i++ )

        {

        // Undim audio routing buttons only if changing the routing is allowed                  

        if ( i == EMusuiCmdToolbarSpeakerOn )

            {

            Toolbar()->SetItemDimmed( 

                                EMusuiCmdToolbarSpeakerOn,

                                dimAudioRouting,

                                ETrue );  

            }

        else if ( i == EMusuiCmdToolbarSpeakerOff )

            {

            Toolbar()->SetItemDimmed( 

                                EMusuiCmdToolbarSpeakerOff,

                                dimAudioRouting,

                                ETrue );  

            }

        else if ( i != aCommand )

            {

            Toolbar()->SetItemDimmed( i, iToolbarItemSelected, ETrue );

            }

        else

            {

            // NOP

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::HightlightSelectedToolbarItem" );

    }

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

//

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

//

void CMusUiGeneralView::ReplaceToolbarCommand( TInt aOldCommand,

                                               TInt aNewCommand,

                                               TBool aSetNewCommandFocused )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiGeneralView::ReplaceToolbarCommand: %d",

                            aNewCommand );  

    // Hide the old item:

    Toolbar()->HideItem( aOldCommand, ETrue, EFalse );

    // Show new item:

    Toolbar()->HideItem( aNewCommand, EFalse, ETrue );

    TBool dimAudioRouting( iToolbarItemSelected || 

                           !( EventController() &&

                              EventController()->AudioRoutingCanBeChanged() ) );

    if ( aNewCommand == EMusuiCmdToolbarSpeakerOn ||

         aNewCommand == EMusuiCmdToolbarSpeakerOff )

        {

        // Dim audio routing button if audio routing cannot be changed                     

        Toolbar()->SetItemDimmed( aNewCommand,

                                  dimAudioRouting,

                                  ETrue );    

        }

    if ( aSetNewCommandFocused &&

         !AknLayoutUtils::PenEnabled() )

        {

        TRAP_IGNORE( Toolbar()->SetFocusedItemL( aNewCommand ) );

        }

    MUS_LOG1( "mus: [MUSUI ]  <- CMusUiGeneralView::ReplaceToolbarCommand: %d",

                            aNewCommand );    

    }   

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

//

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

//

void CMusUiGeneralView::DismissMenuBar()

	{

	 MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::DismissMenuBar" );

	 StopDisplayingMenuBar();

	 MUS_LOG( "mus: [MUSUI ]  <- CMusUiGeneralView::DismissMenuBar" );

	}

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

//

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

//

void CMusUiGeneralView::RefreshAudioRoutingToolbarButton()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiGeneralView::RefreshAudioRoutingToolbarButton" )

    TBool loudSpeakerEnabled( EventController() &&

                          EventController()->IsLoudSpeakerEnabled() );

    if ( MUS_NO_TOOLBAR )

        {

        TRAP_IGNORE( EnableMiddleSoftkeyL( loudSpeakerEnabled ?

                                               R_MUSUI_VIEW_OPS_MSK_IHF_OFF :

                                               R_MUSUI_VIEW_OPS_MSK_IHF_ON ) );

        } 

    else if ( Toolbar()->IsShown() )

        {

        // If toolbar is not shown, it will be refreshed automatically when shown.

        TInt focusedItem( Toolbar()->FocusedItem() );

        TBool focusInAudioRouting( focusedItem == EMusuiCmdToolbarSpeakerOff ||

                                   focusedItem == EMusuiCmdToolbarSpeakerOn );

        TBool loudSpeakerEnabled( EventController() &&

                                  EventController()->IsLoudSpeakerEnabled() );

        // Hide old audio routing buttton

        Toolbar()->HideItem( loudSpeakerEnabled ?

                                EMusuiCmdToolbarSpeakerOn :

                                EMusuiCmdToolbarSpeakerOff,

                             ETrue,

                             EFalse );

        // Show new audio routing button                              

        Toolbar()->HideItem( loudSpeakerEnabled ?

                                    EMusuiCmdToolbarSpeakerOff :

                                    EMusuiCmdToolbarSpeakerOn,

                             EFalse,

                             ETrue );                     

        // Dim new audio routing button if audio routing cannot be changed

        // or when some button is selected        

        TBool dimAudioRouting( iToolbarItemSelected || 

                               !( EventController() &&

                               EventController()->AudioRoutingCanBeChanged() ) );

        Toolbar()->SetItemDimmed( loudSpeakerEnabled ?

                                        EMusuiCmdToolbarSpeakerOff :