photosgallery/collectionframework/datasource/plugins/glxdatasourcemde2.5/src/glxdatasourcetaskmdsattribute.cpp
branchRCL_3
changeset 35 420f6808bf21
parent 25 191387a8b767
equal deleted inserted replaced
32:78ad99c24f08 35:420f6808bf21
    16 */
    16 */
    17 
    17 
    18 
    18 
    19 
    19 
    20 #include "glxdatasourcetaskmdsattribute.h"
    20 #include "glxdatasourcetaskmdsattribute.h"
    21 
       
    22 #include <glxcollectionplugincamera.hrh>
    21 #include <glxcollectionplugincamera.hrh>
    23 #include <glxcollectionplugindownloads.hrh>
       
    24 #include <glxcollectionpluginmonths.hrh>
       
    25 #include <glxcollectionpluginalbums.hrh>
    22 #include <glxcollectionpluginalbums.hrh>
    26 #include <glxcollectionpluginall.hrh>
    23 #include <glxcollectionpluginall.hrh>
    27 #include <glxcollectionplugintags.hrh>
    24 #include <glxcollectionplugintags.hrh>
    28 #include <glxerrors.h>
    25 #include <glxerrors.h>
    29 #include <glxfilterfactory.h>
    26 #include <glxfilterfactory.h>
   154             case EGlxFilterTag:
   151             case EGlxFilterTag:
   155                 {
   152                 {
   156                 QueueTagObjectQueryL(request->MediaIds());
   153                 QueueTagObjectQueryL(request->MediaIds());
   157                 break;
   154                 break;
   158                 }
   155                 }
   159             case EGlxFilterMonth:
   156             }
   160                 {
       
   161                 QueueMonthObjectQueryL(request->MediaIds());
       
   162                 break;
       
   163                 }
       
   164             }
       
   165         
       
   166     	}
   157     	}
   167 
   158 
   168     DoNextQueryL();
   159     DoNextQueryL();
   169     }
   160     }
   170 
   161 
   383                     {
   374                     {
   384                     isContent = EFalse;
   375                     isContent = EFalse;
   385                     objectDef = &DataSource()->TagDef();
   376                     objectDef = &DataSource()->TagDef();
   386                     break;
   377                     break;
   387                     }
   378                     }
   388                 case KGlxCollectionPluginMonthsImplementationUid:
       
   389                     {
       
   390 					filterProperties.iOrigin = EGlxFilterOriginAll;
       
   391                     break;
       
   392                     }
       
   393                 default:
   379                 default:
   394                     {
   380                     {
   395                     // default gallery query returns all objects as per filter
   381                     // default gallery query returns all objects as per filter
   396                     break;
   382                     break;
   397                     }
   383                     }
   488                 aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAlbum);
   474                 aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAlbum);
   489                 }
   475                 }
   490             else if( CGlxDataSource::EContainerTypeTag == aType)
   476             else if( CGlxDataSource::EContainerTypeTag == aType)
   491                 {
   477                 {
   492                 aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXTag);
   478                 aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXTag);
   493                 }
       
   494             else if( CGlxDataSource::EContainerTypeMonth == aType)
       
   495                 {
       
   496                 aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXMonth);
       
   497                 }
   479                 }
   498             else
   480             else
   499                 {
   481                 {
   500                 User::Leave(KErrNotSupported);
   482                 User::Leave(KErrNotSupported);
   501                 }
   483                 }
   543                     }
   525                     }
   544                 case CGlxDataSource::EContainerTypeTag:
   526                 case CGlxDataSource::EContainerTypeTag:
   545                     {
   527                     {
   546                     break;
   528                     break;
   547                     }
   529                     }
   548                 case CGlxDataSource::EContainerTypeMonth:
   530                 default:
   549                     {
       
   550                     request->AppendCpiAttributeL(KMPXMediaGeneralTitle);
       
   551                     CMdEProperty* time;
       
   552                     CMdEPropertyDef& timeProperty = aContainer->Def().GetPropertyDefL(
       
   553                             KPropertyDefNameCreationDate);
       
   554                     TInt timeIndex = aContainer->Property(timeProperty, time);
       
   555                     if( KErrNotFound == timeIndex )
       
   556                         {
       
   557                         User::Leave(KErrCorrupt);
       
   558                         }
       
   559 
       
   560                     aEntry->SetTObjectValueL(KGlxMediaCollectionInternalStartDate, 
       
   561                             static_cast<CMdETimeProperty*>(time)->Value());
       
   562                     break;
   531                     break;
   563                     }
       
   564                 }
   532                 }
   565             }
   533             }
   566         else if ( request->Attributes()[i] == KMPXMediaGeneralDate )
   534         else if ( request->Attributes()[i] == KMPXMediaGeneralDate )
   567             {
   535             {
   568             CMdEProperty* time;
   536             CMdEProperty* time;
   623                 case CGlxDataSource::EContainerTypeAlbum:
   591                 case CGlxDataSource::EContainerTypeAlbum:
   624                 case CGlxDataSource::EContainerTypeTag:
   592                 case CGlxDataSource::EContainerTypeTag:
   625                     {                                                           
   593                     {                                                           
   626                     TUint32 countTypeIndex = aContainer->UsageCount();
   594                     TUint32 countTypeIndex = aContainer->UsageCount();
   627                     aEntry->SetTObjectValueL(request->Attributes()[i], countTypeIndex);
   595                     aEntry->SetTObjectValueL(request->Attributes()[i], countTypeIndex);
   628                     break;
       
   629                     }
       
   630                 case CGlxDataSource::EContainerTypeMonth:
       
   631                     {
       
   632                     iFilterProperties.iOrigin = EGlxFilterOriginAll;                    
       
   633                     TGlxFilterProperties filterProperties = iFilterProperties;
       
   634                     AddMonthFilterL(aContainer, filterProperties);
       
   635                     QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery,
       
   636                             EQueryResultModeCount, TGlxMediaId(KGlxCollectionRootId),
       
   637                             request->Attributes()[i], aEntry, filterProperties);
       
   638                     break;
   596                     break;
   639                     }
   597                     }
   640                 }
   598                 }
   641             }
   599             }
   642         else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem )
   600         else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem )
   666                 case CGlxDataSource::EContainerTypeTag:
   624                 case CGlxDataSource::EContainerTypeTag:
   667                     {
   625                     {
   668                     systemItem = EFalse;
   626                     systemItem = EFalse;
   669                     break;
   627                     break;
   670                     }
   628                     }
   671                 case CGlxDataSource::EContainerTypeMonth:
       
   672                     {
       
   673                     systemItem = ETrue;
       
   674                     break;
       
   675                     }
       
   676                 }
   629                 }
   677             aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, systemItem);
   630             aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, systemItem);
   678             }
   631             }
   679             
       
   680          //Attributes to get the Count of Images in Container                
       
   681         else if	( request->Attributes()[i] == KGlxMediaItemTypeImage )    
       
   682 			{
       
   683 			switch (aType)
       
   684 				{
       
   685 				case CGlxDataSource::EContainerTypeMonth:
       
   686 					{
       
   687 					TGlxFilterProperties filterProperties = iFilterProperties;
       
   688 					AddMonthFilterL(aContainer, filterProperties);
       
   689 					filterProperties.iItemType = EGlxFilterImage;
       
   690 #if 0 	/// AB camera album					
       
   691 					QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery,
       
   692 					        EQueryResultModeCount, DataSource()->CameraAlbumId(), 
       
   693 					        request->Attributes()[i], aEntry, filterProperties);
       
   694 #endif					
       
   695 					break;
       
   696 					}			             					
       
   697 				default:
       
   698 					{
       
   699 					break;	
       
   700 					}
       
   701 				}
       
   702 			}           	
       
   703 		// Attributes to get the Count of Videos in Container 		
       
   704 						                   	
       
   705          else if ( request->Attributes()[i] == KGlxMediaItemTypeVideo )    
       
   706 			{
       
   707 			switch (aType)
       
   708 				{
       
   709 				case CGlxDataSource::EContainerTypeMonth:
       
   710 					{
       
   711 					TGlxFilterProperties filterProperties = iFilterProperties;
       
   712 					AddMonthFilterL(aContainer, filterProperties);
       
   713 					filterProperties.iItemType = EGlxFilterVideo;
       
   714 #if 0 	/// AB camera album					
       
   715 					QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery,
       
   716 					        EQueryResultModeCount, DataSource()->CameraAlbumId(),
       
   717 					        request->Attributes()[i], aEntry, filterProperties);
       
   718 #endif					
       
   719 					break;
       
   720 					}
       
   721 				default:
       
   722 					{
       
   723 					break;	
       
   724 					}
       
   725 				}
       
   726 			}
       
   727 			
       
   728         else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )
   632         else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )
   729             {
   633             {
   730             aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, 
   634             aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, 
   731                     KGlxDataSourceMdeImplementationUid);
   635                     KGlxDataSourceMdeImplementationUid);
   732             }
   636             }
   763                 case CGlxDataSource::EContainerTypeAlbum:
   667                 case CGlxDataSource::EContainerTypeAlbum:
   764                 case CGlxDataSource::EContainerTypeTag:
   668                 case CGlxDataSource::EContainerTypeTag:
   765                     {
   669                     {
   766                     QueueObjectQueryL(aContainer->Def(), ETrue, EAttributeQuery,
   670                     QueueObjectQueryL(aContainer->Def(), ETrue, EAttributeQuery,
   767                             EQueryResultModeCount, TGlxMediaId(aContainer->Id()),
   671                             EQueryResultModeCount, TGlxMediaId(aContainer->Id()),
   768                             request->Attributes()[i], aEntry, filterProperties);
       
   769                     break;
       
   770                     }
       
   771                 case CGlxDataSource::EContainerTypeMonth:
       
   772                     {
       
   773                     filterProperties.iOrigin = EGlxFilterOriginAll;               
       
   774                     AddMonthFilterL(aContainer, filterProperties);
       
   775                     QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery,
       
   776                             EQueryResultModeCount, TGlxMediaId(KGlxCollectionRootId),
       
   777                             request->Attributes()[i], aEntry, filterProperties);
   672                             request->Attributes()[i], aEntry, filterProperties);
   778                     break;
   673                     break;
   779                     }
   674                     }
   780                 }
   675                 }
   781             }
   676             }