/*

* 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 media key handler

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <remconcoreapitarget.h>

#include <remconcoreapitargetobserver.h>

#include <remconinterfaceselector.h>

#include <aknconsts.h>

#include <AknUtils.h>

#include <eikenv.h>

#include <bautils.h>

#include <StringLoader.h>

#include <apgwgnam.h>

#include <utf.h>

#ifdef UPNP_INCLUDED

#include <upnpcopycommand.h>  

#endif

#include <aknnotewrappers.h>  // AknErrorNote

#include <AknVolumePopup.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <data_caging_path_literals.hrh>

#include <mpxmediakeyhandler.rsg>

#include <mpxmedia.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxuser.h>

#include <mpxmediakeyhandler.h>

#include <mpxlog.h>

#include <layoutmetadata.cdl.h>

#include <mpxconstants.h>

#include "mpxmetadatahandler.h"

#include <mpxplaybackframeworkdefs.h>

#include <sounddevice.h>

#include "mpxmediakeyhandlerimp.h"

#include "mpxremconkeyresponse.h"

#include "mpxnotifierdialog.h"

// CONSTANTS

const TInt KFirstTimerExpiryInterval( 1 ); // Expire immediately

const TInt KTimerExpiryInterval( KAknStandardKeyboardRepeatRate );

const TInt KMPXOneSecInMilliSecs( 1000 );

const TInt KMPXMinVolume(0);

const TInt KMPXMaxVolume(100);		// Max volume used in volume popup

const TInt KMPXVolumeSteps(1);

const TInt KTenStepsVolume = 10;   

const TInt KTwentyStepsVolume = 20;

const TInt KVolumePopupSynchInterval = 300000; // 300 ms

const TRemConCoreApiOperationId KSupportedCoreFeatures[] = {

        ERemConCoreApiVolumeUp,

        ERemConCoreApiVolumeDown,

        ERemConCoreApiPlay,

        ERemConCoreApiStop,

        ERemConCoreApiPause,

        ERemConCoreApiRewind,

        ERemConCoreApiFastForward,

        ERemConCoreApiForward,

        ERemConCoreApiBackward,

        ERemConCoreApiPausePlayFunction

};

_LIT( KMPXMediaKeyHandlerRscPath, "mpxmediakeyhandler.rsc" );

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPXMediaKeyHandlerImp::CMPXMediaKeyHandlerImp(

    MMPXMediaKeyHandlerObserver* aObserver ) :

    iObserver( aObserver ),

    iEnable( ETrue ),

    iCurrentVol( KErrNotFound ),

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXMediaKeyHandlerImp::ConstructL(

	TMPXMediaKeyPopupFlags aFlags )

    {

	ASSERT( iObserver );

    CCoeEnv* coeEnv = CEikonEnv::Static();

    TParse parse;

    parse.Set( KMPXMediaKeyHandlerRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile( parse.FullName() );

    User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    // Register to remote control framework

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    // For AVRCP 1.4 support, pass the core features to the target API. 

    TInt entrySize = sizeof( KSupportedCoreFeatures[0] );

    TRemConCoreApiOperationId* entries = (TRemConCoreApiOperationId*) &KSupportedCoreFeatures[0];

    TInt count = sizeof( KSupportedCoreFeatures ) / entrySize;

    RArray<TRemConCoreApiOperationId> coreFeatures( entrySize, entries, count );

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

    // For handling AVRCP 1.3 metadata

    iMetaDataHandler = MMPXMetaDataHandler::NewL(*iInterfaceSelector);

    // For AVRCP 1.4 support, make the player named. 

    HBufC* avsrcname = StringLoader::LoadLC( R_MPX_AVSRC_NAME_TEXT );

    HBufC8* avsrcname8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( avsrcname->Des() );

    CleanupStack::PushL( avsrcname8 );

    iInterfaceSelector->OpenTargetL(ERemConAudioPlayer, ERemConNoSubType, *avsrcname8);

    CleanupStack::PopAndDestroy( avsrcname8 );

    CleanupStack::PopAndDestroy( avsrcname );

    iResponseHandler = CMPXRemConKeyResponse::NewL( *iCoreTarget );

    // Timer for implementing repeat

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

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    // get the current Volume and Max Volume

    iPlaybackUtility->PropertyL(*this, EPbPropertyVolume);

    iPlaybackUtility->PropertyL(*this, EPbPropertyMute);

    CMMFDevSound* devsound = CMMFDevSound::NewL();	

    MPX_DEBUG2( "CMPXMediaKeyHandlerImp::Constructdevsound->MaxVolume()%d",devsound->MaxVolume());

    iVolumeSteps = KTenStepsVolume; //Default 10 steps

    if ( devsound && devsound->MaxVolume() >= KTwentyStepsVolume ) 

        {

         // set 20-steps volume

         iVolumeSteps = KTwentyStepsVolume;

        }    

    delete devsound;

    if ( aFlags & EDisplayVolumePopup )

        {

        // Popup volume control

        iVolPopup = CAknVolumePopup::NewL(NULL, ETrue);

        iVolPopup->SetObserver(this);

        iVolPopup->SetRange(KMPXMinVolume, iVolumeSteps);

        iVolPopup->SetStepSize(KMPXVolumeSteps);

        // Ensure that initial value is set to popup. If not initialized, CAknVolumePopup::Value() returns 0 

        // but the control appears unmuted and allows volume to be decreased out of range (panics also with Avkon 6 in UDEB)

        iVolPopup->SetValue( 0 );

        HBufC* popupText = StringLoader::LoadLC( R_MPX_VOLUME_POPUP_TEXT );

        iVolPopup->SetTitleTextL( *popupText );

        CleanupStack::PopAndDestroy( popupText );

        }

    if ( aFlags & EDisplayMediaPopup )

        {

        // Playback popup

        iPlaybackPopup = CMPXNotifierDialog::NewL();

        }

    MMPXSource* s = iPlaybackUtility->Source();

    if ( s )

        {

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL(attrs);

        attrs.Append( KMPXMediaGeneralTitle );

        s->MediaL( attrs.Array(), *this );

        CleanupStack::PopAndDestroy( &attrs );

        }

    else

        {

        // No current track.

        // This is constructed so that the first popup will display

        // it doesn't hold anything.

        iTrackTitle = HBufC::NewL( 1 );

        }

#ifdef UPNP_INCLUDED

    if (!iUpnpCopyCommand )

        {

        MPX_TRAPD ( error, iUpnpCopyCommand = CUpnpCopyCommand::NewL() );   

		    if ( error == KErrNone )

            {

            iUpnpFrameworkSupport = ETrue;

            }

        else

            {

            iUpnpFrameworkSupport = EFalse;

			iUpnpCopyCommand = NULL;

            }

        }

#endif

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

    }

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

// Two-phased constructor.

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

//

MMPXMediaKeyHandler* CMPXMediaKeyHandlerImp::NewL(

    TMPXMediaKeyPopupFlags aFlags,

    MMPXMediaKeyHandlerObserver* aObserver )

    {

    CMPXMediaKeyHandlerImp* self =

        new(ELeave)CMPXMediaKeyHandlerImp( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aFlags );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CMPXMediaKeyHandlerImp::~CMPXMediaKeyHandlerImp()

    {

    if ( iVolumePopupSynchTimer )

        {

        iVolumePopupSynchTimer->Cancel();

        delete iVolumePopupSynchTimer;

        }

    if ( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    delete iMetaDataHandler;

    delete iResponseHandler;

    delete iInterfaceSelector;

    if( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    if ( iResourceOffset )

        {

        CEikonEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    delete iTrackTitle;

    delete iVolPopup;

    delete iPlaybackPopup;

#ifdef UPNP_INCLUDED

    if ( iUpnpCopyCommand)

        {

        delete iUpnpCopyCommand;

        }

#endif

    }

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

// Filter and send command to playback utility.

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

//

void CMPXMediaKeyHandlerImp::FilterAndSendCommand(

    TMPXPlaybackCommand aCommandId )

    {

    MPX_FUNC( "CMPXMediaKeyHandlerImp::FilterAndSendCommand" );

    TRAP_IGNORE( DoFilterAndSendCommandL( aCommandId ) );

    }

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

// Help filter and send command to playback utility.

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

//

void CMPXMediaKeyHandlerImp::DoFilterAndSendCommandL(

    TMPXPlaybackCommand aCommandId )

    {

    MPX_FUNC( "CMPXMediaKeyHandlerImp::DoFilterAndSendCommandL" );

    // Only send media key events if the media key component is enabled

    if( iEnable )

        {

        TBool forwardCommand = ETrue;

        if ( iUpnpFrameworkSupport )

            {

            switch ( aCommandId )

                {

                case EPbCmdStartSeekForward:

                case EPbCmdStartSeekBackward:

                    {

                    if ( IsUpnpVisibleL() )

                        {

                        TFileName subPlayerName;

                        TMPXPlaybackPlayerType currentPlayerType = EPbLocal;

                        GetSubPlayerInfoL(subPlayerName, currentPlayerType);

                        if ( currentPlayerType != EPbLocal)

                            {

                            //show error note

                            HBufC* dialogText = StringLoader::LoadLC(R_MPX_MEDIA_KEY_NOT_SUPPORTED);

                            CAknErrorNote* errNote = new(ELeave) CAknErrorNote(ETrue);

                            errNote->SetTimeout(CAknNoteDialog::ELongTimeout);

                            errNote->ExecuteLD( *dialogText );

                            CleanupStack::PopAndDestroy( dialogText );

                            forwardCommand = EFalse;

                            }

                        }

                    break;

                    }

                default:

                    {

                    //do nothing

                    break;

                    }

                }

            }

        if ( forwardCommand )

            {

            TInt volume(0);

            TFileName subPlayerName;

            TMPXPlaybackPlayerType currentPlayerType = EPbLocal;

            GetSubPlayerInfoL(subPlayerName, currentPlayerType);

        	if ( currentPlayerType == EPbRemote )

                {

        	    volume = iUpnpVolume % ( KPbPlaybackVolumeLevelMax / iVolumeSteps )

            	                    + iCurrentVol * KPbPlaybackVolumeLevelMax / iVolumeSteps;

        	    }

        	else

        	    {

        	    volume = iCurrentVol * KPbPlaybackVolumeLevelMax/iVolumeSteps;

        	    }

            if ( volume < KMPXMinVolume )

                {

                volume = KMPXMinVolume;

                }

            if ( volume > KMPXMaxVolume )

                {

                volume = KMPXMaxVolume;

                }

            MPX_DEBUG3( "CMPXMediaKeyHandlerImp::DoFilterAndSendCommandL: aCommandId(%d), volume(%d)" , aCommandId, volume );

            iObserver->HandleMediaKeyCommand( aCommandId, volume );

            }

        }

    }

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

// Handle playback message.

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

//

void CMPXMediaKeyHandlerImp::DoHandlePlaybackMessageL(

    const CMPXMessage& aMessage )

    {

    MPX_FUNC( "CMPXMediaKeyHandlerImp::DoHandlePlaybackMessageL(CMPXMessage)");

    TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );

    if ( KMPXMessagePbMediaChanged == id )

        {

        if ( aMessage.IsSupported( KMPXMessagePbMedia ) )

            {

            CMPXMedia* media( aMessage.Value<CMPXMedia>( KMPXMessagePbMedia ) );

            User::LeaveIfNull( media );

            iPlaybackPosition = 0;

            DoHandleMediaL( *media, KErrNone );

            }

        }

    else if ( KMPXMessageGeneral == id )

        {

        TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ));

        TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ));

        switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )

            {

            case TMPXPlaybackMessage::EPropertyChanged:

                {

                TMPXPlaybackProperty property(

                    static_cast<TMPXPlaybackProperty>( type ) );

                TInt error( KErrNone );

                DoHandlePropertyL( property, data, error );

                break;

                }

            case TMPXPlaybackMessage::EStateChanged:

                {

                MPX_DEBUG2( "CMPXMediaKeyHandlerImp::HandlePlaybackMessageL - EStateChanged(%d)", type );

                TMPXPlaybackState state =

                    static_cast<TMPXPlaybackState>( type );

                DoHandleStateChangedL( state );

                break;

                }

            case TMPXPlaybackMessage::EMediaChanged:

                {

                MMPXSource* s = iPlaybackUtility->Source();

                if ( s )

                    {

                    RArray<TMPXAttribute> attrs;

                    CleanupClosePushL(attrs);

                    attrs.Append( KMPXMediaGeneralTitle );

                    MPX_DEBUG1( "CMPXMediaKeyHandlerImp::HandlePlaybackMessageL Media changed, calling MediaL to refresh" );

                    s->MediaL( attrs.Array(), *this );

                    CleanupStack::PopAndDestroy( &attrs );

                    }

                break;

                }

            case TMPXPlaybackMessage::ECommandReceived:

                {

                MPX_DEBUG2( "CMPXMediaKeyHandlerImp::HandlePlaybackMessageL - ECommandReceived(%d)", type );

                break;

                }

            case TMPXPlaybackMessage::ESkipping:

                {

                iSkipping = ETrue;

                break;

                }

            case TMPXPlaybackMessage::ESkipEnd:

                {

                iSkipping = EFalse;

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

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

// Handle playback property.

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

//

void CMPXMediaKeyHandlerImp::DoHandlePropertyL(

    TMPXPlaybackProperty aProperty,

    TInt aValue,

    TInt aError )

    {

    MPX_FUNC( "CMPXMediaKeyHandlerImp::DoHandlePropertyL" );

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

    iUpnpVolume = aValue; 

    if ( KErrNone == aError )

        {

        switch ( aProperty	)

            {

            case EPbPropertyPosition:

                {

                iPlaybackPosition = aValue / KMPXOneSecInMilliSecs;

                ShowPlaybackPopupL( EMPXPopupShowIfVisible );

                break;

                }

            case EPbPropertyMute:

            	{

            	iMuted = aValue;

            	StartVolumePopupSynchTimer();

				break;

				}

			case EPbPropertyVolume:

                {

                // Avkon Volume has 10 steps, but the rest of the framework

                // has 100 steps. Need to scale it to 10 steps.

                if ( aValue > 0 )

                    {

                    aValue = aValue * iVolumeSteps;

                    aValue = aValue / KPbPlaybackVolumeLevelMax;

                    if ( aValue > iVolumeSteps )

                        {

                        aValue = iVolumeSteps;

                        }

                    }

                if( iMuted && aValue > 0  ) // unmute

                    {

                    iMuted = EFalse;

                    iCurrentVol = aValue;

                    }

                else if( aValue == 0 ) // mute

                    {

                    if( !iMuted ) 

                        {

                        iMuted = ETrue;

                        }

                    }

                    {

                        {