/*

* Copyright (c) 2007 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 specific memory plugin

*

*/

#include <e32base.h>

#include <f32file.h>

#include <badesca.h>

#include <apgcli.h>

#include <mpxcollectiontype.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediaarray.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxdrmmediautility.h>

#include <mpxmetadataextractor.h>

#include "mpxmusicmemoryplugin.h"

// CONSTANTS

const TInt KIMMusicPluginUid  = 0x10282960;

const TMPXAttributeData KMPXMediaFetched = {KIMMusicPluginUid, 0x01}; // TInt

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

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

// Default Constructor

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

//

CMPXMusicMemoryPlugin::CMPXMusicMemoryPlugin()

    {

    }

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

// 2nd phased constructor

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

//

void CMPXMusicMemoryPlugin::ConstructL()

    {

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

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

    RPointerArray<CMPXCollectionType> dummy;

    CleanupClosePushL( dummy );

    iMetadataExtractor = CMPXMetadataExtractor::NewL( iFs, iAppArc, dummy );

    dummy.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &dummy );

    iAttributes.AppendL(KMPXMediaDrmAll);

    // Base class construction

    CMPXInMemoryPlugin::ConstructL();

    }

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

// Two-phased constructor

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

//

CMPXMusicMemoryPlugin* CMPXMusicMemoryPlugin::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Virtual destructor

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

//

CMPXMusicMemoryPlugin::~CMPXMusicMemoryPlugin()

    {

    iFs.Close();

    iAppArc.Close();

    delete iMetadataExtractor;

    iAttributes.Close();

    }

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

// Extended properties of the current file (async)

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

//

void CMPXMusicMemoryPlugin::MediaL (

    const CMPXCollectionPath& aPath, 

    const TArray<TMPXAttribute>& aAttrs,

    const TArray<TCapability>& /*aCaps*/,

    CMPXAttributeSpecs* /*aSpecs*/)

    {

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    supportedIds.AppendL(KMPXMediaIdGeneral);

    CMPXMedia* entries=CMPXMedia::NewL(supportedIds.Array());

    CleanupStack::PopAndDestroy(&supportedIds);

    CleanupStack::PushL(entries);

    // Based on Path, what is the embedded client context id?

    //

    TInt err = KErrNone;

    TInt depth = aPath.Levels();

    switch( depth )

        {

        case 2:  // Playlist / Song level

        case 3:  // Song in a playlist level, fall through

            {

            TInt context = aPath.Id(1);

            TInt contextIndex = iEmbeddedContext.Find( context );

            if( contextIndex >= KErrNone )

                {

                CMPXMedia& media = *iTemporaryData[contextIndex];

                TMPXGeneralCategory cat;

                cat = *media.Value<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

                // Playlist media

                //

                if( cat == EMPXPlaylist && depth == 2)

                    {

                    // Get

                    const TDesC& title = media.ValueText( KMPXMediaGeneralTitle );

                    const TDesC& uri = media.ValueText( KMPXMediaGeneralUri );

                    // Set

                    entries->SetTextValueL( KMPXMediaGeneralTitle, title );

                    entries->SetTextValueL( KMPXMediaGeneralUri, uri );

                    entries->SetTObjectValueL<TUid>(KMPXMediaGeneralCollectionId, 

                                                    TUid::Uid(KIMMusicPluginUid) );

                    }

                // Item in a playlist media

                //

                else if( cat == EMPXPlaylist && depth == 3 )

                    {

                    const CMPXMediaArray* plarray = media.Value<CMPXMediaArray>(KMPXMediaArrayContents);

                    TInt selection = aPath.Id(2);

                    TInt count = plarray->Count();

                    if( selection < count )

                        {

                        if( (*plarray)[selection]->IsSupported(KMPXMediaFetched) )

                            {

                            *entries = *(*plarray)[selection];

                            }

                        else  // not fetched yet

                            {

                            // Extract the data

                            const TDesC& uri = (*plarray)[selection]->ValueText( KMPXMediaGeneralUri );

                            CMPXMedia* metadata = ExtractMetadataL( uri, iAttributes.Array() );

                            CleanupStack::PushL( metadata );                                            

                            // Return to client

                            *entries = *metadata;

                            // Save the data

                            *(*plarray)[selection] = *metadata;         

                            (*plarray)[selection]->SetTObjectValueL(KMPXMediaFetched, ETrue);

                            CleanupStack::PopAndDestroy( metadata );

                            }

                        entries->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, 

                                                         TUid::Uid(KIMMusicPluginUid) );

                        }

                    else

                       {

                       // Bounds check

                       err = KErrArgument; 

                       }

                    }

                // Otherwise, assume it is a song

                //

                else // cat == song/image/video/etc

                    {

                    if( media.IsSupported(KMPXMediaFetched) )

                        {

                        *entries = media;    

                        }

                    else

                        {

                        const TDesC& uri = media.ValueText( KMPXMediaGeneralUri );

                        CMPXMedia* metadata = ExtractMetadataL( uri, iAttributes.Array() );

                        CleanupStack::PushL( metadata );

                        // Return to client

                        *entries = *metadata;

                        //Save the data

                        media = *metadata;

                        media.SetTObjectValueL(KMPXMediaFetched, ETrue);

                        CleanupStack::PopAndDestroy( metadata );    

                        }

                    entries->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, 

                                                     TUid::Uid(KIMMusicPluginUid) );

                    }

                }

            break;    

            }  

        default:

            {

            // Return Nothing because a MediaL at this depth contains nothing

            break;    

            }

        }

    // Copy Path

    TMPXAttribute pathAttr(KMPXMediaGeneralPath);

    for (TInt i=aAttrs.Count();--i>=0;)

        {

        if (aAttrs[i]==pathAttr)

            {

            entries->SetCObjectValueL(pathAttr,

                                         const_cast<CMPXCollectionPath*>(&aPath));

            break;

            }

        }

    // Callback to collection client context

    iObs->HandleMedia( entries, err );

    CleanupStack::PopAndDestroy(entries);

    }

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

// Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm

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

//

CMPXMedia* CMPXMusicMemoryPlugin::ExtractMetadataL( const TDesC& aUri, 

                                                    const TArray<TMPXAttribute>& aAttrs )

    {

    CMPXMedia* media( NULL );

    iMetadataExtractor->CreateMediaL( aUri, media, ETrue );

    // Also set drm 

    if( media )

        {

        CleanupStack::PushL( media );

        DoSetMediaDrmL( *media, aAttrs, aUri );

        CleanupStack::Pop( media );

        }

    return media;  // ownership transferred

    }

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

// Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm

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

//

void CMPXMusicMemoryPlugin::DoSetMediaDrmL(CMPXMedia& aMedia, 

                                           const TArray<TMPXAttribute>& aAttrs, 

                                           const TDesC& aLocation )

    {

    // Gather all DRM attributes

    TUint aDrmAttributes(0);

    for( TInt i=0; i<aAttrs.Count(); ++i )

        {

        if( aAttrs[i].ContentId() == KMPXMediaIdDrm )

            {

            aDrmAttributes |= aAttrs[i].AttributeId();

            }

        }

    iDrmMediaUtility->InitL(aLocation);

    const CMPXMedia* drmMedia( iDrmMediaUtility->GetMediaL( aDrmAttributes ));   

    // Only get attributes if it's a DRM file

    if ( drmMedia )

        {

        if ( aDrmAttributes & KMPXMediaDrmType.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmType );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt val( *drmMedia->Value<TInt>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmRightsStatus.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmRightsStatus );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt val( *drmMedia->Value<TInt>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmRightsType.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmRightsType );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt val( *drmMedia->Value<TInt>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmCount.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmCount );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt val( *drmMedia->Value<TInt>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmProtected.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmProtected );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmSendingAllowed.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmSendingAllowed );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmCanSetAutomated.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmCanSetAutomated );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmHasInfoUrl.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmHasInfoUrl );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmHasPreviewUrl.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmHasPreviewUrl );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmAboutToExpire.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmAboutToExpire );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TBool val( *drmMedia->Value<TBool>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmStartTime.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmStartTime );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt64 val( *drmMedia->Value<TInt64>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmEndTime.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmEndTime );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt64 val( *drmMedia->Value<TInt64>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmIntervalStartTime.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmIntervalStartTime );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt64 val( *drmMedia->Value<TInt64>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmAccumulatedTime.iAttributeId )

            {                        

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, 

                                  EMPXMediaDrmAccumulatedTime );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TInt64 val( *drmMedia->Value<TInt64>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        if ( aDrmAttributes & KMPXMediaDrmInterval.iAttributeId )

            {

            TMPXAttribute mpxAtt( KMPXMediaIdDrm, EMPXMediaDrmInterval );

            if ( drmMedia->IsSupported( mpxAtt ))

                {

                TTimeIntervalSeconds val(

                    *drmMedia->Value<TTimeIntervalSeconds>( mpxAtt ));

                aMedia.SetTObjectValueL( mpxAtt, val );

                }

            }

        }

    iDrmMediaUtility->Close();        

    }

// END OF FILE