/*

* 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: Music Player media key handler - private implementation.

*

*/

#include "mpmediakeyhandler_p.h"

#include "mpmediakeyhandler.h"

#include "mpmediakeyremconresponse.h"

#include "mpcommondefs.h"

//symbian header files

#include <remconcoreapitarget.h>

#include <remconinterfaceselector.h>

//mpx header files

#include <mpxplaybackutility.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxlog.h>

const TInt KFirstTimerExpiryInterval( 1 ); // Expire immediately

const TInt KTimerExpiryInterval( 1000000/6 );

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

// MpMediaKeyHandlerPrivate()

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

//

MpMediaKeyHandlerPrivate::MpMediaKeyHandlerPrivate( MpMediaKeyHandler *wrapper )

    : q_ptr( wrapper ),

      iInterfaceSelector(NULL),

      iResponseHandler(NULL),

      iTimer(NULL),

      iPlaybackUtility(NULL),

      iEnabled(ETrue)

{

}

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

// ~MpMediaKeyHandlerPrivate()

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

//

MpMediaKeyHandlerPrivate::~MpMediaKeyHandlerPrivate()

{

    if ( iPlaybackUtility ) {

        //TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

    }

    delete iResponseHandler;

    delete iInterfaceSelector;

    if ( iTimer ) {

        iTimer->Cancel();

        delete iTimer;

    }

}

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

// init

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

//

void MpMediaKeyHandlerPrivate::init()

{

    TRAPD(err, DoInitL());

    if ( err != KErrNone ) {

        emit q_ptr->errorOccured(err);

    }

}

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

// setEnabled

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

//

void MpMediaKeyHandlerPrivate::setEnabled( bool enable )

{

    iEnabled = enable;

}

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

// From MRemConCoreApiTargetObserver

// A command has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoCommand(

    TRemConCoreApiOperationId aOperationId,

    TRemConCoreApiButtonAction aButtonAct )

{

    MPX_DEBUG3( "MpMediaKeyHandlerPrivate::MrccatoCommand(aOperationId=%d, aButtonAct=%d)",

        aOperationId, aButtonAct );

    switch ( aOperationId ) {

    case ERemConCoreApiPausePlayFunction:

        if ( aButtonAct == ERemConCoreApiButtonClick ) {

            SendCommand( EPbCmdPlayPause );

        }

        break;

    case ERemConCoreApiPlay:

        if ( aButtonAct == ERemConCoreApiButtonClick

             || aButtonAct == ERemConCoreApiButtonPress ) {

            SendCommand( EPbCmdPlay );

        }

        break;

    case ERemConCoreApiStop:

        if ( aButtonAct == ERemConCoreApiButtonClick

             || aButtonAct == ERemConCoreApiButtonPress ) {

            SendCommand( EPbCmdStop );

        }

        break;

    case ERemConCoreApiPause:

        if ( aButtonAct == ERemConCoreApiButtonClick

             || aButtonAct == ERemConCoreApiButtonPress ) {

            SendCommand( EPbCmdPause );

        }

        break;

    case ERemConCoreApiRewind:

        switch ( aButtonAct ) {

        case ERemConCoreApiButtonPress:

            SendCommand( EPbCmdStartSeekBackward );

            break;

        case ERemConCoreApiButtonRelease:

            SendCommand( EPbCmdStopSeeking );

            break;

        default:

            break;

        }

        break;

    case ERemConCoreApiFastForward:

        switch ( aButtonAct ) {

        case ERemConCoreApiButtonPress:

            SendCommand( EPbCmdStartSeekForward );

            break;

        case ERemConCoreApiButtonRelease:

            SendCommand( EPbCmdStopSeeking );

            break;

        default:

            break;

        }

        break;

    case ERemConCoreApiBackward:

        if ( aButtonAct == ERemConCoreApiButtonClick ) {

            SendCommand( EPbCmdPrevious );

        }

        break;

    case ERemConCoreApiForward:

        if ( aButtonAct == ERemConCoreApiButtonClick ) {

            SendCommand( EPbCmdNext );

        }

        break;

    case ERemConCoreApiVolumeUp:

        iTimer->Cancel();

        iIncreaseVol = ETrue;

        switch ( aButtonAct ) {

        case ERemConCoreApiButtonPress:

            //Start Timer

            iTimer->Start(

                KFirstTimerExpiryInterval,

                KTimerExpiryInterval,

                TCallBack( TimerCallback, this ) );

            break;

        case ERemConCoreApiButtonClick:

            SendCommand( EPbCmdIncreaseVolume );

            break;

        case ERemConCoreApiButtonRelease:

        default:

            break;

        }

        break;

    case ERemConCoreApiVolumeDown:

        iTimer->Cancel();

        iIncreaseVol = EFalse;

        switch ( aButtonAct ) {

        case ERemConCoreApiButtonPress:

            //Start Timer

            iTimer->Start(

                KFirstTimerExpiryInterval,

                KTimerExpiryInterval,

                TCallBack( TimerCallback, this ) );

            break;

        case ERemConCoreApiButtonClick:

            SendCommand( EPbCmdDecreaseVolume );

            break;

        case ERemConCoreApiButtonRelease:

        default:

            break;

        }

        break;

    default:

        break;

    }

    iResponseHandler->CompleteAnyKey( aOperationId );

}

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

// From MRemConCoreApiTargetObserver

// A 'play' command has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoPlay(

    TRemConCoreApiPlaybackSpeed aSpeed,

    TRemConCoreApiButtonAction aButtonAct )

{

    MPX_DEBUG2( "MpMediaKeyHandlerPrivate::MrccatoPlay(aButtonAct=%d)", aButtonAct );

    Q_UNUSED(aSpeed);

    if ( ( aButtonAct == ERemConCoreApiButtonClick ) ||

        ( aButtonAct == ERemConCoreApiButtonPress ) )

        {

        SendCommand( EPbCmdPlay );

        }

    iResponseHandler->CompleteAnyKey( ERemConCoreApiPlay );

}

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

// From MRemConCoreApiTargetObserver

// A 'tune function' command has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoTuneFunction(

    TBool aTwoPart,

    TUint aMajorChannel,

    TUint aMinorChannel,

    TRemConCoreApiButtonAction aButtonAct )

{

    Q_UNUSED(aTwoPart);

    Q_UNUSED(aMajorChannel);

    Q_UNUSED(aMinorChannel);

    Q_UNUSED(aButtonAct);

    iResponseHandler->CompleteAnyKey( ERemConCoreApiTuneFunction );

}

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

// From MRemConCoreApiTargetObserver

// A 'select disk function' has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoSelectDiskFunction(

    TUint aDisk,

    TRemConCoreApiButtonAction aButtonAct )

{

    Q_UNUSED(aDisk);

    Q_UNUSED(aButtonAct);

    iResponseHandler->CompleteAnyKey( ERemConCoreApiSelectDiskFunction );

}

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

// From MRemConCoreApiTargetObserver

// A 'select AV input function' has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoSelectAvInputFunction(

    TUint8 aAvInputSignalNumber,

    TRemConCoreApiButtonAction aButtonAct )

{

    Q_UNUSED(aAvInputSignalNumber);

    Q_UNUSED(aButtonAct);

    iResponseHandler->CompleteAnyKey( ERemConCoreApiSelectAvInputFunction );

}

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

// From MRemConCoreApiTargetObserver

// A 'select audio input function' has been received.

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

//

void MpMediaKeyHandlerPrivate::MrccatoSelectAudioInputFunction(

    TUint8 aAudioInputSignalNumber,

    TRemConCoreApiButtonAction aButtonAct )

{

    Q_UNUSED(aAudioInputSignalNumber);

    Q_UNUSED(aButtonAct);

    iResponseHandler->CompleteAnyKey( ERemConCoreApiSelectAudioInputFunction );

}

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

// From MMPXPlaybackCallback

// Handle playback property.

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

//

void MpMediaKeyHandlerPrivate::HandlePropertyL(

    TMPXPlaybackProperty aProperty,

    TInt aValue,

    TInt aError )

{

    MPX_FUNC( "MpMediaKeyHandlerPrivate::DoHandlePropertyL" );

    MPX_DEBUG4( "MpMediaKeyHandlerPrivate::HandlePropertyL - Property(%d); Value(%d); Error(%d)", aProperty, aValue, aError );

    if ( KErrNone == aError ) {

        switch ( aProperty  ) {

        case EPbPropertyVolume:

            q_ptr->emit volumeChanged(aValue);

            break;

        case EPbPropertyPosition:

        case EPbPropertyMaxVolume:

        case EPbPropertyMute:

        default:

            break;

        }

    }

}

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

// From MMPXPlaybackCallback

// HandleSubPlayerNamesL

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

//

void MpMediaKeyHandlerPrivate::HandleSubPlayerNamesL(

    TUid aPlayer,

    const MDesCArray* aSubPlayers,

    TBool aComplete,

    TInt aError )

{

    MPX_FUNC( "MpMediaKeyHandlerPrivate::HandleSubPlayerNamesL" );

    Q_UNUSED(aPlayer);

    Q_UNUSED(aSubPlayers);

    Q_UNUSED(aComplete);

    Q_UNUSED(aError);

}

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

// From MMPXPlaybackCallback

// Handle media properties.

// Notes: The client is responsible for delete the object of aMedia.

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

//

void MpMediaKeyHandlerPrivate::HandleMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

{

    MPX_FUNC( "MpMediaKeyHandlerPrivate::DoHandleMediaL" );

    Q_UNUSED(aMedia);

    Q_UNUSED(aError);

}

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

// DoInitL()

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

//

void MpMediaKeyHandlerPrivate::DoInitL()

{

    // Register to remote control framework

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

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

    CleanupStack::PushL( coreTarget );

    iInterfaceSelector->OpenTargetL();

    iResponseHandler = MpMediaKeyRemConResponse::NewL( *coreTarget );

    CleanupStack::Pop(coreTarget);

    // Timer for implementing repeat

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

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( TUid::Uid(MpCommon::KMusicPlayerUid) );

    //iPlaybackUtility->AddObserverL( *this );

    iEnabled = ETrue;

}

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

// Send command to playback utility.

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

//

void MpMediaKeyHandlerPrivate::SendCommand( TMPXPlaybackCommand aCommandId )

{

    MPX_FUNC( "MpMediaKeyHandlerPrivate::SendCommand" );

    TRAP_IGNORE( DoSendCommandL( aCommandId ) );

}

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

// Send command to playback utility.

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

//

void MpMediaKeyHandlerPrivate::DoSendCommandL( TMPXPlaybackCommand aCommandId )

{

    MPX_FUNC( "MpMediaKeyHandlerPrivate::DoFilterAndSendCommandL" );

    if ( iEnabled )

    {

        TMPXPlaybackState playerState( iPlaybackUtility->StateL() );

        switch ( aCommandId ) {

        case EPbCmdIncreaseVolume:

                iPlaybackUtility->CommandL( EPbCmdIncreaseVolume );

            }

            break;

        case EPbCmdDecreaseVolume:

                iPlaybackUtility->CommandL( EPbCmdDecreaseVolume );

            }

            break;

        default:

            break;

        }

    }

}

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

// Callback for timer

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

//

TInt MpMediaKeyHandlerPrivate::TimerCallback( TAny* aPtr )

{

    static_cast<MpMediaKeyHandlerPrivate*>( aPtr )->HandleRepeatEvent();

    return KErrNone;

}

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

// Handle repeat event

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

//

void MpMediaKeyHandlerPrivate::HandleRepeatEvent()

{

    if ( iIncreaseVol ) {

        SendCommand( EPbCmdIncreaseVolume );

    }

    else {

        SendCommand( EPbCmdDecreaseVolume );

    }

}