/*

* Copyright (c) 2008 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 metadata handler

*

*/

#include <bldvariant.hrh>

#include <remconinterfaceselector.h>

#include <bautils.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxplaybackmessage.h>

#include <data_caging_path_literals.hrh>

#include <mpxmedia.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxuser.h>

#include <mpxlog.h>

#include <playerinformationtarget.h>

#include <remcongroupnavigationtarget.h>

#include <utf.h>

#include <remcon/avrcpspec.h>

#include <mpxmediamusicdefs.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <EqualizerConstants.h>

#include <centralrepository.h>

#include "mpxmetadatahandler.h"

#include "mpxmetadatahandlerimp.h"

// CONSTANTS

const TInt KMPXOneSecInMilliSecs( 1000 );

// Definition of remotely controllable application settings

// The commented settings are not used here, included for reference.

_LIT( KMPlayerSettingsDefs, "mplayeravrcpsettings.rsc" );

const TInt KAvrcpEqualizerMode = 0x01;

const TInt KAvrcpRepeatMode = 0x02;

const TInt KAvrcpShuffleMode = 0x03;

//const TInt KAvrcpScanMode = 0x04;

const TInt KAvrcpOff = 0x01;

const TInt KAvrcpOn = 0x02;

// Off                      0x01

//const TInt KAvrcpSingleTrackRepeat = 0x02;

//const TInt KAvrcpAllTracksRepeat = 0x03;

//const TInt KAvrcpGroupRepeat = 0x04;

// Off                      0x01

const TInt KAvrcpAllTracksShuffle = 0x02;

//const TInt KAvrcpGroupShuffle = 0x03;

// Extended settings defined for Music Player

// Note that these are also defined in mplayeravrcpsettings.rss

const TInt KAvrcpBassBoostMode = 0x80;

const TInt KAvrcpStereoWideningMode = 0x81;

const TUid KCRUidMusicPlayerSettings = {0x101FFCDC};

const TUint32 KMPlayerEqPresetId = 0x00000001;

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

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

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

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

//

CMPXMetaDataHandlerImp::CMPXMetaDataHandlerImp()

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXMetaDataHandlerImp::ConstructL(CRemConInterfaceSelector &aInterfaceSelector)

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::ConstructL(CRemConInterfaceSelector)");

    iPlayerInformationTarget = CPlayerInfoTarget::NewL(aInterfaceSelector, 

                                                iPlayerCapabilitiesObserver, 

                                                iPlayerApplicationSettingsObserver, 

                                                iPlayerEventsObserver, *this);

    iMediaInfoTarget = CRemConMediaInformationTarget::NewL( aInterfaceSelector, *this );

    iGroupNavigationTarget = CRemConGroupNavigationApiTarget::NewL( aInterfaceSelector, *this );

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    MMPXSource* s = iPlaybackUtility->Source();

    if ( s )

        {

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL(attrs);

        (void) attrs.Append( KMPXMediaGeneralTitle );

        (void) attrs.Append( KMPXMediaGeneralDuration );

        (void) attrs.Append( KMPXMediaGeneralId );

        (void) attrs.Append( KMPXMediaMusicArtist );

        (void) attrs.Append( KMPXMediaMusicAlbum );

        (void) attrs.Append( KMPXMediaMusicGenre );

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

        CleanupStack::PopAndDestroy( &attrs );

        }

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    TParse parse;   

    parse.Set( KMPlayerSettingsDefs, &KDC_RESOURCE_FILES_DIR, NULL );

    TFileName resourceFile( parse.FullName() );

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

    BaflUtils::NearestLanguageFile( fs, resourceFile );

    CResourceFile* playerSettingsResourceFile = CResourceFile::NewLC( fs, resourceFile, 0, 0 );

    PlayerApplicationSettingsResourceInit::DefineAttributesL( *iPlayerApplicationSettingsObserver, *playerSettingsResourceFile );

    CleanupStack::PopAndDestroy( playerSettingsResourceFile );

    CleanupStack::PopAndDestroy( &fs );

        // Adding two optional events, mandatory ERegisterNotificationPlaybackStatusChanged 

        // and ERegisterNotificationTrackChanged are added by SOS.

    User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationPlaybackPosChanged));

    User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationPlayerApplicationSettingChanged));

    iEqPresetListener = CEqualizerPresetChangeListener::NewL(*this);

    iLastEqPresetId = iEqPresetListener->GetCurrentPresetL();

    iEqPresetListener->StartL();

    iTrackNumber = 0;

    iColId.iUid = -1;

    //Notify accessories that currently no track is playing.

    iPlayerEventsObserver->TrackChanged(MPlayerEventsObserver::KNoTrackSelected, 

        MPlayerEventsObserver::KPlaybackPositionUnknown);

    }

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

// Two-phased constructor.

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

//

MMPXMetaDataHandler* CMPXMetaDataHandlerImp::NewL(CRemConInterfaceSelector &aInterfaceSelector)

    {

    CMPXMetaDataHandlerImp* self = new(ELeave)CMPXMetaDataHandlerImp();

    CleanupStack::PushL( self );

    self->ConstructL(aInterfaceSelector);

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//

CMPXMetaDataHandlerImp::~CMPXMetaDataHandlerImp()

    {

    if( iEqPresetListener )

        {

        iEqPresetListener->Stop();

        delete iEqPresetListener;

        }

    if( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    delete iTrackTitle;

    delete iArtist;

    delete iAlbum;

    delete iGenre;

    delete iMetadataIter;

    }

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

// Handle playback message.

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

//

void CMPXMetaDataHandlerImp::DoHandlePlaybackMessageL(

    const CMPXMessage& aMessage )

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::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( "CMPXMetaDataHandlerImp::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);

                    (void) attrs.Append( KMPXMediaGeneralTitle );

                    (void) attrs.Append( KMPXMediaGeneralDuration );

                    (void) attrs.Append( KMPXMediaGeneralId );

                    (void) attrs.Append( KMPXMediaMusicArtist );

                    (void) attrs.Append( KMPXMediaMusicAlbum );

                    (void) attrs.Append( KMPXMediaMusicGenre );

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

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

                    CleanupStack::PopAndDestroy( &attrs );

                    }

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

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

// Handle playback property.

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

//

void CMPXMetaDataHandlerImp::DoHandlePropertyL(

    TMPXPlaybackProperty aProperty,

    TInt aValue,

    TInt aError )

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::DoHandlePropertyL" );

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

    TInt attr = 0;

    TInt val = KAvrcpOff;

    if ( KErrNone == aError )

        {

        switch ( aProperty )

            {

            case EPbPropertyPosition:

                {

                iPlaybackPosition = aValue / KMPXOneSecInMilliSecs;

                    // AVRCP 1.3 - inform remote device of the new position 

                    // ( Todo: check that we don't call too often)

                iPlayerEventsObserver->SetPlaybackPosition(aValue); // aPlaybackPosInMicroSeconds is converted to 32 bit value

                break;

                }

            case EPbPropertyRepeatMode:

                {

                attr = KAvrcpRepeatMode; // Repeat mode status

                    // TMPlayerRepeatMode values are in the same order as AVRCP 1.3, 

                    // but starting at 0 instead of 1.

                val = (TInt) aValue + 1;

                break;

                }

            case EPbPropertyRandomMode:

                {

                attr = KAvrcpShuffleMode;    // Shuffle on/off status

                TBool random = aValue;

                if( random )

                    {

                    val = KAvrcpAllTracksShuffle;

                    }

                break;

              }

            default:

                {

                break;

                }

            }

        if( attr )

            {

            iPlayerApplicationSettingsObserver->SetAttributeL( attr, val );

            }

        }

    }

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

// Handle media properties.

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

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

//

void CMPXMetaDataHandlerImp::DoHandleMediaL(

    const CMPXMedia& aMedia, TInt aError )

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::DoHandleMediaL" );

    // Delete old title no matter there's error or not

    delete iTrackTitle;

    iTrackTitle = NULL;

    delete iArtist;

    iArtist = NULL;

    delete iAlbum;

    iAlbum = NULL;

    delete iGenre;

    iGenre = NULL;

    TInt lastTrackNumber = -1;

    if ( KErrNone == aError )

        {

        // Keep track of the current track's title

        iTrackTitle = aMedia.ValueText( KMPXMediaGeneralTitle ).AllocL();

        TInt *playingTime = aMedia.Value<TInt>( KMPXMediaGeneralDuration );

        if(playingTime)

            {

            iPlayingTime = *playingTime; // In milliseconds.

            }

        MMPXSource* s = iPlaybackUtility->Source();

        if ( s )

            {

            CMPXCollectionPlaylist* pl = s->PlaylistL();

            if( pl )

                {

                lastTrackNumber = pl->Path().Index() + 1; // What if PlaylistItemCount is zero?

                delete pl;

                }

            }

        iArtist = aMedia.ValueText( KMPXMediaMusicArtist ).AllocL();

        iAlbum = aMedia.ValueText( KMPXMediaMusicAlbum ).AllocL();

        iGenre = aMedia.ValueText( KMPXMediaMusicGenre ).AllocL();

        TUid colId = aMedia.ValueTObjectL<TUid>(KMPXMediaGeneralId);

        MPX_DEBUG2( "CMPXMetaDataHandlerImp::DoHandleMediaL - Track title(%S)", iTrackTitle);

        MPX_DEBUG4( "CMPXMetaDataHandlerImp::DoHandleMediaL - Artist(%S); Album(%S); Genre(%S)", iArtist, iAlbum, iGenre );

        MPX_DEBUG4( "CMPXMetaDataHandlerImp::DoHandleMediaL - Playing time(%d); Track number(%d); UID(%d)", iPlayingTime, lastTrackNumber, colId.iUid);

        if ( colId.iUid != iColId.iUid || lastTrackNumber != iTrackNumber )

            {

            iColId = colId;

            iTrackNumber = lastTrackNumber;

            iPlayerEventsObserver->TrackChanged(iColId.iUid, iPlayingTime);

            if ( iMetadataIter )

                {

                SendCurrentlyPlayingMetadata( *iMetadataIter );

                delete iMetadataIter;

                iMetadataIter = NULL;

                }

            }

        else

            {

            MPX_DEBUG1( "CMPXMetaDataHandlerImp::DoHandleMediaL DUPLICATE Trace Change Received" );

            }

        }

    }

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

// Handle playback state changed.

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

//

void CMPXMetaDataHandlerImp::DoHandleStateChangedL(

    TMPXPlaybackState aState )

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::DoHandleStateChangedL" );

    switch ( aState )

        {

        case EPbStateStopped:

            {

            iPlayerState = aState;

            iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::EStopped);

            break;

            }

        case EPbStatePlaying:

            iPlayerState = aState;

            // Start the time if needed, otherwise, update content if visible

            iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::EPlaying);

            break;

        case EPbStatePaused:

            {

            iPlayerState = aState;

            // Start the time if needed, otherwise, update content if visible

            iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::EPaused);

            break;

            }

        case EPbStateSeekingForward:

            {

            iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::EFwdSeek);

            break;

            }

        case EPbStateSeekingBackward:

            {

            iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::ERevSeek);

            break;

            }

        default:

            {

            // do nothing

            break;

            }

        }

    }

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

// From MMPXPlaybackObserver

// Handle playback message.

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

//

void CMPXMetaDataHandlerImp::HandlePlaybackMessage(

    CMPXMessage* aMessage, TInt aError )

    {

    if ( aError == KErrNone && aMessage )

        {

        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );

        }

    }

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

// From MMPXPlaybackCallback

// Handle playback property.

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

//

void CMPXMetaDataHandlerImp::HandlePropertyL(

    TMPXPlaybackProperty aProperty,

    TInt aValue,

    TInt aError )

    {

    TRAP_IGNORE( DoHandlePropertyL( aProperty, aValue, aError ) );

    }

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

// From MMPXPlaybackCallback

// Handle sub player names.

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

//

void CMPXMetaDataHandlerImp::HandleSubPlayerNamesL(

    TUid /* aPlayer */,

    const MDesCArray* /* aSubPlayers */,

    TBool /* aComplete */,

    TInt /* aError */ )

    {

    MPX_FUNC( "CMPXMediaKeyHandlerImp::HandleSubPlayerNamesL" );

    }

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

// From MMPXPlaybackCallback

// Handle media properties.

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

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

//

void CMPXMetaDataHandlerImp::HandleMediaL(

    const CMPXMedia& aMedia, TInt aError )

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::HandleMediaL" );

    TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );

    }

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

// From MMPXCollectionPlaylistObserver

// Handle collection playlist change.

// Notes: aError values:

// KErrNotFound - Playlist is updated, current item removed

// KErrNone - Playlist is updated, current item is valid

// KErrEof - Playlist is updated, current item removed and reached to the end of playlist

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

//

void CMPXMetaDataHandlerImp::HandleCollectionPlaylistChange(TInt aError)

    {

    MPX_FUNC( "CMPXMetaDataHandlerImp::HandleCollectionPlaylistChange" );

    if( aError )

        {

            // Update the media item.

        MMPXSource* s = iPlaybackUtility->Source();

        if ( s )

            {

            RArray<TMPXAttribute> attrs;

                // Failing the next operations here is not fatal.

            (void) attrs.Append( KMPXMediaGeneralTitle );

            (void) attrs.Append( KMPXMediaGeneralDuration );

            (void) attrs.Append( KMPXMediaGeneralId );

            (void) attrs.Append( KMPXMediaMusicArtist );

            (void) attrs.Append( KMPXMediaMusicAlbum );

            (void) attrs.Append( KMPXMediaMusicGenre );

                // Ignore the leave. If this occurs, we just don't get 

                // an updated media information for time being.

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

            attrs.Close();

            }

        }

    }

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

// From MPlayerApplicationSettingsNotify

// This is called when the controller has changed a setting

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

//

void CMPXMetaDataHandlerImp::MpasnSetPlayerApplicationValueL(

    const RArray<TInt>& aAttributeID, const RArray<TInt>& aAttributeValue )

    {