mpxmusicplayer/commonui/src/mpxalbumartutil.cpp
changeset 0 ff3acec5bc43
child 2 b70d77332e66
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     1 /*
       
     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  MPX album utility API
       
    15 *
       
    16 */
       
    17 
       
    18 #include <e32std.h>
       
    19 #include <MetaDataUtility.h>
       
    20 #include <MetaDataFieldContainer.h>
       
    21 #include <mpxuser.h>
       
    22 #include <mpxmedia.h>
       
    23 #include <mpxmediamusicdefs.h>
       
    24 #include <mpxmediageneraldefs.h>
       
    25 #include <mpxlog.h>
       
    26 
       
    27 #include "mpxalbumartutilobserver.h"
       
    28 #include "mpximageutil.h"
       
    29 #include "mpxalbumartutil.h"
       
    30 #include <thumbnaildata.h>
       
    31 #include <thumbnailobjectsource.h>
       
    32 #include <centralrepository.h>
       
    33 
       
    34 #define THUMBNAIL_CENREP_UID 0x102830B0
       
    35 
       
    36 const TUint32 KSizeAudioGridWidth = 0x12;
       
    37 const TUint32 KSizeAudioGridHeight = 0x13;
       
    38 const TUint32 KSizeAudioFullscreenWidth = 0x16;
       
    39 const TUint32 KSizeAudioFullscreenHeight = 0x17;
       
    40 
       
    41 
       
    42 _LIT( KMPXAlbumMimeType, "audio/mpeg3" );
       
    43 // ============================== MEMBER FUNCTIONS ============================
       
    44 
       
    45 // ----------------------------------------------------------------------------
       
    46 // Create the playback utility object
       
    47 // ----------------------------------------------------------------------------
       
    48 //
       
    49 EXPORT_C CMPXAlbumArtUtil* CMPXAlbumArtUtil::NewL()
       
    50     {
       
    51     CMPXAlbumArtUtil* self = new(ELeave)CMPXAlbumArtUtil();
       
    52     CleanupStack::PushL(self);
       
    53     self->ConstructL();
       
    54     CleanupStack::Pop(self);
       
    55     return self;
       
    56     }
       
    57 
       
    58 
       
    59 // ----------------------------------------------------------------------------
       
    60 // Destructor
       
    61 // ----------------------------------------------------------------------------
       
    62 //
       
    63 EXPORT_C CMPXAlbumArtUtil::~CMPXAlbumArtUtil()
       
    64     {
       
    65     if (iArtUtil)
       
    66         {
       
    67         delete iArtUtil;
       
    68         }
       
    69     if(iFilename)
       
    70         {   
       
    71         delete iFilename;
       
    72         iFilename = NULL;
       
    73         }
       
    74     delete iThumbnailManager;
       
    75     }
       
    76 
       
    77 
       
    78 // ----------------------------------------------------------------------------
       
    79 // Constructor
       
    80 // ----------------------------------------------------------------------------
       
    81 //
       
    82 CMPXAlbumArtUtil::CMPXAlbumArtUtil()
       
    83     {
       
    84     }
       
    85 
       
    86 // ----------------------------------------------------------------------------
       
    87 // Constructor
       
    88 // ----------------------------------------------------------------------------
       
    89 //
       
    90 void CMPXAlbumArtUtil::ConstructL()
       
    91     {
       
    92      MPX_FUNC("CMPXAlbumArtUtil::ConstructL()");
       
    93      iThumbnailManager = CThumbnailManager::NewL( *this );
       
    94      iThumbnailManager->SetFlagsL( CThumbnailManager::EDefaultFlags );
       
    95      iThumbnailManager->SetQualityPreferenceL( CThumbnailManager::EOptimizeForPerformance );
       
    96 	 //cenrep
       
    97      CRepository* repository;
       
    98      repository = CRepository::NewL( TUid::Uid(THUMBNAIL_CENREP_UID));
       
    99 
       
   100      TInt xSize( 0 );
       
   101      TInt ySize( 0 );
       
   102      User::LeaveIfError( repository->Get( KSizeAudioGridWidth, xSize ));
       
   103      User::LeaveIfError( repository->Get( KSizeAudioGridHeight, ySize ));
       
   104      iGridViewImageSize.SetSize(xSize,ySize);
       
   105 
       
   106      User::LeaveIfError( repository->Get( KSizeAudioFullscreenWidth, xSize ));
       
   107      User::LeaveIfError( repository->Get( KSizeAudioFullscreenHeight, ySize ));
       
   108      iFullScreenImageSize.SetSize(xSize,ySize);
       
   109      delete repository;
       
   110      repository = NULL;
       
   111     }
       
   112 
       
   113 // ----------------------------------------------------------------------------
       
   114 // Create the playback utility object
       
   115 // ----------------------------------------------------------------------------
       
   116 //
       
   117 EXPORT_C void CMPXAlbumArtUtil::ExtractAlbumArtL(const CMPXMedia& aMedia,
       
   118                                             MMPXAlbumArtUtilObserver& aObs,
       
   119                                             const TSize& aSize,
       
   120                                             TDisplayMode aDisplayMode /*= EColor64K*/)
       
   121     {
       
   122     MPX_DEBUG1("CMPXAlbumArtUtil::ExtractAlbumArtL(): Entering");
       
   123     MPX_DEBUG_THREAD("CMPXAlbumArtUtil::ExtractAlbumArtL()");
       
   124     delete iArtUtil;
       
   125     iArtUtil = NULL;
       
   126     iArtUtil = CMPXImageUtil::NewL(aObs);
       
   127     iDisplayMode = aDisplayMode;
       
   128     iImageSize = aSize;
       
   129     iObserver = &aObs;
       
   130     
       
   131     if (aMedia.IsSupported( KMPXMediaMusicAlbumArtFileName ))
       
   132         {
       
   133         if ( aMedia.ValueText( KMPXMediaMusicAlbumArtFileName ).Length() == 0)
       
   134             {
       
   135             User::Leave( KErrNotFound );
       
   136             }
       
   137         }
       
   138 
       
   139     if ( aMedia.IsSupported( KMPXMediaGeneralUri ) &&
       
   140          aMedia.IsSupported( KMPXMediaMusicAlbumArtFileName ))
       
   141         {
       
   142         delete iFilename;
       
   143         iFilename = NULL;
       
   144         iFilename = aMedia.ValueText( KMPXMediaMusicAlbumArtFileName ).AllocL();
       
   145         if(aSize == iFullScreenImageSize)
       
   146             {
       
   147             iThumbnailManager->SetThumbnailSizeL(EAudioFullScreenThumbnailSize);
       
   148             }
       
   149         else if(aSize == iGridViewImageSize)
       
   150             { 
       
   151             iThumbnailManager->SetThumbnailSizeL(EAudioGridThumbnailSize);
       
   152             } 
       
   153         else
       
   154             {
       
   155             iThumbnailManager->SetThumbnailSizeL(aSize);
       
   156             }
       
   157         ExtractThumbnailL(&aMedia);
       
   158         }
       
   159     else
       
   160         {
       
   161         User::Leave( KErrNotFound );
       
   162         }
       
   163     MPX_DEBUG1("CMPXAlbumArtUtil::ExtractAlbumArtL(): Exiting");
       
   164     }
       
   165 
       
   166 // -----------------------------------------------------------------------------
       
   167 // Cancel Asynch requests
       
   168 // -----------------------------------------------------------------------------
       
   169 //
       
   170 EXPORT_C void CMPXAlbumArtUtil::CancelRequest()
       
   171     {
       
   172     MPX_DEBUG1("CMPXAlbumArtUtil::CancelRequest(): Entering");
       
   173     if ( iArtUtil )
       
   174         {
       
   175         iArtUtil->CancelRequest();
       
   176         }
       
   177     iReqId = 0;
       
   178     MPX_DEBUG1("CMPXAlbumArtUtil::CancelRequest(): Exiting");
       
   179     }
       
   180 
       
   181 // ----------------------------------------------------------------------------
       
   182 // Extract binary data from file
       
   183 // ----------------------------------------------------------------------------
       
   184 //
       
   185 HBufC8* CMPXAlbumArtUtil::ExtractBinaryMetaDataLC(const TDesC& aFilename,
       
   186                                              TMetaDataFieldId aFieldId)
       
   187     {
       
   188     MPX_DEBUG1("CMPXAlbumArtUtil::ExtractBinaryMetaDataLC(): Entering");
       
   189     HBufC8* ret(NULL);
       
   190 
       
   191     if (EUnknownMetaDataField != aFieldId)
       
   192         {
       
   193         CMetaDataUtility* metaDataUtil = CMetaDataUtility::NewL();
       
   194         CleanupStack::PushL( metaDataUtil );
       
   195 
       
   196         RArray<TMetaDataFieldId> wantedFields;
       
   197         CleanupClosePushL(wantedFields);
       
   198         wantedFields.AppendL(aFieldId);
       
   199 
       
   200         metaDataUtil->OpenFileL(aFilename, wantedFields);
       
   201         const CMetaDataFieldContainer& metaCont =
       
   202                                         metaDataUtil->MetaDataFieldsL();
       
   203         TPtrC data = metaCont.Field( aFieldId );
       
   204         if(data.Length()==0)
       
   205             {
       
   206             iObserver->ExtractAlbumArtCompleted( NULL, KErrNotFound );            
       
   207             }
       
   208         ret = MPXUser::Alloc8L(data);
       
   209 
       
   210         CleanupStack::PopAndDestroy(&wantedFields);
       
   211         CleanupStack::PopAndDestroy(metaDataUtil);
       
   212         CleanupStack::PushL( ret );
       
   213         }
       
   214     else
       
   215         {
       
   216         ret = HBufC8::NewLC(0);
       
   217         }
       
   218 
       
   219     MPX_DEBUG1("CMPXAlbumArtUtil::ExtractBinaryMetaDataLC(): Exiting");
       
   220     return ret;
       
   221     }
       
   222 		
       
   223 // -----------------------------------------------------------------------------
       
   224 // Preview thumbnail generation or loading is complete.
       
   225 // -----------------------------------------------------------------------------
       
   226 //
       
   227 void CMPXAlbumArtUtil::ThumbnailPreviewReady(
       
   228     MThumbnailData& /*aThumbnail*/,
       
   229     TThumbnailRequestId /*aId*/ )
       
   230     {
       
   231     MPX_FUNC( "CMPXAlbumArtUtil::ThumbnailPreviewReady" );
       
   232     // Not used
       
   233     }
       
   234 
       
   235 
       
   236 // -----------------------------------------------------------------------------
       
   237 // Final thumbnail bitmap generation or loading is complete. 
       
   238 // -----------------------------------------------------------------------------
       
   239 //
       
   240 void CMPXAlbumArtUtil::ThumbnailReady(
       
   241         TInt aError, MThumbnailData& aThumbnail,
       
   242         TThumbnailRequestId aId )
       
   243     {
       
   244     MPX_DEBUG2( "CMPXAlbumArtUtil::ThumbnailReady error = %d", aError);
       
   245 
       
   246     if (aError == KErrNone)
       
   247         { 
       
   248         CFbsBitmap* tempBitmap;
       
   249         tempBitmap = aThumbnail.DetachBitmap();                
       
   250         if (tempBitmap)
       
   251             {
       
   252             if(iReqId == aId)
       
   253                 {
       
   254                 iObserver->ExtractAlbumArtCompleted( tempBitmap, KErrNone ); 
       
   255                 }
       
   256             else
       
   257                 {
       
   258                 delete tempBitmap;
       
   259                 } 
       
   260             }
       
   261         else
       
   262             {
       
   263             iObserver->ExtractAlbumArtCompleted( NULL, KErrNotFound );
       
   264             }
       
   265         } 	
       
   266     else
       
   267         {
       
   268         TRAPD( err,
       
   269             HBufC8* art( ExtractBinaryMetaDataLC(iFilename->Des(),EMetaDataJpeg ));
       
   270             CleanupStack::Pop(art);
       
   271             iArtUtil->StartToDecodeL(iImageSize, art, iDisplayMode) );
       
   272         
       
   273         if (err != KErrNone)
       
   274             {
       
   275             iObserver->ExtractAlbumArtCompleted( NULL, KErrNotFound );
       
   276             }  
       
   277         } 
       
   278 
       
   279     }
       
   280 
       
   281 // -----------------------------------------------------------------------------
       
   282 //     Extract Thumbnail for the current song
       
   283 // -----------------------------------------------------------------------------
       
   284 //    	
       
   285 void CMPXAlbumArtUtil::ExtractThumbnailL(
       
   286         const CMPXMedia* aMedia)
       
   287     {
       
   288     MPX_FUNC("CMPXAlbumArtUtil::ExtractThumbnailL");
       
   289     
       
   290     TMPXItemId currentId( aMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
       
   291     if (currentId == KMPXInvalidItemId )
       
   292         {
       
   293         User::Leave( KErrNotFound );
       
   294         }
       
   295     if (aMedia->IsSupported( KMPXMediaMusicAlbumArtFileName ) )
       
   296         {
       
   297         const TDesC& album = aMedia->ValueText( KMPXMediaMusicAlbumArtFileName );
       
   298 #ifdef _DEBUG
       
   299         RDebug::RawPrint(album);
       
   300 #endif
       
   301         if (album.Compare( KNullDesC) != 0 )
       
   302             {
       
   303             CThumbnailObjectSource* source = CThumbnailObjectSource::NewLC( album, KMPXAlbumMimeType );
       
   304             TInt ret = NULL;
       
   305             TRAPD(err, iReqId = TInt (iThumbnailManager->GetThumbnailL( *source, (TAny*)ret)));
       
   306             if( err != KErrNone)
       
   307                 {
       
   308                 User::Leave( KErrNotFound );
       
   309                 }  
       
   310             CleanupStack::PopAndDestroy( source );
       
   311             }
       
   312         }
       
   313     }
       
   314