/*

* 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:  The MUS application's UI class.

*

*/

#include "musenglivesession.h"

#include "musuilivesharingview.h"

#include "musuilivesharingviewcontainer.h"

#include "musuibackgroundviewcontainer.h"

#include "musuilivesharingcontroller.h"

#include "musuiactivitymanger.h"

#include "musuiappui.h"

#include "musuistatuspanehandler.h"

#include "musui.hrh"

#include "musuidefinitions.h"

#include "muslogger.h" // debug logging

#include <musui.rsg>

#include <musui.mbg>

#include "musengmcesession.h"

#include <aknViewAppUi.h>

#include <avkon.hrh>

#include <eikmenup.h>

#include <akntoolbar.h>

const TInt KMusUiContainerWidth = 30;

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

// EPOC two-phased constructor

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

//

void CMusUiLiveSharingView::ConstructL()

    {

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

    CMusUiSendView::ConstructL();

    Toolbar()->SetToolbarObserver( this );

    Toolbar()->UpdateBackground();

/*

    if( MUS_NO_TOOLBAR )

        {

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

        Toolbar()->SetToolbarVisibility( EFalse );

        Toolbar()->MakeVisible(EFalse);

        }

*/

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

    }

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

// Destructor

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

//

CMusUiLiveSharingView::~CMusUiLiveSharingView()

    {

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

    if ( iContainer )

        {

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

        }

    delete iContainer;

    delete iController;

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

    }

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

//

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

//

TUid CMusUiLiveSharingView::Id() const

    {

    MUS_LOG( "mus: [MUSUI ]     CMusUiLiveSharingView::Id()" );

    return KMusUidLiveSharingView;

    }

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

// Handle EKeyUpArrow key presses 

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

//

void CMusUiLiveSharingView::HandleKeyUpArrowL()

    {

    HandleCommandL(

            iController->ZoomSelected() ? EMusuiCmdViewZoomIn :

            iController->BrightnessSelected() ? EMusuiCmdViewIncreaseBrightness :

            EMusUiCmdToolbarLastIndex );

    }

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

// Handle EKeyDownArrow key presses

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

//

void CMusUiLiveSharingView::HandleKeyDownArrowL()

    {

    HandleCommandL(

            iController->ZoomSelected() ? EMusuiCmdViewZoomOut :

            iController->BrightnessSelected() ? EMusuiCmdViewDecreaseBrightness :

            EMusUiCmdToolbarLastIndex );

    }

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

// From MEikMenuObserver, Called by framework before constructing menupane

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

//

void CMusUiLiveSharingView::DynInitMenuPaneL( TInt aResourceId,

                                              CEikMenuPane* aMenuPane )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::DynInitMenuPaneL [%d]" );

    SetZoomVisible(EFalse);

    SetBrightnessVisible(EFalse);

    // Base class initiated initialization first

    CMusUiGeneralView::DynInitMenuPaneL( aResourceId, aMenuPane );

    if( !MUS_NO_TOOLBAR )

        {

        SetInitialFocusedItemL();

        }

    if ( aResourceId == R_MUSUI_VIEW_MENU )

        {

        // Delete items not related to live sharing:

        aMenuPane->DeleteMenuItem( EMusuiCmdViewReplay );

        aMenuPane->DeleteMenuItem( EMusuiCmdViewAudioMute );

        aMenuPane->DeleteMenuItem( EMusuiCmdViewAudioNormal );        

        aMenuPane->DeleteMenuItem( EMusuiCmdViewFullScreen );

        if ( iController->ConnectionEstablished()

                     && !iController->IsDiskFull() )

            {

            CMusEngLiveSession *session = dynamic_cast <CMusEngLiveSession*>

                ( iController->EngineOutSession() );

            if ( session->IsPlayingL() )

                {

                aMenuPane->DeleteMenuItem( session->IsRecording() ?

                                           EMusuiCmdRecord :

                                           EMusuiCmdStopRecording );

                }

            else

                { 

                // when camera source was paused, hide the command

                aMenuPane->DeleteMenuItem( EMusuiCmdRecord );

                aMenuPane->DeleteMenuItem( EMusuiCmdStopRecording );

                }

            }

        else

            {

            // Hide recording commands if the session is not established

            // TODO: check autorecord on/off

            aMenuPane->DeleteMenuItem( EMusuiCmdRecord );

            aMenuPane->DeleteMenuItem( EMusuiCmdStopRecording );                    

            }

        __ASSERT_ALWAYS( iController, User::Leave( KErrNotReady ) );

        if( MUS_NO_TOOLBAR )

            {

            aMenuPane->DeleteMenuItem( EMusuiCmdToolbarBrightness );

            aMenuPane->DeleteMenuItem( EMusuiCmdToolbarZoom );            

            if ( !iController->IsBrightnessSupported() ||

                 !SendController()->IsPlayingL() )

                {

                aMenuPane->DeleteMenuItem( EMusuiCmdViewBrightness );

                }

            if ( !SendController()->IsPlayingL() )

                {

                aMenuPane->DeleteMenuItem( EMusuiCmdViewZoom );

                }

            }

        else

            {

            aMenuPane->DeleteMenuItem( EMusuiCmdViewBrightness );

            aMenuPane->DeleteMenuItem( EMusuiCmdViewZoom );            

            if ( !iController->IsBrightnessSupported() ||

                 !SendController()->IsPlayingL() || 

                 !AknLayoutUtils::PenEnabled() )

                {

                aMenuPane->DeleteMenuItem( EMusuiCmdToolbarBrightness );

                }

            if ( !SendController()->IsPlayingL() ||

                 !AknLayoutUtils::PenEnabled() )

                {

                aMenuPane->DeleteMenuItem( EMusuiCmdToolbarZoom );

                }

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::DynInitMenuPaneL" );

    }

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

//

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

//

void CMusUiLiveSharingView::HandleToolbarCommandL( TInt aCommand )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiLiveSharingView::HandleToolbarCommandL: %d",

                            aCommand );

     __ASSERT_ALWAYS( iController, User::Leave( KErrNotReady ) );

    switch ( aCommand )

        {

        case EKeyLeftArrow:

            {

            if( MUS_NO_TOOLBAR )

                {

            HandleCommandL(

                    iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeDown :

                    iController->BrightnessSelected() ? EMusuiCmdViewDecreaseBrightness :

                    iController->ZoomSelected() ? EMusuiCmdViewZoomOut :

                    EMusUiCmdToolbarLastIndex );

                }

            else

                {

                HandleCommandL(

                        iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeDown :

                        iController->ToolbarBrightnessSelected() ? EMusuiCmdViewDecreaseBrightness :

                        iController->ToolbarZoomSelected() ? EMusuiCmdViewZoomOut :

                        EMusUiCmdToolbarLastIndex );

                }

            break;

            }

        case EKeyRightArrow:

            {

            if( MUS_NO_TOOLBAR )

                {

            HandleCommandL(

                    iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeUp :

                    iController->BrightnessSelected() ? EMusuiCmdViewIncreaseBrightness :

                    iController->ZoomSelected() ? EMusuiCmdViewZoomIn :

                    EMusUiCmdToolbarLastIndex );

                }

            else

                {

                HandleCommandL(

                        iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeUp :

                        iController->ToolbarBrightnessSelected() ? EMusuiCmdViewIncreaseBrightness :

                        iController->ToolbarZoomSelected() ? EMusuiCmdViewZoomIn :

                        EMusUiCmdToolbarLastIndex );

                }

            break;

            }

        case EKeyUpArrow:

            {

            if( MUS_NO_TOOLBAR )

                {

            HandleCommandL(

                    iController->ZoomSelected() ? EMusuiCmdViewZoomIn :

                    iController->BrightnessSelected() ? EMusuiCmdViewIncreaseBrightness :

                    iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeUp :

                    EMusUiCmdToolbarLastIndex );

                }

            else

                {

                HandleCommandL(

                        iController->ToolbarZoomSelected() ? EMusuiCmdViewZoomIn :

                        iController->ToolbarBrightnessSelected() ? EMusuiCmdViewIncreaseBrightness :

                        iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeUp :

                        EMusUiCmdToolbarLastIndex );

                }

            break;

            }

        case EKeyDownArrow:

            {

            if( MUS_NO_TOOLBAR )

                {

            HandleCommandL(

                    iController->ZoomSelected() ? EMusuiCmdViewZoomOut :

                    iController->BrightnessSelected() ? EMusuiCmdViewDecreaseBrightness :

                    iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeDown :

                    EMusUiCmdToolbarLastIndex );

                }

            else

                {

                HandleCommandL(

                        iController->ToolbarZoomSelected() ? EMusuiCmdViewZoomOut :

                        iController->ToolbarBrightnessSelected() ? EMusuiCmdViewDecreaseBrightness :

                        iController->ToolbarVolumeSelected() ? EMusuiCmdViewVolumeDown :

                        EMusUiCmdToolbarLastIndex );

                }

            break;

            }

        case EMusuiCmdViewVolumeDown:

            {

            HandleCommandL( EMusuiCmdViewVolumeDown );

            break;

            }

        case EMusuiCmdViewVolumeUp:

            {

            HandleCommandL( EMusuiCmdViewVolumeUp );

            break;

            }

        default:

            {

            break;

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::HandleToolbarCommandL" );

    }

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

//

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

//

void CMusUiLiveSharingView::SetInitialFocusedItemL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> MusUiLiveSharingView::SetInitialFocusedItemL" );

    __ASSERT_ALWAYS( iController, User::Leave( KErrNotReady ) );

    if ( iOperatorSpecificFunctionality  && !AknLayoutUtils::PenEnabled() )

        {

        MUS_LOG( "Focus changed in OPERATOR mode !!!!!!!!!!!!!" );

        Toolbar()->SetFocusedItemL( EMusuiCmdToolbarZoom );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::SetInitialFocusedItemL" );

    }

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

//

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

//

void CMusUiLiveSharingView::DynInitToolbarL( TInt aResourceId,

                                             CAknToolbar* aToolbar )

    {

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

    // Items to be removed in Live Sharing View:    

 	if (!AknLayoutUtils::PenEnabled())//(aResourceId == R_MUS_TOOLBAR_NONTOUCH)//

	{

    	Toolbar()->RemoveItem( EMusuiCmdToolbarFFRev );

		// Items to be removed in Live Sharing View:

    	if ( iController->DeviceHasDedicatedVolumeKeys() )

        	{

       		Toolbar()->RemoveItem( EMusuiCmdToolbarVolume );

        	}

    	else

        	{

        	aToolbar->SetFocusedItemL( EMusuiCmdToolbarVolume );

        	}

   		if ( !iController->IsBrightnessSupported() )

        	{

        	Toolbar()->HideItem( EMusuiCmdToolbarBrightness, ETrue, ETrue );

        	}

   	 	else

        	{

        	if ( aToolbar->FocusedItem() == KErrNotFound )

            	{

            	aToolbar->SetFocusedItemL( EMusuiCmdToolbarBrightness );

            	}

        	}                      

	}

    Toolbar()->RemoveItem( EMusuiCmdToolbarPause );

    Toolbar()->RemoveItem( EMusuiCmdToolbarUnPause );

    Toolbar()->RemoveItem( EMusuiCmdToolbarFullScreen );

    if ( iOperatorSpecificFunctionality )

        {

        // Remove pause/unpause functionality in operator variant case

        Toolbar()->RemoveItem( EMusuiCmdToolbarPauseLive );

        Toolbar()->RemoveItem( EMusuiCmdToolbarUnPauseLive );            

        if ( (aToolbar->FocusedItem() == KErrNotFound ) &&

			 !AknLayoutUtils::PenEnabled() )

            {

            aToolbar->SetFocusedItemL( EMusuiCmdToolbarZoom );

            }

        }

    else        

        {

        // Toggled items to be hidden:

        Toolbar()->HideItem( iPauseSelected ?

                                EMusuiCmdToolbarPauseLive :

                                EMusuiCmdToolbarUnPauseLive,

                             ETrue,

                             ETrue ); 

        if ( aToolbar->FocusedItem() == KErrNotFound &&

             !AknLayoutUtils::PenEnabled() )

            {

            aToolbar->SetFocusedItemL( EMusuiCmdToolbarPauseLive );

            }                                

        }

    // Last generic base class functionality

    CMusUiGeneralView::DynInitToolbarL( aResourceId, aToolbar );

    MUS_LOG1( "aToolbar Focused Item: %d", aToolbar->FocusedItem() );

    MUS_LOG1( "toolbar() Focused Item: %d", Toolbar()->FocusedItem() );

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

    }

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

//

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

//

void CMusUiLiveSharingView::SetZoomValues( TInt aMinZoom, TInt aMaxZoom )

    {

    iContainer->SetZoomValues( aMinZoom, aMaxZoom );

    }

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

//

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

//

void CMusUiLiveSharingView::SetBrightnessValues( TInt aMinBrightness,

                                                 TInt aMaxBrightness )

    {

    iContainer->SetBrightnessValues( aMinBrightness, aMaxBrightness );

    }

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

//

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

//

void CMusUiLiveSharingView::SetZoomL( TInt aZoomLevel )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::SetZoomL" );

    iContainer->SetZoomL( aZoomLevel );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::SetZoomL" );

    }

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

//

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

//

void CMusUiLiveSharingView::SetBrightnessL( TInt aBrightnessLevel )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::SetBrightnessL" );

    iContainer->SetBrightnessL( aBrightnessLevel );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::SetBrightnessL" );

    }

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

//

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

//

void CMusUiLiveSharingView::SetZoomVisible( TBool aVisible )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::SetZoomVisible" );

    iContainer->SetZoomVisible( aVisible );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::SetZoomVisible" );

    }

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

//

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

//

void CMusUiLiveSharingView::SetBrightnessVisible( TBool aVisible )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::SetBrightnessVisible" );

    iContainer->SetBrightnessVisible( aVisible );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::SetBrightnessVisible" );

    }

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

//

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

//

void CMusUiLiveSharingView::LevelIndicatorDismissed()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::LevelIndicatorDismissed" );

        iController->LevelIndicatorDismissed();

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::LevelIndicatorDismissed" );

    }

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

//

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

//

void CMusUiLiveSharingView::RefreshAudioRoutingButton()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingView::RefreshAudioRoutingButton" );

    //We ignore audio routing change event in case there is Zoom/Brightness

    //adjustment ongoing in operator variant. Middle softkey will be

    //updated once adjustment is done    

    if ( !MUS_NO_TOOLBAR ||

         ( !iController->ZoomSelected() &&

         !iController->BrightnessSelected() ) )

        {

        CMusUiGeneralView::RefreshAudioRoutingToolbarButton();        

        }

   MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingView::RefreshAudioRoutingButton" );

   }

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