photosgallery/viewframework/medialists/src/glxcachemanager.cpp
branchRCL_3
changeset 30 a60acebbbd9d
parent 25 191387a8b767
child 32 78ad99c24f08
equal deleted inserted replaced
25:191387a8b767 30:a60acebbbd9d
   800                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralTitle )
   800                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralTitle )
   801                                 {
   801                                 {
   802                                 TParsePtrC parser(fileName);
   802                                 TParsePtrC parser(fileName);
   803                                 iMPXMedia->SetTextValueL(KMPXMediaGeneralTitle, parser.Name());
   803                                 iMPXMedia->SetTextValueL(KMPXMediaGeneralTitle, parser.Name());
   804                                 }
   804                                 }
   805                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralDate )
   805                             else if ((iRequestedAttrs[i] == KGlxMediaGeneralLastModifiedDate)
   806                                 {
   806                                     || (iRequestedAttrs[i] == KMPXMediaGeneralDate))
       
   807                                 {
       
   808                                 // Image viewer use case, no need of genaral date, 
       
   809                                 // but, the same is added for attribute completion purpose.
       
   810                                 TMPXAttribute attrib = iRequestedAttrs[i];
   807                                 TTime time;
   811                                 TTime time;
   808                                 time.HomeTime();
   812                                 time.HomeTime();
   809                                 iMPXMedia->SetTObjectValueL(KMPXMediaGeneralDate, time.Int64());
   813                                 if (errInImage == KErrNone)
   810                                 }
       
   811                             else if ( iRequestedAttrs[i] == KGlxMediaGeneralLastModifiedDate )
       
   812                                 {
       
   813                                 if(errInImage == KErrNone)
       
   814                                     {
   814                                     {
   815                                     RFs fs;
   815                                     RFs fs;
   816                                     CleanupClosePushL(fs);
   816                                     CleanupClosePushL(fs);
   817                                     TInt err = fs.Connect();   
   817                                     TInt err = fs.Connect();
   818                                     if(err == KErrNone)
   818                                     if (err == KErrNone)
   819                                         {                                    
   819                                         {
   820                                         TEntry entry;   
   820                                         TEntry entry;
   821                                         fs.Entry(fileName,entry);    
   821                                         fs.Entry(fileName, entry);
   822                                         TTime time = entry.iModified;   
   822                                         time = entry.iModified;
   823                                         iMPXMedia->SetTObjectValueL(
       
   824                                                 KGlxMediaGeneralLastModifiedDate, 
       
   825                                                 time.Int64());
       
   826                                         }
   823                                         }
   827                                     else
   824                                     CleanupStack::PopAndDestroy(&fs);
       
   825                                     }
       
   826                                 iMPXMedia->SetTObjectValueL(attrib,
       
   827                                         time.Int64());
       
   828                                 }
       
   829                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralSize )
       
   830                                 {
       
   831                                 TInt64 size = 0;
       
   832                                 TInt err = KErrNotFound;
       
   833                                 if (errInImage == KErrNone)
       
   834                                     {
       
   835                                     if (iImageViewerInstance->IsPrivate())
   828                                         {
   836                                         {
   829                                         TTime time;
   837                                         RFile64& imageHandle =
   830                                         time.HomeTime();
   838                                                 iImageViewerInstance->ImageFileHandle();
   831                                         iMPXMedia->SetTObjectValueL(
   839                                         if (imageHandle.SubSessionHandle()
   832                                                 KGlxMediaGeneralLastModifiedDate, 
   840                                                 != KNullHandle)
   833                                                 time.Int64());
       
   834                                         }
       
   835                                     CleanupStack::PopAndDestroy(&fs);                                    
       
   836                                     }
       
   837                                 else
       
   838                                     {
       
   839                                     TTime time;
       
   840                                     time.HomeTime();
       
   841                                     iMPXMedia->SetTObjectValueL(KGlxMediaGeneralLastModifiedDate, time.Int64());
       
   842                                     }
       
   843                                 }
       
   844                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralSize )
       
   845                                 {
       
   846                                 if(errInImage == KErrNone)
       
   847                                     {
       
   848                                     if(iImageViewerInstance->IsPrivate())
       
   849                                         {
       
   850                                         TInt64 sz = 0;
       
   851                                         TInt err = KErrNotFound;                                      
       
   852                                         RFile64& imageHandle = iImageViewerInstance->ImageFileHandle();
       
   853                                         if ( imageHandle.SubSessionHandle() != KNullHandle )
       
   854                                             {
   841                                             {
   855                                             err = imageHandle.Size(sz);
   842                                             err = imageHandle.Size(size);
   856                                             }
       
   857                                         if(err == KErrNone)
       
   858                                             {
       
   859                                             iMPXMedia->SetTObjectValueL(KMPXMediaGeneralSize, (TUint)sz);
       
   860                                             }
       
   861                                         else
       
   862                                             {
       
   863                                             iMPXMedia->SetTObjectValueL(KMPXMediaGeneralSize, 0);                                            
       
   864                                             }
   843                                             }
   865                                         }
   844                                         }
   866                                     else
   845                                     else
   867                                         {
   846                                         {
   868                                         RFs fs;
   847                                         RFs fs;
   869                                         CleanupClosePushL(fs);
   848                                         CleanupClosePushL(fs);
   870                                         TInt err = fs.Connect();   
   849                                         err = fs.Connect();
   871                                         if(err == KErrNone)
   850                                         if (err == KErrNone)
   872                                             {
   851                                             {
   873                                             TEntry entry;   
   852                                             TEntry entry;
   874                                             fs.Entry(fileName,entry);    
   853                                             fs.Entry(fileName, entry);
   875                                             TUint sz = entry.iSize;                                      
   854                                             size = (TUint) entry.iSize;
   876                                             iMPXMedia->SetTObjectValueL(KMPXMediaGeneralSize, sz);
       
   877                                             }
       
   878                                         else
       
   879                                             {
       
   880                                             iMPXMedia->SetTObjectValueL(KMPXMediaGeneralSize, 0);
       
   881                                             }
   855                                             }
   882                                         CleanupStack::PopAndDestroy(&fs);
   856                                         CleanupStack::PopAndDestroy(&fs);
   883                                         }
   857                                         }
       
   858 
       
   859                                     if (err != KErrNone)
       
   860                                         {
       
   861                                         size = 0;
       
   862                                         }
   884                                     }
   863                                     }
   885                                 // If any error while image is being decoded by image decorder, Need to set
   864                                 iMPXMedia->SetTObjectValueL(
   886                                 // default vaule for that image. Typical case is corrupted image.
   865                                         KMPXMediaGeneralSize, size);
   887                                 else
       
   888                                     {
       
   889                                     iMPXMedia->SetTObjectValueL(KMPXMediaGeneralSize, 0);
       
   890                                     }
       
   891                                 }
   866                                 }
   892                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralDrive )
   867                             else if ( iRequestedAttrs[i] == KMPXMediaGeneralDrive )
   893                                 {
   868                                 {
   894                                 TParsePtrC parser(fileName);
   869                                 TParsePtrC parser(fileName);
   895                                 iMPXMedia->SetTextValueL(KMPXMediaGeneralDrive, parser.Drive());
   870                                 iMPXMedia->SetTextValueL(KMPXMediaGeneralDrive, parser.Drive());