/*

* Copyright (c) 2009 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 playback view's input handler

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <w32std.h> // RWindowBase

#include <e32base.h>

#include <eikclbd.h>

#include <aknconsts.h>

#include <remconcoreapi.h>

#include <remconcoreapitarget.h>

#include <remconinterfaceselector.h> // Side volume key

#include <mpxplaybackframeworkdefs.h>

#include <centralrepository.h>  // for peripheral display timeout setting

#include <settingsinternalcrkeys.h> // display timeout setting keys

#include <hwrmlightdomaincrkeys.h>

#include <mpxvideoplaybackdefs.h>

#include "mpxvideo_debug.h"

#include "mpxvideoviewwrapper.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "videoplaybackuserinputhandler.h"

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

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

// CVideoPlaybackUserInputHandler::CVideoPlaybackUserInputHandler()

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

//

CVideoPlaybackUserInputHandler::CVideoPlaybackUserInputHandler( CMPXVideoViewWrapper* aWrapper )

{

}

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

// CVideoPlaybackUserInputHandler::NewL()

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

//

{

    CVideoPlaybackUserInputHandler* self =

        new (ELeave) CVideoPlaybackUserInputHandler( aWrapper );

    CleanupStack::PushL( self );

    CleanupStack::Pop();

    return self;

}

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

// CVideoPlaybackUserInputHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

{

    MPX_ENTER_EXIT(_L("CVideoPlaybackUserInputHandler::ConstructL()"));

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

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    iCoreTarget = CRemConCoreApiTarget::NewL( *iInterfaceSelector, *this );

    // not detrimental if Media Keys dont work - so ignore any errors here

    TRAP_IGNORE( iInterfaceSelector->OpenTargetL() );

}

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

// CVideoPlaybackUserInputHandler::~CVideoPlaybackUserInputHandler()

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

//

CVideoPlaybackUserInputHandler::~CVideoPlaybackUserInputHandler()

{

    if ( iVolumeRepeatTimer )

    {

        iVolumeRepeatTimer->Cancel();

        delete iVolumeRepeatTimer;

    }

    if ( iInterfaceSelector )

    {

        delete iInterfaceSelector;

        iCoreTarget = NULL;

        iInterfaceSelector = NULL;

    }

}

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

// CVideoPlaybackUserInputHandler::MrccatoPlay()

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

//

void CVideoPlaybackUserInputHandler::MrccatoPlay( TRemConCoreApiPlaybackSpeed /*aSpeed*/,

                                                  TRemConCoreApiButtonAction aButtonAct )

{

    MPX_ENTER_EXIT(

        _L("CVideoPlaybackUserInputHandler::MrccatoPlay"),

        _L("aButtonAct = %d"), aButtonAct );

    ProcessMediaKey(ERemConCoreApiPlay, aButtonAct);

}

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

// CVideoPlaybackUserInputHandler::MrccatoCommand()

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

//

void CVideoPlaybackUserInputHandler::MrccatoCommand( TRemConCoreApiOperationId aOperationId,

                                                     TRemConCoreApiButtonAction aButtonAct )

{

    MPX_ENTER_EXIT(

        _L("CVideoPlaybackUserInputHandler::MrccatoCommand"),

        _L("aButtonAct = %d"), aButtonAct );

    ProcessMediaKey(aOperationId, aButtonAct);

}

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

// CVideoPlaybackUserInputHandler::DoHandleMediaKey()

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

//

void CVideoPlaybackUserInputHandler::DoHandleMediaKey( TRemConCoreApiOperationId aOperationId,

                                                       TRemConCoreApiButtonAction aButtonAct )

{

    switch ( aOperationId )

    {

        case ERemConCoreApiStop:

        {

            if ( aButtonAct == ERemConCoreApiButtonClick )

            {

            }

            break;

        }

        case ERemConCoreApiRewind:

        {

            break;

        }

        case ERemConCoreApiFastForward:

        {

            break;

        }

        case ERemConCoreApiVolumeUp:

        {

            break;

        }

        case ERemConCoreApiVolumeDown:

        {

            break;

        }

        case ERemConCoreApiPausePlayFunction:

        {

            if ( aButtonAct == ERemConCoreApiButtonClick )

            {

            }

            break;

        }

        case ERemConCoreApiPause:

        {

            break;

        }

        case ERemConCoreApiPlay:

        {

            if ( aButtonAct == ERemConCoreApiButtonClick )

            {

                TRAP_IGNORE(iViewWrapper->HandleCommandL(EMPXPbvCmdPlay));

            }

            break;

        }

        default:

            break;

    }

}

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

// CVideoPlaybackUserInputHandler::HandleFastForward()

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

//

void CVideoPlaybackUserInputHandler::HandleFastForward( TRemConCoreApiButtonAction aButtonAct )

{

    {

    }

    {

    }

}

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

// CVideoPlaybackUserInputHandler::HandleRewind()

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

//

void CVideoPlaybackUserInputHandler::HandleRewind( TRemConCoreApiButtonAction aButtonAct )

{

    {

    }

    {

    }

}

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

// CVideoPlaybackUserInputHandler::HandleVolumeUp()

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

//

void CVideoPlaybackUserInputHandler::HandleVolumeUp( TRemConCoreApiButtonAction aButtonAct )

{

    switch ( aButtonAct )

    {

        case ERemConCoreApiButtonPress:

        {

            // Volume Up - Pressed

            if ( iVolumeRepeatTimer->IsActive() )

            {

                iVolumeRepeatTimer->Cancel();

            }

            iVolumeRepeatUp = ETrue;

            iVolumeRepeatTimer->Start(

                KAknStandardKeyboardRepeatRate,

                KAknStandardKeyboardRepeatRate,

                TCallBack(

                    CVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL,

                    this ) );

            break;

        }

        case ERemConCoreApiButtonRelease:

        {

            // Volume Up - Released

            iVolumeRepeatTimer->Cancel();

            break;

        }

        case ERemConCoreApiButtonClick:

        {

            // Volume Up - Clicked

            TRAP_IGNORE( iViewWrapper->HandleCommandL( EMPXPbvCmdIncreaseVolume ) );

            break;

        }

    }

}

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

// CVideoPlaybackUserInputHandler::HandleVolumeDown()

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

//

void CVideoPlaybackUserInputHandler::HandleVolumeDown( TRemConCoreApiButtonAction aButtonAct )

{

    switch ( aButtonAct )

    {

        case ERemConCoreApiButtonPress:

        {

            // Volume Up - Pressed

            if ( iVolumeRepeatTimer->IsActive() )

            {

                iVolumeRepeatTimer->Cancel();

            }

            iVolumeRepeatUp = EFalse;

            iVolumeRepeatTimer->Start(

                KAknStandardKeyboardRepeatRate,

                KAknStandardKeyboardRepeatRate,

                TCallBack(

                    CVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL,

                    this ) );

            break;

        }

        case ERemConCoreApiButtonRelease:

        {

            // Volume Up - Released

            iVolumeRepeatTimer->Cancel();

            break;

        }

        case ERemConCoreApiButtonClick:

        {

            // Volume Down - Clicked

            TRAP_IGNORE( iViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) );

            break;

        }

    }

}

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

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

//

{

    {

        {

            {

            }

            break;

        }

        {

            {

                {

                }

            }

            break;

        }

}

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

// CVideoPlaybackUserInputHandler::ProcessMediaKey()

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

//

void CVideoPlaybackUserInputHandler::ProcessMediaKey( TRemConCoreApiOperationId aOperationId,

                                                      TRemConCoreApiButtonAction aButtonAct )

{

    {

        case EVideoNone:

        {

            {

                }

            }

            break;

        }

        case EVideoMediaKeys:

        {

            {

                // handle only if this release is for media-key being currently handled

                // ignore spurious media key presses

                {

                    // reset on click AND/OR release

                    iProcessingInputType = EVideoNone;

                }

            }

            break;

        }

        default:

        {

            // user input is disallowed

            break;

        }

    } // switch

}

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

//   CVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL()

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

//

TInt CVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL( TAny* aPtr )

{

    MPX_DEBUG(_L("CVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL()"));

    static_cast<CVideoPlaybackUserInputHandler*>(aPtr)->HandleVolumeRepeatL();

    return KErrNone;

}

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

//   CVideoPlaybackUserInputHandler::HandleVolumeRepeatL()

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

//

void CVideoPlaybackUserInputHandler::HandleVolumeRepeatL()

{

    MPX_DEBUG(_L("CVideoPlaybackUserInputHandler::HandleVolumeRepeatL()"));