|
1 /* |
|
2 * Copyright (c) 2009 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: Implementation of container area filter class |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <s32strm.h> |
|
20 #include <lbttriggerfilterbyarea.h> |
|
21 #include <lbtgeoareabase.h> |
|
22 #include <lbttriggerconditionarea.h> |
|
23 #include <lbtgeocircle.h> |
|
24 #include <lbtgeorect.h> |
|
25 #include <lbtgeocell.h> |
|
26 #include <lbtgeohybrid.h> |
|
27 #include "lbtcontainerfilterbase.h" |
|
28 #include "lbtcontainertriggerfilter.h" |
|
29 #include "lbtcontainerareafilter.h" |
|
30 #include "lbtlogger.h" |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 // ======== LOCAL FUNCTIONS ======== |
|
36 |
|
37 // --------------------------------------------------------------------------- |
|
38 // CLbtContainerAttrFilter::NewL() |
|
39 // |
|
40 // (other items were commented in a header). |
|
41 // --------------------------------------------------------------------------- |
|
42 // |
|
43 CLbtContainerAreaFilter* CLbtContainerAreaFilter::NewL(CLbtTriggerFilterBase* aTrigFilter,CLbtContainerFilter* aContFilter) |
|
44 { |
|
45 FUNC_ENTER("CLbtContainerAreaFilter::NewL"); |
|
46 CLbtContainerAreaFilter* self = new( ELeave ) CLbtContainerAreaFilter; |
|
47 CleanupStack::PushL( self ); |
|
48 self->ConstructL(aTrigFilter,aContFilter); |
|
49 CleanupStack::Pop( self ); |
|
50 return self; |
|
51 } |
|
52 |
|
53 void CLbtContainerAreaFilter::ProcessFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
54 { |
|
55 FUNC_ENTER("CLbtContainerAreaFilter::ProcessFilter"); |
|
56 ProcessContFilter( aEntry,aIsFilterPresent, aIsEntryRequested); |
|
57 |
|
58 if((aIsFilterPresent>0 && aIsEntryRequested)||(aIsFilterPresent == 0)) |
|
59 { |
|
60 CLbtGeoAreaBase::TGeoAreaType type = iArea->Type(); |
|
61 switch( type ) |
|
62 { |
|
63 case CLbtGeoAreaBase::ECircle: |
|
64 { |
|
65 ProcessCircleFilter(aEntry,aIsFilterPresent,aIsEntryRequested); |
|
66 } |
|
67 break; |
|
68 case CLbtGeoAreaBase::ERectangular: |
|
69 { |
|
70 ProcessRectFilter(aEntry,aIsFilterPresent,aIsEntryRequested); |
|
71 } |
|
72 break; |
|
73 case CLbtGeoAreaBase::ECellular: |
|
74 { |
|
75 ProcessCellFilter(aEntry,aIsFilterPresent,aIsEntryRequested); |
|
76 } |
|
77 break; |
|
78 case CLbtGeoAreaBase::EHybrid: |
|
79 { |
|
80 ProcessHybridFilter(aEntry,aIsFilterPresent,aIsEntryRequested); |
|
81 } |
|
82 break; |
|
83 default: |
|
84 { |
|
85 break; |
|
86 } |
|
87 } |
|
88 } |
|
89 } |
|
90 |
|
91 void CLbtContainerAreaFilter::ProcessCellFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
92 { |
|
93 FUNC_ENTER("CLbtContainerAreaFilter::ProcessCellFilter"); |
|
94 |
|
95 CLbtGeoCell* cellArea=static_cast<CLbtGeoCell*>(iArea); |
|
96 |
|
97 // If the filter does not have a valid network mode then return ETrue |
|
98 //case only for simcard change from server |
|
99 //from client side, it is restricted |
|
100 if(cellArea->NetworkType() == RMobilePhone::ENetworkModeUnknown) |
|
101 { |
|
102 aIsFilterPresent++; |
|
103 aIsEntryRequested = ETrue; |
|
104 return; |
|
105 } |
|
106 |
|
107 if(aEntry!=NULL) |
|
108 { |
|
109 CLbtTriggerEntry* trigEntry=aEntry->TriggerEntry(); |
|
110 if(!trigEntry) |
|
111 { |
|
112 aIsFilterPresent = 0; |
|
113 return; |
|
114 } |
|
115 CLbtTriggerConditionBase* condBase=trigEntry->GetCondition(); |
|
116 if(!condBase) |
|
117 { |
|
118 aIsFilterPresent = 0; |
|
119 return; |
|
120 } |
|
121 |
|
122 CLbtTriggerConditionArea* trigCond = static_cast<CLbtTriggerConditionArea*> (condBase); |
|
123 |
|
124 |
|
125 CLbtGeoAreaBase::TGeoAreaType trigAreaType = trigCond->TriggerArea()->Type(); |
|
126 |
|
127 //if other than cell/hybrid |
|
128 if( trigAreaType != CLbtGeoAreaBase::ECellular && trigAreaType != CLbtGeoAreaBase::EHybrid ) |
|
129 { |
|
130 // The area type is not the same. |
|
131 aIsFilterPresent++; |
|
132 aIsEntryRequested = EFalse; |
|
133 return; |
|
134 } |
|
135 |
|
136 //if cell |
|
137 if( trigAreaType == CLbtGeoAreaBase::ECellular ) |
|
138 { |
|
139 CLbtGeoCell* trigArea=static_cast<CLbtGeoCell*>(trigCond->TriggerArea()); |
|
140 CompareCells( trigArea,cellArea, aIsFilterPresent, aIsEntryRequested ); |
|
141 return; |
|
142 } |
|
143 //hybrid |
|
144 CLbtGeoHybrid* hybridArea=static_cast<CLbtGeoHybrid*>(trigCond->TriggerArea()); |
|
145 const RPointerArray<CLbtGeoAreaBase>& trigAreaArray = hybridArea->HybridArea(); |
|
146 TInt cnt = trigAreaArray.Count(); |
|
147 TInt index; |
|
148 CLbtGeoCell* trigArea = NULL; |
|
149 for(index=0;index<cnt;index++) |
|
150 { |
|
151 //Current support is only for cellular hybrid triggers |
|
152 if( trigAreaArray[index]->Type() != CLbtGeoAreaBase::ECellular ) |
|
153 { |
|
154 continue; |
|
155 } |
|
156 trigArea = static_cast<CLbtGeoCell*> (trigAreaArray[index]); |
|
157 CompareCells( trigArea,cellArea, aIsFilterPresent, aIsEntryRequested ); |
|
158 //if atleast one cell matches, return, else goto next value |
|
159 if( aIsEntryRequested ) return; |
|
160 } |
|
161 }// end of if(aEntry!=NULL) |
|
162 } |
|
163 |
|
164 void CLbtContainerAreaFilter::ProcessHybridFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
165 { |
|
166 FUNC_ENTER("CLbtContainerAreaFilter::ProcessHybridFilter"); |
|
167 if(aEntry!=NULL) |
|
168 { |
|
169 CLbtTriggerEntry* trigEntry=aEntry->TriggerEntry(); |
|
170 if(!trigEntry) |
|
171 { |
|
172 aIsFilterPresent = 0; |
|
173 return; |
|
174 } |
|
175 CLbtTriggerConditionBase* condBase=trigEntry->GetCondition(); |
|
176 if(!condBase) |
|
177 { |
|
178 aIsFilterPresent = 0; |
|
179 return; |
|
180 } |
|
181 |
|
182 CLbtTriggerConditionArea* trigCond = static_cast<CLbtTriggerConditionArea*> (condBase); |
|
183 |
|
184 |
|
185 CLbtGeoAreaBase::TGeoAreaType trigAreaType = trigCond->TriggerArea()->Type(); |
|
186 |
|
187 //if other than cell/hybrid |
|
188 if( trigAreaType != CLbtGeoAreaBase::ECellular && trigAreaType != CLbtGeoAreaBase::EHybrid ) |
|
189 { |
|
190 // The area type is not the same. |
|
191 aIsFilterPresent++; |
|
192 aIsEntryRequested = EFalse; |
|
193 return; |
|
194 } |
|
195 |
|
196 //start filtering |
|
197 CLbtGeoHybrid* hybridArea = static_cast<CLbtGeoHybrid*>(iArea); |
|
198 const RPointerArray<CLbtGeoAreaBase>& hybridAreaArray = hybridArea->HybridArea(); |
|
199 TInt cnt = hybridAreaArray.Count(); |
|
200 TInt index; |
|
201 CLbtGeoCell* hybridCellArea = NULL; |
|
202 CLbtGeoCell* trigCellArea = NULL; |
|
203 for(index=0;index<cnt;index++) |
|
204 { |
|
205 //Current support is only for cellular hybrid triggers -check for dest |
|
206 if( hybridAreaArray[index]->Type() != CLbtGeoAreaBase::ECellular ) |
|
207 { |
|
208 continue; |
|
209 } |
|
210 hybridCellArea = static_cast<CLbtGeoCell*> (hybridAreaArray[index]); |
|
211 |
|
212 if( trigAreaType == CLbtGeoAreaBase::ECellular ) //source |
|
213 { |
|
214 trigCellArea=static_cast<CLbtGeoCell*>(trigCond->TriggerArea()); |
|
215 CompareCells( trigCellArea,hybridCellArea, aIsFilterPresent, aIsEntryRequested ); |
|
216 if( aIsFilterPresent > 0 && aIsEntryRequested ) return; |
|
217 } |
|
218 else |
|
219 { |
|
220 CLbtGeoHybrid* trigHybridArea=static_cast<CLbtGeoHybrid*>(trigCond->TriggerArea()); |
|
221 const RPointerArray<CLbtGeoAreaBase>& trigHybridAreaArray = trigHybridArea->HybridArea(); |
|
222 TInt count = trigHybridAreaArray.Count(); |
|
223 TInt indexTrig; |
|
224 for(indexTrig=0;indexTrig<count;indexTrig++) |
|
225 { |
|
226 //Current support is only for cellular hybrid triggers -check for source |
|
227 if( trigHybridAreaArray[indexTrig]->Type() != CLbtGeoAreaBase::ECellular ) |
|
228 { |
|
229 continue; |
|
230 } |
|
231 trigCellArea = static_cast<CLbtGeoCell*> (trigHybridAreaArray[indexTrig]); |
|
232 CompareCells( trigCellArea, hybridCellArea, aIsFilterPresent, aIsEntryRequested ); |
|
233 //if atleast one cell matches, return, else goto next value |
|
234 if( aIsFilterPresent > 0 && aIsEntryRequested ) |
|
235 { |
|
236 return; |
|
237 } |
|
238 } //inner for |
|
239 }//else trigAreaType == CLbtGeoAreaBase::ECellular |
|
240 } //outer for |
|
241 }// end of if(aEntry!=NULL) |
|
242 } |
|
243 |
|
244 void CLbtContainerAreaFilter::ProcessCircleFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
245 { |
|
246 FUNC_ENTER("CLbtContainerAreaFilter::ProcessCircleFilter"); |
|
247 // Add cicular filtering here. |
|
248 if(aEntry!=NULL) |
|
249 { |
|
250 CLbtTriggerEntry* trigEntry=aEntry->TriggerEntry(); |
|
251 if(!trigEntry) |
|
252 { |
|
253 //CHECK HOW TO HANDLE THIS SCENARIO |
|
254 aIsFilterPresent = 0; |
|
255 return; |
|
256 } |
|
257 |
|
258 CLbtTriggerConditionBase* condBase=trigEntry->GetCondition(); |
|
259 if(!condBase) |
|
260 { |
|
261 //CHECK HOW TO HANDLE THIS SCENARIO |
|
262 aIsFilterPresent = 0; |
|
263 return; |
|
264 } |
|
265 |
|
266 CLbtTriggerConditionArea* trigCond=(CLbtTriggerConditionArea*)condBase; |
|
267 CLbtGeoCircle* trigArea=static_cast<CLbtGeoCircle*>(trigCond->TriggerArea()); |
|
268 if( trigArea->Type() != CLbtGeoAreaBase::ECircle ) |
|
269 { |
|
270 // The area type is not the same. |
|
271 aIsFilterPresent++; |
|
272 aIsEntryRequested = EFalse; |
|
273 return; |
|
274 } |
|
275 |
|
276 CLbtGeoCircle* circArea=static_cast<CLbtGeoCircle*>(iArea); |
|
277 TCoordinate filterCenter=circArea->Center(); |
|
278 TCoordinate trigCenter=trigArea->Center(); |
|
279 TReal filterRadius=circArea->Radius(); |
|
280 TReal trigRadius=trigArea->Radius(); |
|
281 TReal32 distance; |
|
282 filterCenter.Distance(trigCenter,distance); |
|
283 |
|
284 /* If the distance between the trigger center and the filter center |
|
285 * is less than the radius of the filter circle |
|
286 * and if this distance + the radius of the trigger |
|
287 * is less than the radius of the filter |
|
288 * then the given trigger lies within the specified area |
|
289 * and will be returned back to the client |
|
290 */ |
|
291 if((distance<filterRadius) && ((distance+trigRadius)<=filterRadius)) |
|
292 { |
|
293 aIsFilterPresent++ ; |
|
294 aIsEntryRequested = ETrue; |
|
295 } |
|
296 else |
|
297 { |
|
298 aIsEntryRequested = EFalse; |
|
299 } |
|
300 } |
|
301 } |
|
302 |
|
303 void CLbtContainerAreaFilter::ProcessRectFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
304 { |
|
305 FUNC_ENTER("CLbtContainerAreaFilter::ProcessRectFilter"); |
|
306 // Add rectangular filtering here. |
|
307 if(aEntry != NULL) |
|
308 { |
|
309 CLbtTriggerEntry* trigEntry=aEntry->TriggerEntry(); |
|
310 CLbtGeoRect* rectArea=static_cast<CLbtGeoRect*>(iArea); |
|
311 TReal northLat,southLat,eastLong,westLong; |
|
312 rectArea->GetBorder(southLat,northLat,westLong,eastLong); |
|
313 CLbtExtendedTriggerInfo* contExtInfo = aEntry->ExtendedTriggerInfo(); |
|
314 CLbtExtendedTriggerInfo::TLbtTriggerRectArea trigArea=contExtInfo->TriggerReactangleArea(); |
|
315 if( trigArea.iTrigAreaNorthLat <= northLat && trigArea.iTrigAreaSouthLat >= southLat && |
|
316 trigArea.iTrigAreaEastLong <= eastLong && trigArea.iTrigAreaWestLong >= westLong ) |
|
317 { |
|
318 aIsFilterPresent++; |
|
319 aIsEntryRequested = ETrue; |
|
320 } |
|
321 } |
|
322 |
|
323 } |
|
324 |
|
325 void CLbtContainerAreaFilter::ProcessContFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
326 { |
|
327 FUNC_ENTER("CLbtContainerAreaFilter::ProcessContFilter"); |
|
328 CLbtExtendedTriggerInfo* contExtInfo=aEntry->ExtendedTriggerInfo(); |
|
329 TInt isFilterPresent = 0; |
|
330 TBool isEntryRequested = EFalse; |
|
331 TInt i; |
|
332 if(contExtInfo!=NULL) |
|
333 { |
|
334 if((isFilterPresent>0 && isEntryRequested && iHystRadiusArray.Count()>0) || (iHystRadiusArray.Count()>0 && isFilterPresent==0 )) |
|
335 { |
|
336 isFilterPresent++; |
|
337 isEntryRequested=EFalse; |
|
338 for(i=0;i<iHystRadiusArray.Count();i++) |
|
339 { |
|
340 if(contExtInfo->HysteresisRadius()==iHystRadiusArray[i]) |
|
341 { |
|
342 |
|
343 isEntryRequested=ETrue; |
|
344 } |
|
345 |
|
346 } |
|
347 } |
|
348 |
|
349 |
|
350 if((isFilterPresent>0 && isEntryRequested && iTriggerFiredArray.Count()>0) || (iTriggerFiredArray.Count()>0 && isFilterPresent==0 )) |
|
351 { |
|
352 isFilterPresent++; |
|
353 isEntryRequested=EFalse; |
|
354 for(i=0;i<iTriggerFiredArray.Count();i++) |
|
355 { |
|
356 if(contExtInfo->IsTriggerFired()==iTriggerFiredArray[i]) |
|
357 { |
|
358 isEntryRequested=ETrue; |
|
359 |
|
360 } |
|
361 } |
|
362 } |
|
363 |
|
364 if((isFilterPresent>0 && isEntryRequested && iSidArray.Count()>0) || (iSidArray.Count()>0 && isFilterPresent==0 )) |
|
365 { |
|
366 isFilterPresent++; |
|
367 isEntryRequested=EFalse; |
|
368 for(i=0;i<iSidArray.Count();i++) |
|
369 { |
|
370 if(contExtInfo->OwnerSid()==iSidArray[i]) |
|
371 { |
|
372 |
|
373 isEntryRequested=ETrue; |
|
374 } |
|
375 |
|
376 } |
|
377 } |
|
378 |
|
379 if((isFilterPresent>0 && isEntryRequested && iTriggerFireOnCreationArray.Count()>0) || (iTriggerFireOnCreationArray.Count()>0 && isFilterPresent==0 )) |
|
380 { |
|
381 isFilterPresent++; |
|
382 isEntryRequested=EFalse; |
|
383 for(i=0;i<iTriggerFireOnCreationArray.Count();i++) |
|
384 { |
|
385 if(contExtInfo->IsTriggerFireOnCreation()==iTriggerFireOnCreationArray[i]) |
|
386 { |
|
387 |
|
388 isEntryRequested=ETrue; |
|
389 } |
|
390 |
|
391 } |
|
392 } |
|
393 |
|
394 |
|
395 } |
|
396 |
|
397 // end of if(contExtInfo!=NULL) |
|
398 aIsFilterPresent = isFilterPresent; |
|
399 aIsEntryRequested = isEntryRequested; |
|
400 } |
|
401 void CLbtContainerAreaFilter::RetrieveFilterDataL() |
|
402 { |
|
403 FUNC_ENTER("CLbtContainerAreaFilter::RetrieveFilterDataL"); |
|
404 CLbtContainerFilter* contFilter = ContFilter(); |
|
405 CLbtTriggerFilterBase* trigFilter = TrigFilter(); |
|
406 CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*>(trigFilter); |
|
407 iArea = areaFilter->Area(); |
|
408 |
|
409 if(contFilter) |
|
410 { |
|
411 contFilter->GetSidArrayL(&iSidArray) ; |
|
412 contFilter->GetHystRadiusArrayL(&iHystRadiusArray); |
|
413 contFilter->GetRectAreaArrayL(&iTriggerRectAreaArray) ; |
|
414 contFilter->GetTriggerFiredArrayL(&iTriggerFiredArray) ; |
|
415 contFilter->GetTriggerFireOnCreationArrayL( &iTriggerFireOnCreationArray ); |
|
416 } |
|
417 |
|
418 } |
|
419 |
|
420 void CLbtContainerAreaFilter::CompareCells( CLbtGeoCell* aCellToBeMatched, CLbtGeoCell* aCellFilter, TInt& aIsFilterPresent,TBool& aIsEntryRequested ) |
|
421 { |
|
422 if(aCellToBeMatched->NetworkType() != aCellFilter->NetworkType()) |
|
423 { |
|
424 aIsFilterPresent++; |
|
425 aIsEntryRequested = EFalse; |
|
426 return ; |
|
427 } |
|
428 else |
|
429 { |
|
430 aIsFilterPresent++; |
|
431 TLex lex( aCellFilter->NetworkCountryCode() ); |
|
432 TUint netCountryCode; |
|
433 lex.Val( netCountryCode ); |
|
434 |
|
435 TLex lexTrig( aCellToBeMatched->NetworkCountryCode() ); |
|
436 TUint trigNetCountryCode; |
|
437 lexTrig.Val( trigNetCountryCode ); |
|
438 |
|
439 if(netCountryCode == 0 ) |
|
440 { |
|
441 aIsEntryRequested=ETrue; |
|
442 return; |
|
443 } |
|
444 else |
|
445 { |
|
446 if(netCountryCode != trigNetCountryCode) |
|
447 { |
|
448 aIsFilterPresent++; |
|
449 aIsEntryRequested = EFalse; |
|
450 return; |
|
451 } |
|
452 |
|
453 if(netCountryCode == trigNetCountryCode) |
|
454 { |
|
455 aIsEntryRequested = ETrue; |
|
456 aIsFilterPresent++; |
|
457 TLex idcode( aCellFilter->NetworkIdentityCode() ); |
|
458 TUint netIdCode; |
|
459 idcode.Val( netIdCode ); |
|
460 |
|
461 TLex trigIdcode( aCellToBeMatched->NetworkIdentityCode() ); |
|
462 TUint trigNetIdCode; |
|
463 trigIdcode.Val( trigNetIdCode ); |
|
464 if(netIdCode == 0 ) |
|
465 { |
|
466 aIsEntryRequested = ETrue; |
|
467 return; |
|
468 } |
|
469 else |
|
470 { |
|
471 if(netIdCode != trigNetIdCode) |
|
472 { |
|
473 aIsFilterPresent++; |
|
474 aIsEntryRequested = EFalse; |
|
475 return; |
|
476 } |
|
477 if(netIdCode == trigNetIdCode) |
|
478 { |
|
479 aIsFilterPresent++; |
|
480 aIsEntryRequested = EFalse; |
|
481 if(aCellFilter->LocationAreaCode() == 0) |
|
482 { |
|
483 aIsEntryRequested = ETrue; |
|
484 return; |
|
485 } |
|
486 else |
|
487 { |
|
488 if(aCellFilter->LocationAreaCode() != aCellToBeMatched->LocationAreaCode()) |
|
489 { |
|
490 aIsFilterPresent++; |
|
491 aIsEntryRequested = EFalse; |
|
492 return; |
|
493 } |
|
494 if(aCellFilter->LocationAreaCode() == aCellToBeMatched->LocationAreaCode()) |
|
495 { |
|
496 aIsFilterPresent++; |
|
497 aIsEntryRequested = ETrue; |
|
498 if(aCellFilter->CellId() == 0) |
|
499 { |
|
500 aIsEntryRequested = ETrue; |
|
501 return ; |
|
502 } |
|
503 else if(aCellFilter->CellId() != aCellToBeMatched->CellId()) |
|
504 { |
|
505 aIsFilterPresent++; |
|
506 aIsEntryRequested = EFalse; |
|
507 return ; |
|
508 } |
|
509 }// if(cellArea->LocationAreaCode() == trigArea->LocationAreaCode()) |
|
510 } // end of else if(cellArea->LocationAreaCode() == 0) |
|
511 }// end of if(netIdCode == trigNetIdCode) |
|
512 }// end of else if(netIdCode == 0 ) |
|
513 } //end of if(netCountryCode == trigNetCountryCode) |
|
514 }// end of else after if(netCountryCode == 0 ) |
|
515 }// end of if(trigArea->NetworkType() == cellArea->NetworkType()) |
|
516 } |
|
517 |
|
518 CLbtContainerAreaFilter::CLbtContainerAreaFilter() |
|
519 { |
|
520 |
|
521 } |
|
522 |
|
523 |
|
524 CLbtContainerAreaFilter::~CLbtContainerAreaFilter() |
|
525 { |
|
526 FUNC_ENTER("CLbtContainerAreaFilter::~CLbtContainerAreaFilter"); |
|
527 iHystRadiusArray.Close(); |
|
528 iTriggerRectAreaArray.Close(); |
|
529 iTriggerFiredArray.Close(); |
|
530 iSidArray.Close(); |
|
531 iTriggerFireOnCreationArray.Close(); |
|
532 |
|
533 } |
|
534 |
|
535 void CLbtContainerAreaFilter::ConstructL(CLbtTriggerFilterBase* aTrigFilter,CLbtContainerFilter* aContFilter) |
|
536 { |
|
537 FUNC_ENTER("CLbtContainerAreaFilter::ConstructL"); |
|
538 SetTrigFilter(aTrigFilter); |
|
539 SetContFilter(aContFilter); |
|
540 RetrieveFilterDataL(); |
|
541 } |
|
542 |