/*
* 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:  Volume popup implementation.
*
*/


#include    <AknVolumePopup.h>
#include    <cvtlogger.h>
#include    "cvtuivolumepopup.h"
#include    "cvtuifeaturemanager.h"
#include	"tVtuifeaturevariation.h"
#include    "CVtUiAppUi.h"
#include    "cvtengmodel.h"

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::NewL
// ---------------------------------------------------------------------------
//
CVtUiVolumePopup* CVtUiVolumePopup::NewL( CVtUiFeatureManager&
    aFeatureManager )
    {
    __VTPRINTENTER( "CVtUiVolumePopup.NewL" )
    CVtUiVolumePopup* self =
        new ( ELeave ) CVtUiVolumePopup( aFeatureManager );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    __VTPRINTEXIT( "CVtUiVolumePopup.NewL" )
    return self;
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::~CVtUiVolumePopup
// ---------------------------------------------------------------------------
//
CVtUiVolumePopup::~CVtUiVolumePopup()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.~" )
    __VTPRINTEXIT( "CVtUiVolumePopup.~" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::UpdateVolumeAndRouting
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::UpdateVolumeAndRoutingL()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.UpdateVolumeAndRoutingL" )
    MVtEngAudio& audio( iModel.Audio() );
    MVtEngAudio::TAudioRoutingState audioRouting;
    User::LeaveIfError( audio.GetRoutingState( audioRouting ) );
    //update routing and volume for this routing
    iAudioRouting = audioRouting;
    iVolume = OutputVolume( iAudioRouting );
    SetValue( iVolume );    
    __VTPRINTEXIT( "CVtUiVolumePopup.UpdateVolumeAndRoutingL" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::RefreshL
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::RefreshL()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.RefreshL" )
    MVtEngAudio& audio( iModel.Audio() );
    MVtEngAudio::TAudioRoutingState audioRouting;
    User::LeaveIfError( audio.GetRoutingState( audioRouting ) );

    // Check if audio routing has changed
    if ( audioRouting != iAudioRouting )
        {
        __VTPRINT( DEBUG_GEN,
            "CVtUiVolumePopup.RefreshL audio routing changed" )
        // Audio routing changed -> update routing and volume for this routing
        iAudioRouting = audioRouting;
        iVolume = OutputVolume( iAudioRouting );
        SetValue( iVolume );
        __VTPRINT2( DEBUG_GEN, "CVtUiVolumePopup.RefreshL routing = %d",
            iAudioRouting )
        __VTPRINT2( DEBUG_GEN, "CVtUiVolumePopup.RefreshL volume = %d",
            iVolume )
        ClosePopup();
        }
    else
        {
        // No change in audio routing
        const TInt volume( OutputVolume( iAudioRouting ) );
        if ( volume != iVolume )
            {
            __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.RefreshL volume changed" )
            iVolume = volume;
            SetValue( iVolume );
            __VTPRINT2( DEBUG_GEN, "CVtUiVolumePopup.RefreshL volume = %d",
                iVolume )
            if ( !IsPopUpVisible() )
                {
                __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.RefreshL OpenPopupL" )
                OpenPopupL();
                }
            else
                {
                __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.RefreshL ShowPopupL" )
                ShowPopupL();
                }
            }
        else
            {
            __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.RefreshL ShowPopupL2" )
            ShowPopupL();
            }
        }
    __VTPRINTEXIT( "CVtUiVolumePopup.RefreshL" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::DoActivateL()
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::DoActivateL()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.DoActivateL" )
    CVtUiPopupBase::DoActivateL();
    // In order to refresh softkey.
    iFeatureManager.AppUi().RefreshSoftkeysL();
    __VTPRINTEXIT( "CVtUiVolumePopup.DoActivateL" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::OfferKeyEventL()
// ---------------------------------------------------------------------------
//
TKeyResponse CVtUiVolumePopup::OfferKeyEventL( const TKeyEvent& aEvent,
    TEventCode /*aCode*/ )
    {
    __VTPRINTENTER( "CVtUiVolumePopup.OfferKeyEventL" )
    TKeyResponse response( EKeyWasNotConsumed );
    TVtUiSideVolumeKeysVariation svkvariation;
    if ( !svkvariation.IsSideVolumeKeysSupported() &&
         ( aEvent.iScanCode == EStdKeyLeftArrow ||
           aEvent.iScanCode == EStdKeyRightArrow ) )
        {
        ShowPopupL();
        UpdateVolumeL();
        }
    __VTPRINTEXITR( "CVtUiVolumePopup.OfferKeyEventL %d", response )
    return response;
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::HandleControlEventL
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::HandleControlEventL( CCoeControl* aControl,
    TCoeEvent aEventType )
    {
    __VTPRINTENTER( "CVtUiVolumePopup.HandleControlEventL" )
    CVtUiPopupBase::HandleControlEventL( aControl, aEventType );
    if ( aEventType == EEventStateChanged )
        {
        UpdateVolumeL();
        }
    __VTPRINTEXIT( "CVtUiVolumePopup.HandleControlEventL" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::CVtUiVolumePopup
// ---------------------------------------------------------------------------
//
CVtUiVolumePopup::CVtUiVolumePopup( CVtUiFeatureManager& aFeatureManager )
    : CVtUiPopupBase( aFeatureManager.ComponentManager(),
      TVtUiBlockListBitField(
        MVtUiComponent::EComponentIdToolbar |
        MVtUiComponent::EComponentIdNumberEntry |
        MVtUiComponent::EComponentIdZoom |
        MVtUiComponent::EVComponentIdContrast |
        MVtUiComponent::EVComponentIdBrightness ),
      EComponentIdVolume ),
      iModel( aFeatureManager.AppUi().Model() ), 
      iFeatureManager ( aFeatureManager ) 
    {
    __VTPRINTENTER( "CVtUiVolumePopup.CVtUiVolumePopup" )
    __VTPRINTEXIT( "CVtUiVolumePopup.CVtUiVolumePopup" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::ConstructL
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::ConstructL()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.ConstructL" )
    BaseConstructL();
    // set default value
    MVtEngAudio& audio( iModel.Audio() );
    MVtEngAudio::TAudioRoutingState audioRouting;
    User::LeaveIfError( audio.GetRoutingState( audioRouting ) );
    SetValue( OutputVolume( audioRouting ) );
    // set default audiorouting
    iAudioRouting = audioRouting;
    __VTPRINTEXIT( "CVtUiVolumePopup.ConstructL" )
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::OutputVolume
// ---------------------------------------------------------------------------
//
TInt CVtUiVolumePopup::OutputVolume(
    MVtEngAudio::TAudioRoutingState aRouting ) const
    {
    __VTPRINTENTER( "CVtUiVolumePopup.OutputVolume" )
    const MVtEngAudio& audio( iModel.Audio() );
    const TInt volume( audio.OutputVolume(
        !( aRouting == MVtEngAudio::EAudioLoudspeaker ) ) );
    __VTPRINTEXITR( "CVtUiVolumePopup.OutputVolume %d", volume )
    return volume;
    }

// ---------------------------------------------------------------------------
// CVtUiVolumePopup::UpdateVolumeL
// ---------------------------------------------------------------------------
//
void CVtUiVolumePopup::UpdateVolumeL()
    {
    __VTPRINTENTER( "CVtUiVolumePopup.UpdateVolumeL" )
    
    MVtEngAudio& audio( iModel.Audio() );
    MVtEngAudio::TAudioRoutingState audioRouting;
    User::LeaveIfError( audio.GetRoutingState( audioRouting ) );

    const TInt volume( OutputVolume( iAudioRouting ) );
    
    __VTPRINT2( DEBUG_GEN, "CVtUiVolumePopup.UpdateVolumeL volume = %d",
                volume )      
    __VTPRINT2( DEBUG_GEN, "CVtUiVolumePopup.UpdateVolumeL Value() = %d",
                Value() )                
    if ( volume != Value() )
        {
        MVtEngAudio::TVtEngOutputVolume newVolume;
        
        // Get current audio values from engine
        // and set new audio volume to right routing
        if ( iAudioRouting == MVtEngAudio::EAudioLoudspeaker )
            {
            __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.UpdateVolumeL.LS")
            // changed value
            newVolume.iHandsfreeVolume = Value();
            // old value
            TInt volume = audio.OutputVolume( ETrue );
            newVolume.iHandsetVolume = volume;
            }
        else
            {
            __VTPRINT( DEBUG_GEN, "CVtUiVolumePopup.UpdateVolumeL.HS")
            // changed value
            newVolume.iHandsetVolume = Value();
            // old value
            TInt volume = audio.OutputVolume( EFalse );
            newVolume.iHandsfreeVolume = volume;
            }
            
      iFeatureManager.AppUi().CmdUpdateVolumeL( newVolume );
      }
    __VTPRINTEXIT( "CVtUiVolumePopup.UpdateVolumeL" )    
    }