80 // |
78 // |
81 CGlxDataSourceTaskMde:: CGlxDataSourceTaskMde(CGlxRequest* aRequest, |
79 CGlxDataSourceTaskMde:: CGlxDataSourceTaskMde(CGlxRequest* aRequest, |
82 MGlxDataSourceRequestObserver& aObserver, CGlxDataSource* aDataSource) |
80 MGlxDataSourceRequestObserver& aObserver, CGlxDataSource* aDataSource) |
83 : CGlxDataSourceTask(aRequest, aObserver, aDataSource) |
81 : CGlxDataSourceTask(aRequest, aObserver, aDataSource) |
84 { |
82 { |
85 TRACER("CGlxDataSourceTaskMde::CGlxDataSourceTaskMde()") |
83 TRACER("CGlxDataSourceTaskMde::CGlxDataSourceTaskMde()"); |
86 // No implementation required |
84 // No implementation required |
87 } |
85 } |
88 |
86 |
89 // ---------------------------------------------------------------------------- |
87 // ---------------------------------------------------------------------------- |
90 // Destructor |
88 // Destructor |
91 // ---------------------------------------------------------------------------- |
89 // ---------------------------------------------------------------------------- |
92 // |
90 // |
93 CGlxDataSourceTaskMde::~CGlxDataSourceTaskMde() |
91 CGlxDataSourceTaskMde::~CGlxDataSourceTaskMde() |
94 { |
92 { |
95 TRACER("CGlxDataSourceTaskMde::~CGlxDataSourceTaskMde()") |
93 TRACER("CGlxDataSourceTaskMde::~CGlxDataSourceTaskMde()"); |
96 DestroyQueries(); |
94 DestroyQueries(); |
97 } |
95 } |
98 |
96 |
99 // ---------------------------------------------------------------------------- |
97 // ---------------------------------------------------------------------------- |
100 // Second stage constructor |
98 // Second stage constructor |
101 // ---------------------------------------------------------------------------- |
99 // ---------------------------------------------------------------------------- |
102 // |
100 // |
103 void CGlxDataSourceTaskMde::ConstructL() |
101 void CGlxDataSourceTaskMde::ConstructL() |
104 { |
102 { |
105 TRACER("CGlxDataSourceTaskMde::ConstructL()") |
103 TRACER("CGlxDataSourceTaskMde::ConstructL()"); |
106 CreateResponseL(); |
104 CreateResponseL(); |
107 #ifdef USE_S60_TNM |
105 #ifdef USE_S60_TNM |
108 DataSource()->CancelFetchThumbnail(); |
106 DataSource()->CancelFetchThumbnail(); |
109 #else |
107 #else |
110 DataSource()->ThumbnailCreator().CancelRequest( TGlxMediaId(0) ); |
108 DataSource()->ThumbnailCreator().CancelRequest( TGlxMediaId(0) ); |
115 // CGlxDataSourceTaskMde::CancelRequest |
113 // CGlxDataSourceTaskMde::CancelRequest |
116 // ---------------------------------------------------------------------------- |
114 // ---------------------------------------------------------------------------- |
117 // |
115 // |
118 void CGlxDataSourceTaskMde::CancelRequest() |
116 void CGlxDataSourceTaskMde::CancelRequest() |
119 { |
117 { |
120 TRACER("CGlxDataSourceTaskMde::CancelRequest()") |
118 TRACER("CGlxDataSourceTaskMde::CancelRequest()"); |
121 DestroyQueries(); |
|
122 iCancelled = ETrue; |
119 iCancelled = ETrue; |
|
120 DestroyQueries(); |
123 } |
121 } |
124 |
122 |
125 // ---------------------------------------------------------------------------- |
123 // ---------------------------------------------------------------------------- |
126 // CGlxDataSourceTaskMde::HandleQueryNewResults |
124 // CGlxDataSourceTaskMde::HandleQueryNewResults |
127 // ---------------------------------------------------------------------------- |
125 // ---------------------------------------------------------------------------- |
128 // |
126 // |
129 void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/, |
127 void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/, |
130 TInt /*aFirstNewItemIndex*/, |
128 TInt /*aFirstNewItemIndex*/, |
131 TInt /*aNewItemCount*/ ) |
129 TInt /*aNewItemCount*/ ) |
132 { |
130 { |
133 TRACER("CGlxDataSourceTaskMde::HandleQueryNewResults()") |
131 TRACER("CGlxDataSourceTaskMde::HandleQueryNewResults()"); |
134 // Not used. |
132 // Not used. |
135 } |
133 } |
136 |
134 |
137 |
135 |
138 // ---------------------------------------------------------------------------- |
136 // ---------------------------------------------------------------------------- |
142 void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/, |
140 void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/, |
143 TInt /*aNewObjectItemCount*/, |
141 TInt /*aNewObjectItemCount*/, |
144 TInt /*aNewRelationItemCount*/, |
142 TInt /*aNewRelationItemCount*/, |
145 TInt /*aNewEventItemCount*/) |
143 TInt /*aNewEventItemCount*/) |
146 { |
144 { |
147 TRACER("CGlxDataSourceTaskMde::HandleQueryNewResults()") |
145 TRACER("CGlxDataSourceTaskMde::HandleQueryNewResults()"); |
148 // Not used. |
146 // Not used. |
149 } |
147 } |
150 |
148 |
151 |
149 |
152 // ---------------------------------------------------------------------------- |
150 // ---------------------------------------------------------------------------- |
153 // CGlxDataSourceTaskMde::HandleQueryCompleted |
151 // CGlxDataSourceTaskMde::HandleQueryCompleted |
154 // ---------------------------------------------------------------------------- |
152 // ---------------------------------------------------------------------------- |
155 // |
153 // |
156 void CGlxDataSourceTaskMde::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError) |
154 void CGlxDataSourceTaskMde::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError) |
157 { |
155 { |
158 TRACER("CGlxDataSourceTaskMde::HandleQueryCompleted()") |
156 TRACER("CGlxDataSourceTaskMde::HandleQueryCompleted()"); |
159 __ASSERT_ALWAYS(&aQuery == iQueries[0], Panic(EGlxPanicQueryLogicError)); |
157 __ASSERT_ALWAYS(&aQuery == iQueries[0], Panic(EGlxPanicQueryLogicError)); |
160 |
158 |
161 TInt err = aError; |
159 TInt err = aError; |
162 if (err == KErrNone) |
160 if (err == KErrNone) |
163 { |
161 { |
164 TRAP(err, HandleQueryCompletedL(aQuery)); |
162 TRAP(err, HandleQueryCompletedL(aQuery)); |
165 } |
163 } |
166 |
164 |
167 if (err != KErrNone) |
165 if (err != KErrNone && !iCancelled) |
168 { |
166 { |
169 HandleRequestComplete(err); |
167 HandleRequestComplete(err); |
170 } |
168 } |
171 } |
169 } |
172 |
170 |
174 // CGlxDataSourceTaskMde::DataSource |
172 // CGlxDataSourceTaskMde::DataSource |
175 // ---------------------------------------------------------------------------- |
173 // ---------------------------------------------------------------------------- |
176 // |
174 // |
177 CGlxDataSourceMde* CGlxDataSourceTaskMde::DataSource() |
175 CGlxDataSourceMde* CGlxDataSourceTaskMde::DataSource() |
178 { |
176 { |
179 TRACER("CGlxDataSourceTaskMde::DataSource()") |
177 TRACER("CGlxDataSourceTaskMde::DataSource()"); |
180 return static_cast<CGlxDataSourceMde*>(iDataSource); |
178 return static_cast<CGlxDataSourceMde*>(iDataSource); |
181 } |
179 } |
182 |
180 |
183 // ---------------------------------------------------------------------------- |
181 // ---------------------------------------------------------------------------- |
184 // CGlxDataSourceTaskMde::AddMonthFilterL |
182 // CGlxDataSourceTaskMde::AddMonthFilterL |
185 // ---------------------------------------------------------------------------- |
183 // ---------------------------------------------------------------------------- |
186 // |
184 // |
187 void CGlxDataSourceTaskMde::AddMonthFilterL(const TGlxMediaId& aContainerId, TGlxFilterProperties& aFilterProperties) |
185 void CGlxDataSourceTaskMde::AddMonthFilterL(const TGlxMediaId& aContainerId, |
188 { |
186 TGlxFilterProperties& aFilterProperties) |
189 TRACER("CGlxDataSourceTaskMde::AddMonthFilterL(const TGlxMediaId& aContainerId, TGlxFilterProperties& aFilterProperties)") |
187 { |
|
188 TRACER("CGlxDataSourceTaskMde::AddMonthFilterL(const TGlxMediaId& aContainerId, TGlxFilterProperties& aFilterProperties)"); |
190 CMdEObject* month = DataSource()->Session().GetObjectL(aContainerId.Value()); |
189 CMdEObject* month = DataSource()->Session().GetObjectL(aContainerId.Value()); |
191 if( !month ) |
190 if( !month ) |
192 { |
191 { |
193 User::Leave(KErrNotFound); |
192 User::Leave(KErrNotFound); |
194 } |
193 } |
202 |
201 |
203 // ---------------------------------------------------------------------------- |
202 // ---------------------------------------------------------------------------- |
204 // CGlxDataSourceTaskMde::AddMonthFilterL |
203 // CGlxDataSourceTaskMde::AddMonthFilterL |
205 // ---------------------------------------------------------------------------- |
204 // ---------------------------------------------------------------------------- |
206 // |
205 // |
207 void CGlxDataSourceTaskMde::AddMonthFilterL(CMdEObject* aMonth, TGlxFilterProperties& aFilterProperties) |
206 void CGlxDataSourceTaskMde::AddMonthFilterL(CMdEObject* aMonth, TGlxFilterProperties& |
208 { |
207 aFilterProperties) |
209 TRACER("CGlxDataSourceTaskMde::AddMonthFilterL(CMdEObject* aMonth, TGlxFilterProperties& aFilterProperties)") |
208 { |
210 CMdEPropertyDef& creationDateDef = DataSource()->ObjectDef().GetPropertyDefL(KPropertyDefNameCreationDate); |
209 TRACER("CGlxDataSourceTaskMde::AddMonthFilterL(CMdEObject* aMonth, TGlxFilterProperties& aFilterProperties)"); |
|
210 CMdEPropertyDef& creationDateDef = DataSource()->ObjectDef().GetPropertyDefL( |
|
211 KPropertyDefNameCreationDate); |
211 if (creationDateDef.PropertyType() != EPropertyTime) |
212 if (creationDateDef.PropertyType() != EPropertyTime) |
212 { |
213 { |
213 User::Leave(KErrCorrupt); |
214 User::Leave(KErrCorrupt); |
214 } |
215 } |
215 |
216 |
216 CMdEPropertyDef& lmDateDef = DataSource()->ObjectDef().GetPropertyDefL(KPropertyDefNameLastModifiedDate); |
217 CMdEPropertyDef& lmDateDef = DataSource()->ObjectDef().GetPropertyDefL( |
|
218 KPropertyDefNameLastModifiedDate); |
217 if (lmDateDef.PropertyType() != EPropertyTime) |
219 if (lmDateDef.PropertyType() != EPropertyTime) |
218 { |
220 { |
219 User::Leave(KErrCorrupt); |
221 User::Leave(KErrCorrupt); |
220 } |
222 } |
221 |
223 |
238 |
240 |
239 // ---------------------------------------------------------------------------- |
241 // ---------------------------------------------------------------------------- |
240 // CGlxDataSourceTaskMde::SetQueryConditionsL |
242 // CGlxDataSourceTaskMde::SetQueryConditionsL |
241 // ---------------------------------------------------------------------------- |
243 // ---------------------------------------------------------------------------- |
242 // |
244 // |
243 void CGlxDataSourceTaskMde::SetQueryConditionsL(CMdEQuery& aQuery, const TGlxFilterProperties& aFilterProperties, const TGlxMediaId aContainerId, CMdEObjectDef& aObjectDef) |
245 void CGlxDataSourceTaskMde::SetQueryConditionsL(CMdEQuery& aQuery, |
244 { |
246 const TGlxFilterProperties& aFilterProperties, const TGlxMediaId aContainerId, |
245 TRACER("CGlxDataSourceTaskMde::SetQueryConditionsL()") |
247 CMdEObjectDef& aObjectDef) |
|
248 { |
|
249 TRACER("CGlxDataSourceTaskMde::SetQueryConditionsL()"); |
246 |
250 |
247 CMdELogicCondition& rootCondition = aQuery.Conditions(); |
251 CMdELogicCondition& rootCondition = aQuery.Conditions(); |
248 CMdEObjectDef* objectDef = &aObjectDef; |
252 CMdEObjectDef* objectDef = &aObjectDef; |
249 |
253 |
250 SetQueryFilterConditionsL(rootCondition, *objectDef, aFilterProperties); |
254 SetQueryFilterConditionsL(rootCondition, *objectDef, aFilterProperties); |
251 SetSortOrderL(aQuery, aObjectDef, aFilterProperties); |
255 |
|
256 if (aQuery.ResultMode() != EQueryResultModeCount) |
|
257 { |
|
258 SetSortOrderL(aQuery, aObjectDef, aFilterProperties); |
|
259 } |
252 |
260 |
253 if( KGlxCollectionRootId != aContainerId.Value() ) |
261 if( KGlxCollectionRootId != aContainerId.Value() ) |
254 { |
262 { |
255 CMdELogicCondition* containerCondition = NULL; |
263 CMdELogicCondition* containerCondition = NULL; |
256 CMdERelationCondition* relationCondition = NULL; |
264 CMdERelationCondition* relationCondition = NULL; |
257 objectDef = &DataSource()->ObjectDef(); |
265 objectDef = &DataSource()->ObjectDef(); |
258 if( DataSource()->ContainerIsLeft(aObjectDef) ) |
266 if( DataSource()->ContainerIsLeft(aObjectDef) ) |
259 { |
267 { |
260 relationCondition = &rootCondition.AddRelationConditionL(DataSource()->ContainsDef(), ERelationConditionSideRight); |
268 relationCondition = &rootCondition.AddRelationConditionL( |
|
269 DataSource()->ContainsDef(), ERelationConditionSideRight); |
261 containerCondition = &relationCondition->LeftL(); |
270 containerCondition = &relationCondition->LeftL(); |
262 } |
271 } |
263 else |
272 else |
264 { |
273 { |
265 relationCondition = &rootCondition.AddRelationConditionL(DataSource()->ContainsDef(), ERelationConditionSideLeft); |
274 relationCondition = &rootCondition.AddRelationConditionL( |
|
275 DataSource()->ContainsDef(), ERelationConditionSideLeft); |
266 containerCondition = &relationCondition->RightL(); |
276 containerCondition = &relationCondition->RightL(); |
267 } |
277 } |
268 containerCondition->AddObjectConditionL(aContainerId.Value()); |
278 containerCondition->AddObjectConditionL(aContainerId.Value()); |
269 } |
279 } |
270 |
280 |
296 logicCondition.AddObjectConditionL( DataSource()->ImageDef() ); |
306 logicCondition.AddObjectConditionL( DataSource()->ImageDef() ); |
297 logicCondition.AddObjectConditionL( DataSource()->VideoDef() ); |
307 logicCondition.AddObjectConditionL( DataSource()->VideoDef() ); |
298 } |
308 } |
299 } |
309 } |
300 |
310 |
301 if( ( aFilterProperties.iMinCount > 0 ) && ( CGlxDataSource::EContainerTypeNotAContainer != DataSource()->ContainerType(&aObjectDef) ) ) |
311 if( ( aFilterProperties.iMinCount > 0 ) && ( |
|
312 CGlxDataSource::EContainerTypeNotAContainer != DataSource()->ContainerType( |
|
313 &aObjectDef) ) ) |
302 { |
314 { |
303 TMdEUintRange range(aFilterProperties.iMinCount,aFilterProperties.iMinCount,EMdERangeTypeGreaterOrEqual); |
315 TMdEUintRange range(aFilterProperties.iMinCount, |
|
316 aFilterProperties.iMinCount,EMdERangeTypeGreaterOrEqual); |
304 aLogicCondition.AddObjectConditionL(range); |
317 aLogicCondition.AddObjectConditionL(range); |
305 } |
318 } |
306 |
319 |
307 if( 0 != aFilterProperties.iContainsItem.Value() ) |
320 if( 0 != aFilterProperties.iContainsItem.Value() ) |
308 { |
321 { |
309 |
322 |
310 if( DataSource()->ContainerIsLeft(aObjectDef) ) |
323 if( DataSource()->ContainerIsLeft(aObjectDef) ) |
311 { |
324 { |
312 CMdERelationCondition& relationCondition = |
325 CMdERelationCondition& relationCondition = |
313 aLogicCondition.AddRelationConditionL(DataSource()->ContainsDef(), ERelationConditionSideLeft); |
326 aLogicCondition.AddRelationConditionL( |
314 relationCondition.RightL().AddObjectConditionL(aFilterProperties.iContainsItem.Value()); |
327 DataSource()->ContainsDef(), ERelationConditionSideLeft); |
|
328 relationCondition.RightL().AddObjectConditionL( |
|
329 aFilterProperties.iContainsItem.Value()); |
315 } |
330 } |
316 else |
331 else |
317 { |
332 { |
318 CMdERelationCondition& relationCondition = aLogicCondition.AddRelationConditionL(DataSource()->ContainsDef(), ERelationConditionSideRight); |
333 CMdERelationCondition& relationCondition = aLogicCondition.AddRelationConditionL( |
|
334 DataSource()->ContainsDef(), ERelationConditionSideRight); |
319 relationCondition.LeftL().AddObjectConditionL(aFilterProperties.iContainsItem.Value()); |
335 relationCondition.LeftL().AddObjectConditionL(aFilterProperties.iContainsItem.Value()); |
320 } |
336 } |
321 } |
337 } |
322 |
338 |
323 if( EGlxFilterOriginNotUsed != aFilterProperties.iOrigin ) |
339 if( EGlxFilterOriginNotUsed != aFilterProperties.iOrigin ) |
324 { |
340 { |
325 CMdEPropertyDef& originProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameOrigin); |
341 CMdEPropertyDef& originProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameOrigin); |
326 if( EGlxFilterOriginDownload == aFilterProperties.iOrigin ) |
342 if( EGlxFilterOriginDownload == aFilterProperties.iOrigin ) |
327 { |
343 { |
328 // The download collection shows all but captured items |
344 // The download collection shows all but captured items |
329 aLogicCondition.AddPropertyConditionL(originProperty, TMdEUintNotEqual(MdeConstants::Object::ECamera)); |
345 aLogicCondition.AddPropertyConditionL(originProperty, TMdEUintNotEqual( |
|
346 MdeConstants::Object::ECamera)); |
330 } |
347 } |
331 else if(EGlxFilterOriginCamera == aFilterProperties.iOrigin ) |
348 else if(EGlxFilterOriginCamera == aFilterProperties.iOrigin ) |
332 { |
349 { |
333 // The camera collection Shows the captured Items |
350 // The camera collection Shows the captured Items |
334 aLogicCondition.AddPropertyConditionL(originProperty, TMdEUintEqual(MdeConstants::Object::ECamera)); |
351 aLogicCondition.AddPropertyConditionL(originProperty, TMdEUintEqual( |
|
352 MdeConstants::Object::ECamera)); |
335 } |
353 } |
|
354 else if(EGlxFilterOriginAll == aFilterProperties.iOrigin ) |
|
355 { |
|
356 // The Months Collection Populates All the Items, filter |
|
357 // it for Images and Videos only |
|
358 CMdELogicCondition& logicCondition = |
|
359 aLogicCondition.AddLogicConditionL(ELogicConditionOperatorOr); |
|
360 logicCondition.AddObjectConditionL( DataSource()->ImageDef() ); |
|
361 } |
336 } |
362 } |
337 |
363 |
338 if( aFilterProperties.iExcludeAnimation ) |
364 if( aFilterProperties.iExcludeAnimation ) |
339 { |
365 { |
340 //__ASSERT_DEBUG((EGlxFilterImage == aFilterProperties.iItemType), Panic(EGlxPanicIllegalArgument)); |
|
341 // Exclude any image with a frame count > 1 |
366 // Exclude any image with a frame count > 1 |
342 const TInt excludeAllImagesAboveOrEqualToThisFrameCount = 2; |
367 const TInt excludeAllImagesAboveOrEqualToThisFrameCount = 2; |
343 CMdEPropertyDef& frameCountProperty = DataSource()->ImageDef().GetPropertyDefL(KPropertyDefNameFrameCount); |
368 CMdEPropertyDef& frameCountProperty = DataSource()->ImageDef().GetPropertyDefL( |
344 aLogicCondition.AddPropertyConditionL(frameCountProperty, TMdEIntLess(excludeAllImagesAboveOrEqualToThisFrameCount)); |
369 KPropertyDefNameFrameCount); |
|
370 aLogicCondition.AddPropertyConditionL(frameCountProperty, TMdEIntLess( |
|
371 excludeAllImagesAboveOrEqualToThisFrameCount)); |
345 } |
372 } |
346 |
373 |
347 if( aFilterProperties.iNoDRM ) |
374 if( aFilterProperties.iNoDRM ) |
348 { |
375 { |
349 __ASSERT_DEBUG((EGlxFilterImage == aFilterProperties.iItemType), Panic(EGlxPanicIllegalArgument)); |
376 __ASSERT_DEBUG((EGlxFilterImage == aFilterProperties.iItemType), Panic( |
350 // Exclude any image which is DRM protected |
377 EGlxPanicIllegalArgument)); |
351 //CMdEPropertyDef& drmProperty = DataSource()->ImageDef().GetPropertyDefL(KPropertyDefNameDRM); |
|
352 //aLogicCondition.AddPropertyConditionL(drmProperty, EFalse); |
|
353 } |
378 } |
354 |
379 |
355 if( aFilterProperties.iPath ) // If this is set. Then we need to filter on the Ids it supplies |
380 if( aFilterProperties.iPath ) // If this is set. Then we need to filter on the Ids it supplies |
356 { |
381 { |
357 TArray<TInt> selection = aFilterProperties.iPath->Selection(); |
382 TArray<TInt> selection = aFilterProperties.iPath->Selection(); |
371 CleanupStack::Pop(&itemList); |
396 CleanupStack::Pop(&itemList); |
372 } |
397 } |
373 |
398 |
374 if( !aFilterProperties.iIncludeCameraAlbum ) |
399 if( !aFilterProperties.iIncludeCameraAlbum ) |
375 { |
400 { |
376 CMdEObjectCondition& objectCondition = aLogicCondition.AddObjectConditionL(DataSource()->CameraAlbumId().Value()); |
401 CMdEObjectCondition& objectCondition = aLogicCondition.AddObjectConditionL( |
|
402 DataSource()->CameraAlbumId().Value()); |
377 objectCondition.SetNegate(ETrue); |
403 objectCondition.SetNegate(ETrue); |
378 } |
404 } |
379 |
405 |
380 if( TTime(0) != aFilterProperties.iStartDate ) |
406 if( TTime(0) != aFilterProperties.iStartDate ) |
381 { |
407 { |
382 CMdEPropertyDef& creationDateDef = aObjectDef.GetPropertyDefL(KPropertyDefNameCreationDate); |
408 CMdEPropertyDef& creationDateDef = aObjectDef.GetPropertyDefL( |
|
409 KPropertyDefNameCreationDate); |
383 if (creationDateDef.PropertyType() != EPropertyTime) |
410 if (creationDateDef.PropertyType() != EPropertyTime) |
384 { |
411 { |
385 User::Leave(KErrCorrupt); |
412 User::Leave(KErrCorrupt); |
386 } |
413 } |
387 |
414 |
388 aLogicCondition.AddPropertyConditionL(creationDateDef, TMdETimeBetween(aFilterProperties.iStartDate, aFilterProperties.iEndDate)); |
415 aLogicCondition.AddPropertyConditionL(creationDateDef, TMdETimeBetween( |
|
416 aFilterProperties.iStartDate, aFilterProperties.iEndDate)); |
389 } |
417 } |
390 } |
418 } |
391 |
419 |
392 // ---------------------------------------------------------------------------- |
420 // ---------------------------------------------------------------------------- |
393 // CGlxDataSourceTaskMde::SetSortOrderL |
421 // CGlxDataSourceTaskMde::SetSortOrderL |
394 // ---------------------------------------------------------------------------- |
422 // ---------------------------------------------------------------------------- |
395 // |
423 // |
396 void CGlxDataSourceTaskMde::SetSortOrderL(CMdEQuery& aQuery, CMdEObjectDef& aObjectDef, |
424 void CGlxDataSourceTaskMde::SetSortOrderL(CMdEQuery& aQuery, CMdEObjectDef& aObjectDef, |
397 const TGlxFilterProperties& aFilterProperties) |
425 const TGlxFilterProperties& aFilterProperties) |
398 { |
426 { |
399 TRACER("CGlxDataSourceTaskMde::SetSortOrderL()") |
427 TRACER("CGlxDataSourceTaskMde::SetSortOrderL()"); |
400 switch(aFilterProperties.iSortOrder) |
428 switch(aFilterProperties.iSortOrder) |
401 { |
429 { |
402 case EGlxFilterSortOrderAlphabetical: |
430 case EGlxFilterSortOrderAlphabetical: |
403 { |
431 { |
404 CMdEPropertyDef& titleProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameTitle); |
432 CMdEPropertyDef& titleProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameTitle); |
405 TMdEOrderRule orderRule(titleProperty, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
433 TMdEOrderRule orderRule(titleProperty, aFilterProperties.iSortDirection == |
|
434 EGlxFilterSortDirectionAscending); |
406 orderRule.SetType(EOrderRuleTypeProperty); |
435 orderRule.SetType(EOrderRuleTypeProperty); |
407 orderRule.SetCaseSensitive(EFalse); |
436 orderRule.SetCaseSensitive(EFalse); |
408 aQuery.AppendOrderRuleL(orderRule); |
437 aQuery.AppendOrderRuleL(orderRule); |
409 break; |
438 break; |
410 } |
439 } |
411 case EGlxFilterSortOrderItemCount: |
440 case EGlxFilterSortOrderItemCount: |
412 { |
441 { |
413 TMdEOrderRule orderRule(EOrderRuleTypeUsageCount, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
442 //Order rule is needed for tags popularity |
|
443 TMdEOrderRule orderRule(EOrderRuleTypeUsageCount, aFilterProperties.iSortDirection == |
|
444 EGlxFilterSortDirectionAscending); |
414 aQuery.AppendOrderRuleL(orderRule); |
445 aQuery.AppendOrderRuleL(orderRule); |
415 break; |
446 break; |
416 } |
447 } |
417 case EGlxFilterSortOrderCaptureDate: |
448 case EGlxFilterSortOrderCaptureDate: |
418 { |
449 { |
419 CMdEPropertyDef& creationDateProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameCreationDate); |
450 CMdEPropertyDef& creationDateProperty = aObjectDef.GetPropertyDefL( |
420 TMdEOrderRule orderRule(creationDateProperty, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
451 KPropertyDefNameCreationDate); |
|
452 TMdEOrderRule orderRule(creationDateProperty, aFilterProperties.iSortDirection == |
|
453 EGlxFilterSortDirectionAscending); |
421 orderRule.SetType(EOrderRuleTypeProperty); |
454 orderRule.SetType(EOrderRuleTypeProperty); |
422 aQuery.AppendOrderRuleL(orderRule); |
455 aQuery.AppendOrderRuleL(orderRule); |
423 TMdEOrderRule orderRule2(EOrderRuleTypeItemID, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
456 TMdEOrderRule orderRule2(EOrderRuleTypeItemID, aFilterProperties.iSortDirection == |
|
457 EGlxFilterSortDirectionAscending); |
424 aQuery.AppendOrderRuleL(orderRule2); |
458 aQuery.AppendOrderRuleL(orderRule2); |
425 break; |
459 break; |
426 } |
460 } |
427 case EGlxFilterSortOrderModifiedDate: |
461 case EGlxFilterSortOrderModifiedDate: |
428 { |
462 { |
429 CMdEPropertyDef& modifiedDateProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameLastModifiedDate); |
463 CMdEPropertyDef& modifiedDateProperty = aObjectDef.GetPropertyDefL( |
430 TMdEOrderRule orderRule(modifiedDateProperty, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
464 KPropertyDefNameLastModifiedDate); |
|
465 TMdEOrderRule orderRule(modifiedDateProperty, aFilterProperties.iSortDirection == |
|
466 EGlxFilterSortDirectionAscending); |
431 orderRule.SetType(EOrderRuleTypeProperty); |
467 orderRule.SetType(EOrderRuleTypeProperty); |
432 aQuery.AppendOrderRuleL(orderRule); |
468 aQuery.AppendOrderRuleL(orderRule); |
433 TMdEOrderRule orderRule2(EOrderRuleTypeItemID, aFilterProperties.iSortDirection == EGlxFilterSortDirectionAscending); |
469 TMdEOrderRule orderRule2(EOrderRuleTypeItemID, aFilterProperties.iSortDirection == |
|
470 EGlxFilterSortDirectionAscending); |
434 aQuery.AppendOrderRuleL(orderRule2); |
471 aQuery.AppendOrderRuleL(orderRule2); |
435 break; |
472 break; |
436 } |
473 } |
437 case EGlxFilterSortOrderNotUsed: |
474 case EGlxFilterSortOrderNotUsed: |
438 { |
475 { |
443 |
480 |
444 // ---------------------------------------------------------------------------- |
481 // ---------------------------------------------------------------------------- |
445 // CGlxDataSourceTaskMde::MaxQueryResultsCount |
482 // CGlxDataSourceTaskMde::MaxQueryResultsCount |
446 // ---------------------------------------------------------------------------- |
483 // ---------------------------------------------------------------------------- |
447 // |
484 // |
448 TInt CGlxDataSourceTaskMde::MaxQueryResultsCount(const TGlxFilterProperties& aFilterProperties) const |
485 TInt CGlxDataSourceTaskMde::MaxQueryResultsCount(const TGlxFilterProperties& |
449 { |
486 aFilterProperties) const |
450 TRACER("CGlxDataSourceTaskMde::MaxQueryResultsCount()") |
487 { |
|
488 TRACER("CGlxDataSourceTaskMde::MaxQueryResultsCount()"); |
451 TInt ret = KMdEQueryDefaultMaxCount; |
489 TInt ret = KMdEQueryDefaultMaxCount; |
452 if (aFilterProperties.iLastCaptureDate) |
490 if (aFilterProperties.iLastCaptureDate || aFilterProperties.iMaxCount == 1) |
453 { |
491 { |
454 ret = 1; |
492 ret = 1; |
455 } |
493 } |
|
494 GLX_DEBUG2("CGlxDataSourceTaskMde::MaxQueryResultsCount ret=%d", ret); |
456 return ret; |
495 return ret; |
457 } |
496 } |
458 |
497 |
459 // ---------------------------------------------------------------------------- |
498 // ---------------------------------------------------------------------------- |
460 // CGlxDataSourceTaskMde::RemoveQuery |
499 // CGlxDataSourceTaskMde::RemoveQuery |
461 // ---------------------------------------------------------------------------- |
500 // ---------------------------------------------------------------------------- |
462 // |
501 // |
463 void CGlxDataSourceTaskMde::RemoveQuery() |
502 void CGlxDataSourceTaskMde::RemoveQuery() |
464 { |
503 { |
465 TRACER("CGlxDataSourceTaskMde::RemoveQuery()") |
504 TRACER("CGlxDataSourceTaskMde::RemoveQuery()"); |
466 CMdEQuery* query = iQueries[0]; |
505 CMdEQuery* query = iQueries[0]; |
467 iQueryTypes.Remove(0); |
506 iQueryTypes.Remove(0); |
468 iQueries.Remove(0); |
507 iQueries.Remove(0); |
469 query->RemoveObserver(*this); |
508 query->RemoveObserver(*this); |
470 delete query; |
509 delete query; |
546 // CGlxDataSourceTask::QueueTagObjectQueryL |
586 // CGlxDataSourceTask::QueueTagObjectQueryL |
547 // ---------------------------------------------------------------------------- |
587 // ---------------------------------------------------------------------------- |
548 // |
588 // |
549 void CGlxDataSourceTaskMde::QueueTagObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
589 void CGlxDataSourceTaskMde::QueueTagObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
550 { |
590 { |
551 TRACER("CGlxDataSourceTaskMde::QueueTagObjectQueryL()") |
591 TRACER("CGlxDataSourceTaskMde::QueueTagObjectQueryL()"); |
552 QueueObjectQueryL(DataSource()->TagDef(), aObjectIds, EImageVideoQuery); |
592 QueueObjectQueryL(DataSource()->TagDef(), aObjectIds, EImageVideoQuery); |
553 } |
593 } |
554 |
594 |
555 // ---------------------------------------------------------------------------- |
595 // ---------------------------------------------------------------------------- |
556 // CGlxDataSourceTask::QueueAlbumObjectQueryL |
596 // CGlxDataSourceTask::QueueAlbumObjectQueryL |
557 // ---------------------------------------------------------------------------- |
597 // ---------------------------------------------------------------------------- |
558 // |
598 // |
559 void CGlxDataSourceTaskMde::QueueAlbumObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
599 void CGlxDataSourceTaskMde::QueueAlbumObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
560 { |
600 { |
561 TRACER("CGlxDataSourceTaskMde::QueueAlbumObjectQueryL()") |
601 TRACER("CGlxDataSourceTaskMde::QueueAlbumObjectQueryL()"); |
562 QueueObjectQueryL(DataSource()->AlbumDef(), aObjectIds, EImageVideoQuery); |
602 QueueObjectQueryL(DataSource()->AlbumDef(), aObjectIds, EImageVideoQuery); |
563 } |
603 } |
564 |
604 |
565 |
605 |
566 void CGlxDataSourceTaskMde::QueueMonthObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
606 void CGlxDataSourceTaskMde::QueueMonthObjectQueryL(const RArray<TGlxMediaId>& aObjectIds) |
567 { |
607 { |
568 TRACER("CGlxDataSourceTaskMde::QueueMonthObjectQueryL()") |
608 TRACER("CGlxDataSourceTaskMde::QueueMonthObjectQueryL()"); |
569 QueueObjectQueryL(DataSource()->MonthDef(), aObjectIds, EImageVideoQuery); |
609 QueueObjectQueryL(DataSource()->MonthDef(), aObjectIds, EImageVideoQuery); |
570 } |
610 } |
571 |
611 |
572 // ---------------------------------------------------------------------------- |
612 // ---------------------------------------------------------------------------- |
573 // CGlxDataSourceTask::QueueObjectQueryL |
613 // CGlxDataSourceTask::QueueObjectQueryL |
574 // ---------------------------------------------------------------------------- |
614 // ---------------------------------------------------------------------------- |
575 // |
615 // |
576 void CGlxDataSourceTaskMde::QueueObjectQueryL(CMdEObjectDef& aObjectDef, |
616 void CGlxDataSourceTaskMde::QueueObjectQueryL(CMdEObjectDef& aObjectDef, |
577 const RArray<TGlxMediaId>& aObjectIds, const TGlxQueryType& aQueryType) |
617 const RArray<TGlxMediaId>& aObjectIds, const TGlxQueryType& aQueryType) |
578 { |
618 { |
579 TRACER("CGlxDataSourceTaskMde::QueueObjectQueryL()") |
619 TRACER("CGlxDataSourceTaskMde::QueueObjectQueryL()"); |
580 CMdEQuery* query = DataSource()->Session().NewObjectQueryL(*DataSource()->NamespaceDef(), aObjectDef, this); |
620 CMdEQuery* query = DataSource()->Session().NewObjectQueryL(*DataSource()->NamespaceDef(), |
|
621 aObjectDef, this); |
581 CleanupStack::PushL(query); |
622 CleanupStack::PushL(query); |
582 |
623 |
583 CMdELogicCondition& lc = query->Conditions(); |
624 CMdELogicCondition& lc = query->Conditions(); |
584 NGlxDataSourceMdsUtility::AddObjectConditionL(lc,aObjectIds); |
625 NGlxDataSourceMdsUtility::AddObjectConditionL(lc,aObjectIds); |
585 |
626 |
586 query->SetResultMode(EQueryResultModeObjectWithFreetexts); |
627 query->SetResultMode(EQueryResultModeItem); |
587 |
628 |
588 CleanupStack::Pop(query); |
629 CleanupStack::Pop(query); |
589 AppendQueryL(query, aQueryType); |
630 AppendQueryL(query, aQueryType); |
590 |
631 |
591 } |
632 } |
616 // CGlxDataSourceTaskMde::ExecuteQueryL |
657 // CGlxDataSourceTaskMde::ExecuteQueryL |
617 // ---------------------------------------------------------------------------- |
658 // ---------------------------------------------------------------------------- |
618 // |
659 // |
619 void CGlxDataSourceTaskMde::ExecuteQueryL() |
660 void CGlxDataSourceTaskMde::ExecuteQueryL() |
620 { |
661 { |
621 TRACER("CGlxDataSourceTaskMde::ExecuteQueryL()") |
662 TRACER("CGlxDataSourceTaskMde::ExecuteQueryL()"); |
622 __ASSERT_DEBUG(iQueries.Count(), Panic(EGlxPanicQueryLogicError)); |
663 __ASSERT_DEBUG(iQueries.Count(), Panic(EGlxPanicQueryLogicError)); |
623 iQueries[0]->FindL(); |
664 iQueries[0]->FindL(); |
624 } |
665 } |
625 |
666 |
626 // ---------------------------------------------------------------------------- |
667 // ---------------------------------------------------------------------------- |
627 // CGlxDataSourceTaskMde::HandleQueryCompletedL |
668 // CGlxDataSourceTaskMde::HandleQueryCompletedL |
628 // ---------------------------------------------------------------------------- |
669 // ---------------------------------------------------------------------------- |
629 // |
670 // |
630 void CGlxDataSourceTaskMde::HandleQueryCompletedL(CMdEQuery& aQuery) |
671 void CGlxDataSourceTaskMde::HandleQueryCompletedL(CMdEQuery& aQuery) |
631 { |
672 { |
632 TRACER("CGlxDataSourceTaskMde::HandleQueryCompletedL()") |
673 TRACER("CGlxDataSourceTaskMde::HandleQueryCompletedL()"); |
633 DoHandleQueryCompletedL(aQuery); |
674 DoHandleQueryCompletedL(aQuery); |
634 RemoveQuery(); |
675 |
|
676 // Both the function calls should be executed if any |
|
677 // request is not cancelled before completion. |
|
678 // All the pending Queries are already destroyed in CancelRequest. |
|
679 // Hence we do not have to call RemoveQuery here. That will lead to |
|
680 // User 130 crash. |
|
681 // DoNextQuery tries to get iQueries.Count(). Since iQueries is destroyed |
|
682 // in CancelRequest |
|
683 if (iCancelled) |
|
684 { |
|
685 GLX_LOG_INFO("***Query already Removed. Hence Return***"); |
|
686 return; |
|
687 } |
|
688 RemoveQuery(); |
635 DoNextQueryL(); |
689 DoNextQueryL(); |
636 } |
690 } |
637 |
691 |
638 // ---------------------------------------------------------------------------- |
692 // ---------------------------------------------------------------------------- |
639 // CGlxDataSourceTaskMde::DestroyQueries |
693 // CGlxDataSourceTaskMde::DestroyQueries |
640 // ---------------------------------------------------------------------------- |
694 // ---------------------------------------------------------------------------- |
641 // |
695 // |
642 void CGlxDataSourceTaskMde::DestroyQueries() |
696 void CGlxDataSourceTaskMde::DestroyQueries() |
643 { |
697 { |
644 TRACER("CGlxDataSourceTaskMde::DestroyQueries()") |
698 TRACER("CGlxDataSourceTaskMde::DestroyQueries()"); |
645 for (TInt i = 0; i < iQueries.Count(); i++) |
699 for (TInt i = 0; i < iQueries.Count(); i++) |
646 { |
700 { |
647 // Ensure that there are not any running queries |
701 // Ensure that there are not any running queries |
648 iQueries[i]->RemoveObserver(*this); |
702 iQueries[i]->RemoveObserver(*this); |
649 iQueries[i]->Cancel(); |
703 iQueries[i]->Cancel(); |