/*

* 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:  Implementation of Common Playback view's container.

*

*/

// INCLUDE FILES

#include <eiklabel.h>

#include <eikimage.h>

#include <eikprogi.h>

#include <eikmenub.h>

#include <eikappui.h>

#include <eikenv.h>

#include <aknview.h>

#include <AknsUtils.h>

#include <AknDef.h>

#include <AknsConstants.h>

#include <AknsSkinInstance.h>

#include <AknsControlContext.h>

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <barsread.h>

#include <centralrepository.h>

#include <StringLoader.h>

#include <fontids.hrh>

#include <gulfont.h>

#include <applayout.cdl.h>

#include <AknIconArray.h>

#include <AknIconUtils.h>

#include <gulicon.h>

#include <featmgr.h>

#include <aknnotewrappers.h>

#include <data_caging_path_literals.hrh>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <avkon.mbg>

#include <mpxcommonplaybackview.rsg>

#include <mpxcommonplaybackview.mbg>

#include <mpxconstants.h>

#include <mpxfmtx.rsg> // For FF_FMTX

#include <mpxappui.hrh>

#include <mpxinternalcrkeys.h>

#include <touchfeedback.h>

#include <akntranseffect.h>                 // For transition effects

#include <gfxtranseffect/gfxtranseffect.h>  // For transition effects

#include "mpxcommonplaybackviewcontainer.h"

#include "mpxcommonplaybackviewlayout.h"

#include "mpxcommonplaybackview.hrh"

#include "mpxplaybackview.hlp.hrh"

#include "mpxplaybackviewinfolabel.h"

#include "mpxplaybackviewlayoutinterface.h"

#include "mpxlayoutswitchobserver.h"

#include "mpxcommonuihelper.h"

#include "mpxbuttonmanager.h"

#include "mpxlog.h"

// CONSTANTS

const TInt KLabelCount = ETextCount;

const TInt KMPXMinSecSeparatorIndex = 2;

_LIT(KMPXZeroDurationMark, "--");

const TInt KOneHourInSeconds = 3600;

const TInt KMPXTimeIndicatorLength = 16;

// S60 softkey positions in CBA

const TInt KMPXCbaLeftSoftkeyPos = 0;

const TInt KMPXCbaRightSoftkeyPos = 2;

// delay for actual seek operation

const TInt KSeekDelay = 100000; // 0.1s

const TInt KOneSecondInOneMilliSecond = 1000;

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

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

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::ConstructL( const TRect& /*aRect*/ )

    {

    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::ConstructL() entering" );

    CreateWindowL();

    TAknWindowLineLayout screenLayout =

        AknLayout::screen();

    TRect screenRect = screenLayout.Rect();

	iBackground = CAknsBasicBackgroundControlContext::NewL(

			KAknsIIDQsnBgAreaMain, screenRect, EFalse );

	iSeekTimer = CPeriodic::NewL( EPriorityLow );

    TInt flags( 0 );

    CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );

    User::LeaveIfError( repository->Get( KMPXMPLocalVariation, flags ));

    delete repository;

    repository = NULL;

    iEnableMarquee = static_cast<TBool>( flags & KMPXMarqueeArtistName );

    iEnableButtons = static_cast<TBool>( flags & KMPXRockerMappingSupport );

    // Create labels

    CreateLabelsL();

    iLabels[ETextPlaylistCount]->MakeVisible( ETrue );

	if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) )

		{

    	// By default, FMTX label is displayed

    	iLabels[ETextFMFrequency]->MakeVisible( ETrue );

    	SetFMTXMode(ETrue);

		}

    // Create icons

    CreateIconsL();

    // Create buttons if enabled

    if ( iEnableButtons )

        {

        TRect rockerParentRect;

        if ( iCurrentLayout.Width())

        {

            rockerParentRect = iCurrentLayout;

        }

        else

        {

            rockerParentRect = iCurrentLayout;

        }

        iButtonManager = CMPXButtonManager::NewL(

            this,

            iLayout,

            *this);

        iButtonManager->SetContainerWindowL( *this );

        iButtonManager->SetMopParent( this );

        iButtonManager->SetRect(rockerParentRect);

        }

     // Read time format strings from AVKON resource

    iMinSecFormatString = StringLoader::LoadL(

        R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

    iShortFormatString =

        StringLoader::LoadL( R_QTN_TIME_DURAT_SHORT_WITH_ZERO );

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    // Refresh the progress bar

    UpdateProgressBarGraphics();

    iMode = EUninitialized;

    iLabels[ETextArtist]->MakeVisible( EFalse );

    iLabels[ETextTrack]->MakeVisible( EFalse );

    iLabels[ETextElapsedTime]->MakeVisible( EFalse );

    iLabels[ETextRemainingTime]->MakeVisible( EFalse );

    iDisplayAlbumArt = EFalse;

    ActivateL();

    iTouchDown = EFalse;

    iActiveView = ETrue;

    iPrerollCompleted = EFalse;

    iLightStatus = CHWRMLight::ELightStatusUnknown;

    iIsForeground = EFalse ;

    iLight = CHWRMLight::NewL(this);

	DrawableWindow()->SetPointerGrab( ETrue );

    EnableDragEvents();

    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::ConstructL() exiting" );

    }

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

// Destructor

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

//

EXPORT_C CMPXCommonPlaybackViewContainer::~CMPXCommonPlaybackViewContainer()

    {

    // Pointer events

    SetGloballyCapturing( EFalse );

    SetPointerCapture( EFalse );

    FreeIcons();

    delete iTrackAlbumArt;

    delete iBackground;

    iLabels.ResetAndDestroy();

    delete iMinSecFormatString;

    delete iShortFormatString;

    delete iCommonUiHelper;

    if ( iLight )

        {

        delete iLight;

        iLight = NULL;

        }

    delete iButtonManager;

   MTouchFeedback* feedback = MTouchFeedback::Instance();

   if (feedback)

       {

       feedback->RemoveFeedbackForControl(this);

       }

    if ( iIdle )

        {

        iIdle->Cancel();

        delete iIdle;

        }

	if ( iSeekTimer )

		{

		iSeekTimer->Cancel();

		delete iSeekTimer;

		}

    }

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

// Updates time indicators.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateTimeIndicatorsL(

    TInt aPlaybackPosInSeconds,

    TInt aTotalLengthInSeconds )

    {

    iTrackTotalLengthInSeconds = aTotalLengthInSeconds;

    if (!iTouchDown)

        {

        if( iDragProgressBar )

          {

          TInt expectPlaybackPos = iNewSongPosition / KOneSecondInOneMilliSecond;

          if( expectPlaybackPos == aPlaybackPosInSeconds )

              {

              iDragProgressBar = EFalse;

              }

          else

              {

              return;

              }

          }

    if ( aTotalLengthInSeconds == 0 )

        {

        TLocale locale;

        TBuf<KMPXTimeIndicatorLength> pos;

        TChar separator = locale.TimeSeparator( KMPXMinSecSeparatorIndex );

        pos = KMPXZeroDurationMark;

        pos.Append( separator );

        pos += KMPXZeroDurationMark;

        UpdateLabelL( ETextElapsedTime, pos );

        UpdateLabelL( ETextRemainingTime, pos );

        }

    else

        {

        CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =

            CMPXCommonUiHelper::EMPXDuratAuto;

        if ( aTotalLengthInSeconds > KOneHourInSeconds )

            {

            durationMode = CMPXCommonUiHelper::EMPXDuratHMS;

            }

        // Convert ellapsed time to texts

        HBufC* position = iCommonUiHelper->DisplayableDurationL(

            aPlaybackPosInSeconds,

            durationMode );

        CleanupStack::PushL( position );

        TInt remainingTime = aTotalLengthInSeconds - aPlaybackPosInSeconds;

        if ( remainingTime < 0 )

            {

            // Convert all negative value to zero

            remainingTime = 0;

            }

        // Convert remaining time to texts

        HBufC* remaining = iCommonUiHelper->DisplayableDurationL(

            remainingTime,

            durationMode );

        CleanupStack::PushL( remaining );

        UpdateLabelL( ETextElapsedTime, *position );

        UpdateLabelL( ETextRemainingTime, *remaining );

        CleanupStack::PopAndDestroy( remaining );

        CleanupStack::PopAndDestroy( position );

        }

    if ( ( iMode != EUninitialized )

         || ( iMode == EPlayMode || iMode == EPauseMode ) )

        {

        if ( aTotalLengthInSeconds )

            {

            TReal t = aTotalLengthInSeconds;

            iPlaybackRatio = aPlaybackPosInSeconds / t;

            }

        RefreshProgressBar();

        }

        }

    }

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

// Updates label

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateLabelL(

    TMPXPbvTextIndicator aLabel,

    const TDesC& aText )

    {

    ASSERT( aLabel >= 0 && aLabel < iLabels.Count() );

    CMPXPlaybackViewInfoLabel* label = iLabels[aLabel];

    if(aLabel == ETextDownloadState)

        {

        iSliderPaneRect = iLayout->IndicatorLayout( Rect(), ESliderPane );

        iLayout->LayoutLabel(

        iLabels[ETextDownloadState], iSliderPaneRect, ETextDownloadState );

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        TRgb color = KRgbBlack;

        AknsUtils::GetCachedColor(

            skin,

            color,

            KAknsIIDQsnTextColors,

            EAknsCIQsnTextColorsCG50 );

        AknLayoutUtils::OverrideControlColorL(

            *iLabels[ETextDownloadState],

            EColorLabelText,

            color );

        }

    if ( label )

        {

        TBool needRedraw = EFalse;

        if ( label->FullText() != aText )

            {

            needRedraw = ETrue;

            label->SetLabelTextL( aText);

            }

        if ( needRedraw && label->IsVisible() )

            {

            label->StartMarquee();

            label->DrawDeferred();

            }

        }

    }

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

// Sets main pane mode.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::SetMode( TMPXPbvPlaybackMode aMode )

    {

    iMode = aMode;

    iDisplayAlbumArt = ETrue;

    switch ( iMode )

        {

	    case EUninitialized:

	    	{

	    	// Set label visibility

	        iLabels[ETextArtist]->MakeVisible( ETrue );

	        iLabels[ETextTrack]->MakeVisible( ETrue );

	        //iLabels[ETextEmpty]->MakeVisible( EFalse );

	        iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

	        iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

        	break;

        	}

        case ENoTracksMode:

            {

            // Set label visibility

            iLabels[ETextArtist]->MakeVisible( EFalse );

            iLabels[ETextTrack]->MakeVisible( EFalse );

            //iLabels[ETextEmpty]->MakeVisible( ETrue );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            iDisplayAlbumArt = EFalse;

            break;

            }

        case EStopMode:

            {

            // Fixed the layout for Download label and time label are overlaped in position

            iLabels[ETextTrack]->MakeVisible( ETrue );

            iLabels[ETextArtist]->MakeVisible( ETrue );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        case EInitialising:

            {

            iLabels[ETextTrack]->MakeVisible( ETrue );

            iLabels[ETextArtist]->MakeVisible( ETrue );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        case EMediaKeySkipping:

            {

            iLabels[ETextTrack]->MakeVisible( ETrue );

            iLabels[ETextArtist]->MakeVisible( ETrue );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        case EInvalidMode:

            {

            iLabels[ETextTrack]->MakeVisible( EFalse );

            iLabels[ETextArtist]->MakeVisible( EFalse );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        case EBufferingMode:

            {

            // Set label visibility

            iLabels[ETextArtist]->MakeVisible( ETrue );

            iLabels[ETextTrack]->MakeVisible( ETrue );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        default:

            {

            // Set label visibility

            iLabels[ETextArtist]->MakeVisible( ETrue );

            iLabels[ETextTrack]->MakeVisible( ETrue );

            //iLabels[ETextEmpty]->MakeVisible( EFalse );

            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);

            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;

            }

        }

    if ( iMode == EPlayMode )

        {

        iLabels[ETextArtist]->StartMarquee();

        iLabels[ETextTrack]->StartMarquee();

        }

    else

        {

        iLabels[ETextArtist]->StopMarquee();

        iLabels[ETextTrack]->StopMarquee();

        }

    DrawDeferred();

    }

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

// Set random mode.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::SetRandomMode( TBool aRandomMode )

    {

    iRandomMode = aRandomMode;

    Window().Invalidate( iRandomIconRect );

    }

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

// Set repeat mode.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::SetRepeatMode(

    TBool aRepeatAll,

    TBool aRepeatOne )

    {

    iRepeatAllMode = aRepeatAll;

    iRepeatOneMode = aRepeatOne;

    Window().Invalidate( iRepeatIconRect );

    }

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

// Set RealPlayer mode.

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

//

EXPORT_C void CMPXCommonPlaybackViewContainer::SetRealAudioMode(

    TBool aRealAudioMode )

    {

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

    iRealAudioMode = aRealAudioMode;

    Window().Invalidate( iRealIconRect );

#else

    (void) aRealAudioMode;

    ASSERT( 0 );

#endif