/*

* 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>

#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;

_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 ),

    iVolumeSteps(KMPXMaxVolume)

    {

    }

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

// 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();

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

    // For handling AVRCP 1.3 metadata

    iMetaDataHandler = MMPXMetaDataHandler::NewL(*iInterfaceSelector);

    iInterfaceSelector->OpenTargetL();

    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);

        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

    }

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

// 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 ( 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 )

            {

            iVolumeEventCount++;

            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;

                }

            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:

            	{

                if ( iTouchVolEventCount > 0 )

                    {

                    --iTouchVolEventCount;

                    }

                if ( iVolumeEventCount > 0 )

                	{

                	--iVolumeEventCount;

                	}

            	iMuted = aValue;

            	if ( iMuted )

            	    {

            	    iVolPopup->SetValue( 0 );

            	    }

            	else

            		{

            		iVolPopup->SetValue( iCurrentVol );

            		}

				break;

				}

			case EPbPropertyVolume:

                {

				if ( iVolPopup )

					{

	                if ( iTouchVolEventCount > 0 )

	                    {

	                    --iTouchVolEventCount;

	                    }

					// 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;

                        	}

                        }

			            {

			            iMuted = EFalse;

			            iCurrentVol = aValue;

			            iVolPopup->SetValue( iCurrentVol );

			            }

		            else if( aValue == 0 ) // mute

			            {

			            if( !iMuted ) 

				            {

				            iMuted = ETrue;

				            iVolPopup->SetValue( 0 );

				            }

			            }

                    else if ( aValue != iCurrentVol && !iTouchVolEventCount && !iVolumeEventCount )

					    {

					    if ( aValue != 0 )

					        {

					        iCurrentVol = aValue;

					        }

				        iVolPopup->SetValue( iCurrentVol );

					    }

				    if ( iVolumeEventCount > 0 )

				    	{

				    	--iVolumeEventCount;

					    }

                    // send a command to UI to display Volume bar on device when controlling volume via UPnP  

                    if ( IsUpnpVisibleL() && iPlayerState != EPbStateNotInitialised )

                        {

                        TFileName subPlayerName;

                        TMPXPlaybackPlayerType currentPlayerType = EPbLocal;

                        GetSubPlayerInfoL( subPlayerName, currentPlayerType );

                        if ( currentPlayerType != EPbLocal )

                            {

                            iObserver->HandleMediaKeyCommand( EPbCmdSetVolume, iUpnpVolume ); 

                            }            

                        }

					if ( iUpnpFrameworkSupport )

						{

						SetVolumePopupTitleL();

						}

					}

				break;

                }

            default:

                {

                break;

                }