mpxplugins/serviceplugins/collectionplugins/mpxinmemoryplugin/src/mpxmusicmemoryplugin.cpp
changeset 0 ff3acec5bc43
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpxplugins/serviceplugins/collectionplugins/mpxinmemoryplugin/src/mpxmusicmemoryplugin.cpp	Thu Dec 17 08:45:05 2009 +0200
@@ -0,0 +1,432 @@
+/*
+* 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