/*

* 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:  Button state manager for playback view

*

*/

// INCLUDE FILES

#include <aknbutton.h>

#include <mpxcommonplaybackview.rsg>

#include <AknsUtils.h>

#include <AknsSkinInstance.h>

#include <AknsDrawUtils.h>

#include <barsread.h>

#include <AknDef.h>

#include <featmgr.h>

#include <aknconsts.h>

#include "mpxbuttonmanager.h"

#include "mpxplaybackviewlayoutinterface.h"

#include "mpxcommonplaybackview.hrh"

#include "mpxlog.h"

// CONSTANTS

struct TStateAndCommandIds

    {

    TInt iState;

    TInt iEnterCommand;

    TInt iExitCommand;

    TInt iLongEnterCommand;

    TInt iLongExitCommand;

    };

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

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

// CMPXButtonManager::CMPXButtonManager

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

//

CMPXButtonManager::CMPXButtonManager(

    MMPXButtonCmdObserver* aObserver,

    MMPXPlaybackViewLayout* aLayout )

    : iObserver(aObserver),

      iLayout(aLayout),

      iEnabled(ETrue)

    {

    MPX_FUNC("CMPXButtonManager::CMPXButtonManager()");

    }

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

// CMPXButtonManager::NewL

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

//

CMPXButtonManager* CMPXButtonManager::NewL(

    MMPXButtonCmdObserver* aObserver,

    MMPXPlaybackViewLayout* aLayout,

    const CCoeControl &aContainer)

    {

    MPX_FUNC("CMPXButtonManager::NewL()");

    CMPXButtonManager* self = new (ELeave) CMPXButtonManager(

        aObserver,

        aLayout);

    CleanupStack::PushL(self);

    //self->ConstructL(aRect, aContainer);

    self->ConstructL(aContainer);

    CleanupStack::Pop();

    return self;

    }

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

// CMPXButtonManager::~CMPXButtonManager

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

//

CMPXButtonManager::~CMPXButtonManager()

    {

    MPX_FUNC("CMPXButtonManager::~CMPXButtonManager()");

//    iButtons.ResetAndDestroy();

    iAvkonButtons.ResetAndDestroy();

    if (iLongKeyTimer)

        {

        iLongKeyTimer->Cancel();

        delete iLongKeyTimer;

        }

    }

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

// CMPXButtonManager::ConstructL (overloaded for avkon button rocker)

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

//

void CMPXButtonManager::ConstructL(const CCoeControl &aContainer)

    {

    MPX_FUNC("CMPXButtonManager::ConstructL()");

    iIsLongPress = EFalse;

    iVolumeInRocker = (!FeatureManager::FeatureSupported( KFeatureIdSideVolumeKeys ));

    if( AknLayoutUtils::PenEnabled() )

        {

            iIsTouchUi = ETrue;

        }

    else

        {

            iIsTouchUi = EFalse;

        }

    if (!iVolumeInRocker)

        {

            iStopInRocker = ETrue;

        }

    else

        {

            iStopInRocker = EFalse;

        }

    if( !iIsTouchUi)

        {

        CreateRockerAvkonButtonsL(aContainer);

        }

    ActivateL();

    iLongKeyTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    }

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

// CMPXButtonManager::UpdateButtonStates

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

//

void CMPXButtonManager::UpdateButtonStates( TMPXPlaybackState aState )

    {

    MPX_DEBUG2("CMPXButtonManager::UpdateButtonStates(%d) entering", aState);

    if( !iIsTouchUi && !iIsSeeking )

        {

        if (aState == EPbStatePlaying)

            {

            // Playing

            if (iAvkonButtons[EButtonPlay]->IsVisible())

                {

                iAvkonButtons[EButtonPlay]->MakeVisible(EFalse);

                }

            if (!iAvkonButtons[EButtonPause]->IsVisible())

                {

                iAvkonButtons[EButtonPause]->MakeVisible(ETrue);

                }

            }

        else

            {

            // Not playing

            if (!iAvkonButtons[EButtonPlay]->IsVisible())

                {

                iAvkonButtons[EButtonPlay]->MakeVisible(ETrue);

                }

            if (iAvkonButtons[EButtonPause]->IsVisible())

                {

                iAvkonButtons[EButtonPause]->MakeVisible(EFalse);

                }

            }

        if (iAvkonButtons[EButtonPlay]->IsVisible())

            {

            if (aState == EPbStateNotInitialised &&

                !iAvkonButtons[EButtonPlay]->IsDimmed())

                {

                iAvkonButtons[EButtonPlay]->SetDimmed(ETrue);

                }

            if (aState != EPbStateNotInitialised &&

                iAvkonButtons[EButtonPlay]->IsDimmed())

                {

                iAvkonButtons[EButtonPlay]->SetDimmed(EFalse);

                }

            }

        for (TInt i = 0; i< iRockerAvkonButtonCount; i++)

            {

            iAvkonButtons[i]->SetCurrentState(0, ETrue);

            }

        }

    MPX_DEBUG1("CMPXButtonManager::UpdateButtonStates() exiting");

    }

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

// CMPXButtonManager::OfferKeyEventL

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

//

TKeyResponse CMPXButtonManager::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    MPX_DEBUG3("CMPXButtonManager::OfferKeyEventL(%d, %d) entering", aKeyEvent.iScanCode, aType);

    TKeyResponse response( EKeyWasNotConsumed );

    MPX_DEBUG2("CMPXButtonManager::OfferKeyEventL() exiting %d", response);

    return response;

    }

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

// CMPXButtonManager::SetParentRect

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

//

void CMPXButtonManager::SetParentRect(

    const TRect& aRect )

    {

    iParentRect = aRect;

    }

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

// CMPXButtonManager::SetEnabled

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

//

void CMPXButtonManager::SetEnabled( TBool aEnabled )

    {

    MPX_DEBUG2("CMPXButtonManager::SetEnabled(%d) entering", aEnabled);

    iEnabled = aEnabled;

    MPX_DEBUG1("CMPXButtonManager::SetEnabled() exiting");

    }

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

// CMPXButtonManager::HandleForegroundLostL

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

//

void CMPXButtonManager::HandleForegroundLostL()

    {

    MPX_FUNC( "CMPXButtonManager::HandleForegroundLostL" );

    iIsSeeking = EFalse;

 	if (iIsLongPress)

		{

		iIsLongPress = EFalse;

		iObserver->HandleButtonCommandL(EMPXPbvCmdEndSeek);

		}

	if(iLongKeyTimer)

		{

		iLongKeyTimer->Cancel();

		}

    }

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

// CMPXCommonPlaybackViewContainer::CreateRockerAvkonButtonsL

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

//

void CMPXButtonManager::CreateRockerAvkonButtonsL(const CCoeControl &aContainer)

    {

    TResourceReader reader;

    iRockerAvkonButtonCount = 0;

    CCoeEnv::Static()->CreateResourceReaderLC( reader, R_MPX_PBV_ROCKER_AVKON_BUTTONS );

    TInt numButtons( reader.ReadInt16() );

    CCoeControl::SetContainerWindowL(aContainer);

    for (TInt i = 0; i < numButtons; i++ )

        {

        CAknButton* aknButton = CAknButton::NewL();

        CleanupStack::PushL( aknButton );

        aknButton->SetContainerWindowL(*this);

        aknButton->SetParent( this );

        aknButton->ConstructFromResourceL( reader );

        aknButton->SetObserver( this );

        aknButton->SetLongPressInterval(1000);//KAknKeyboardRepeatInitialDelay / 1000);

        aknButton->SetKeyRepeatInterval(0, KAknKeyboardRepeatInitialDelay / 1000);

        aknButton->ActivateL();

        iAvkonButtons.AppendL( aknButton );

        CleanupStack::Pop( aknButton );

        iRockerAvkonButtonCount++;

        }

    CleanupStack::PopAndDestroy(); // reader;

    TResourceReader reader2;

    if (iVolumeInRocker)

        {

        CCoeEnv::Static()->CreateResourceReaderLC( reader2, R_MPX_PBV_ROCKER_VOLUME_AVKON_BUTTONS );

        numButtons = reader2.ReadInt16();

        for (TInt i = 0; i < numButtons; i++ )

            {

            CAknButton* aknButton = CAknButton::NewL();

            CleanupStack::PushL( aknButton );

            aknButton->SetContainerWindowL( *this );

            aknButton->SetParent( this );

            aknButton->ConstructFromResourceL( reader2 );

            aknButton->SetObserver( this );

            aknButton->SetLongPressInterval(1000);//KAknKeyboardRepeatInitialDelay / 1000);

            aknButton->SetKeyRepeatInterval(0, KAknKeyboardRepeatInitialDelay / 1000);

            aknButton->ActivateL();

            iAvkonButtons.AppendL( aknButton );

            CleanupStack::Pop( aknButton );

            iRockerAvkonButtonCount++;

            }

        }

    else

        {

        CCoeEnv::Static()->CreateResourceReaderLC( reader2, R_MPX_PBV_ROCKER_STOP_AVKON_BUTTON );

        CAknButton* aknButton = CAknButton::NewL();

        CleanupStack::PushL( aknButton );

        aknButton->SetContainerWindowL( *this );

        aknButton->SetParent( this );

        aknButton->ConstructFromResourceL( reader2 );

        aknButton->SetObserver( this );

        aknButton->SetLongPressInterval(1000);//KAknKeyboardRepeatInitialDelay / 1000);

        aknButton->SetKeyRepeatInterval(0, KAknKeyboardRepeatInitialDelay / 1000);

        aknButton->ActivateL();

        iAvkonButtons.AppendL( aknButton );

        CleanupStack::Pop( aknButton );

        iRockerAvkonButtonCount++;

        }

    CleanupStack::PopAndDestroy(); // reader2;

    }

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

// CMPXCommonPlaybackViewContainer::SetAvkonButtonState

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

//

        TEventCode aType)

    {

    TKeyResponse response = EKeyWasNotConsumed;

    if (aKeyEvent.iScanCode == EStdKeyLeftArrow || aKeyEvent.iCode == EKeyLeftArrow)

        {    

        if (aType == EEventKeyDown)

            {

            if (!iIsTouchUi)

                {

                iAvkonButtons[EButtonRewind]->SetCurrentState(1, ETrue); 

                }

            iLongKeyTimer->Cancel();

            iLongKeyTimer->Start(KAknKeyboardRepeatInitialDelay,

                                 KAknKeyboardRepeatInitialDelay,

                                 TCallBack(TimerCallback, this));

            iLongPressCommandId = EMPXPbvCmdSeekBackward;

            iIsSeeking = ETrue;

            }

        else if (aType == EEventKeyUp)

            {

            if (!iIsTouchUi)

                {

                iAvkonButtons[EButtonRewind]->SetCurrentState(0, ETrue);

                }

            iLongKeyTimer->Cancel();

            if (iIsLongPress)

               {

               iIsLongPress = EFalse;

               iObserver->HandleButtonCommandL(EMPXPbvCmdEndSeek);

               }

            else

               {

               iObserver->HandleButtonCommandL(EMPXPbvCmdPreviousListItem);

               }

            iIsLongPress = EFalse;

            response = EKeyWasConsumed;

            iIsSeeking = EFalse;

            }

        }

    else if (aKeyEvent.iScanCode == EStdKeyRightArrow || aKeyEvent.iCode == EKeyRightArrow)

        {

        if (aType == EEventKeyDown)

            {

	    	    if (!iIsTouchUi)

	    	        {

                iAvkonButtons[EButtonFastForward]->SetCurrentState(1, ETrue);

                }

            iLongKeyTimer->Cancel();

            iLongKeyTimer->Start(KAknKeyboardRepeatInitialDelay,

                                 KAknKeyboardRepeatInitialDelay,

                                 TCallBack(TimerCallback, this));

            iLongPressCommandId = EMPXPbvCmdSeekForward;

            iIsSeeking = ETrue;

            }

            else if (aType == EEventKeyUp)

                {

                if (!iIsTouchUi)

                    {

                    iAvkonButtons[EButtonFastForward]->SetCurrentState(0, ETrue);    

                    }

                iLongKeyTimer->Cancel();

                if (iIsLongPress)

                    {

                    iIsLongPress = EFalse;

                    iObserver->HandleButtonCommandL(EMPXPbvCmdEndSeek);

                    }

                else

                    {

                   iObserver->HandleButtonCommandL(EMPXPbvCmdNextListItem);

                   }

                iIsLongPress = EFalse;

                iIsSeeking = EFalse;

                response = EKeyWasConsumed;

                }

        }

    else if (aKeyEvent.iScanCode == EStdKeyDevice3 || aKeyEvent.iCode == EKeyDevice3

            || aKeyEvent.iScanCode == EStdKeyEnter || aKeyEvent.iCode == EKeyEnter)

   		{

        if (!iIsTouchUi)

            {

            if (aType == EEventKeyDown)

                {

                iKeyDownEventReceived = ETrue;

                if (iAvkonButtons[EButtonPause]->IsVisible())

                    {

                    iAvkonButtons[EButtonPause]->SetCurrentState(1, ETrue);

                    }

                else

                    {

                    iAvkonButtons[EButtonPlay]->SetCurrentState(1, ETrue);

                    }

                }

            else if (aType == EEventKeyUp)

                {

                if ( iKeyDownEventReceived )

                    {

                    if (iAvkonButtons[EButtonPause]->IsVisible())

                        {

                        iAvkonButtons[EButtonPause]->SetCurrentState(0, ETrue);

                        iObserver->HandleButtonCommandL(EMPXPbvCmdPause);

                        response = EKeyWasConsumed;

                        }

                    else

                        {

                        iAvkonButtons[EButtonPlay]->SetCurrentState(0, ETrue);

                        iObserver->HandleButtonCommandL(EMPXPbvCmdPlay);

                        response = EKeyWasConsumed;

                        }

                    }

                iKeyDownEventReceived= EFalse;

                }

            }

        else  //iIsTouchUi

            {

            if (aType == EEventKeyDown)

                {

                iKeyDownEventReceived = ETrue;

                }

            else if (aType == EEventKeyUp)

                {

                if ( iKeyDownEventReceived )

                    {

                    iObserver->HandleButtonCommandL(EMPXPbvCmdPlayPause );

                    response = EKeyWasConsumed;

                    }

                iKeyDownEventReceived = EFalse;

                }

            }	

   		}

    else if (aKeyEvent.iScanCode == EStdKeyDownArrow || aKeyEvent.iCode == EKeyDownArrow)

        {

        if (iVolumeInRocker || iStopInRocker)

           {	

           if (!iIsTouchUi)

               {

            if (aType == EEventKeyDown)

                {

                iAvkonButtons[EButtonVolumeDown]->SetCurrentState(1, ETrue);

                }

            else if (aType == EEventKeyUp)

                {

                iAvkonButtons[EButtonVolumeDown]->SetCurrentState(0, ETrue);

                if(iVolumeInRocker)

                    {

                    iObserver->HandleButtonCommandL(EMPXPbvCmdDecreaseVolume);

                    }

                else

                    {

                    iObserver->HandleButtonCommandL(EMPXPbvCmdStop);

                    }

                response = EKeyWasConsumed;

                    }

               }

		       else //iIsTouchUi

		           {

               if (iVolumeInRocker && aType == EEventKeyUp )

			             {            

                   iObserver->HandleButtonCommandL(EMPXPbvCmdDecreaseVolume);

                   }

               else if (iStopInRocker && aType == EEventKeyUp)

                   {                 		

                   iObserver->HandleButtonCommandL(EMPXPbvCmdStop);

                   }

               response = EKeyWasConsumed; 

               }

		        }

		    }

    else if (aKeyEvent.iScanCode == EStdKeyUpArrow || aKeyEvent.iCode == EKeyUpArrow)

        {

        if(iVolumeInRocker)

            {

	    	    if (!iIsTouchUi)

                {

                if (aType == EEventKeyDown)

                    {

                    iAvkonButtons[EButtonVolumeUp]->SetCurrentState(1, ETrue);

                    }

                else if (aType == EEventKeyUp)

                    {

                	  iAvkonButtons[EButtonVolumeUp]->SetCurrentState(0, ETrue);     		

                	  iObserver->HandleButtonCommandL(EMPXPbvCmdIncreaseVolume);

                	  response = EKeyWasConsumed;

                	  }

                }

            else //iIsTouchUi