1 /*

     2 * Copyright (c) 2004 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:  Tracked Presence ID collection.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <CPEngTrackedPresenceIDs2.h>

    20 #include <CPEngTrackedPresenceID2.h>

    21 #include <MPEngPresenceAttrModel2.h>

    22 #include <E32Std.h>

    23 

    24 #include "CPEngTrackedPresenceIDCollection.h"

    25 #include "CPEngTrackedPresenceIDEntry.h"

    26 #include "CPEngTrackedPresenceIDEntryLookUp.h"

    27 #include "TPEngTrackedPresenceEntryFilter.h"

    28 

    29 

    30 // ============================ MEMBER FUNCTIONS ===============================

    31 

    32 // -----------------------------------------------------------------------------

    33 // CPEngTrackedPresenceIDCollection::NewL()

    34 // Two-phased constructor.

    35 // -----------------------------------------------------------------------------

    36 //

    37 CPEngTrackedPresenceIDCollection* CPEngTrackedPresenceIDCollection::NewL()

    38     {

    39     CPEngTrackedPresenceIDCollection* self = new ( ELeave ) CPEngTrackedPresenceIDCollection;

    40     CleanupStack::PushL( self );

    41     self->ConstructL();

    42     CleanupStack::Pop( self );

    43 

    44     return self;

    45     }

    46 

    47 

    48 // Destructor

    49 CPEngTrackedPresenceIDCollection::~CPEngTrackedPresenceIDCollection()

    50     {

    51     delete iInterface;

    52     delete iPresenceIdLookup;

    53     delete iEntryListFilter;

    54     // Ondra, remove all tracked Ids

    55     RemoveAllTrackedIds();

    56     }

    57 

    58 

    59 // -----------------------------------------------------------------------------

    60 // CPEngTrackedPresenceIDCollection::CPEngTrackedPresenceIDCollection

    61 // C++ default constructor can NOT contain any code, that

    62 // might leave.

    63 // -----------------------------------------------------------------------------

    64 //

    65 CPEngTrackedPresenceIDCollection::CPEngTrackedPresenceIDCollection()

    66     {

    67     }

    68 

    69 

    70 // -----------------------------------------------------------------------------

    71 // CPEngTrackedPresenceIDCollection::ConstructL()

    72 // Symbian OS constructor.

    73 // -----------------------------------------------------------------------------

    74 //

    75 void CPEngTrackedPresenceIDCollection::ConstructL()

    76     {

    77     iInterface = new ( ELeave ) CPEngTrackedPresenceIDs2( *this );

    78     iPresenceIdLookup = CPEngTrackedPresenceIDEntryLookUp::NewL();

    79     iEntryListFilter = new ( ELeave ) TPEngTrackedPresenceEntryFilter( iTrackedIDs,

    80                                                                        EIncludedToList );

    81     }

    82 

    83 

    84 // -----------------------------------------------------------------------------

    85 // CPEngTrackedPresenceIDCollection::Interface()

    86 // -----------------------------------------------------------------------------

    87 //

    88 CPEngTrackedPresenceIDs2& CPEngTrackedPresenceIDCollection::Interface()

    89     {

    90     return *iInterface;

    91     }

    92 

    93 

    94 // -----------------------------------------------------------------------------

    95 // CPEngTrackedPresenceIDCollection::TrackedPresenceIDsCount()

    96 // Tracked presence IDs.

    97 // -----------------------------------------------------------------------------

    98 //

    99 TInt CPEngTrackedPresenceIDCollection::TrackedPresenceIDsCount() const

   100     {

   101     return iTrackedIDs.Count();

   102     }

   103 

   104 

   105 // -----------------------------------------------------------------------------

   106 // CPEngTrackedPresenceIDCollection::FindTrackedPresenceID()

   107 // Tracked presence IDs.

   108 // -----------------------------------------------------------------------------

   109 //

   110 const CPEngTrackedPresenceIDEntry* CPEngTrackedPresenceIDCollection::FindTrackedPresenceID(

   111     const TDesC& aPresenceID ) const

   112     {

   113     TLinearOrder< CPEngTrackedPresenceIDEntry > order ( CPEngTrackedPresenceIDEntry::Compare );

   114     iPresenceIdLookup->SetLookupKey( aPresenceID );

   115     TInt index = iTrackedIDs.FindInOrder( iPresenceIdLookup, order );

   116     iPresenceIdLookup->Reset();

   117 

   118     const CPEngTrackedPresenceIDEntry* presenceID = NULL;

   119     if ( index != KErrNotFound )

   120         {

   121         presenceID = iTrackedIDs[ index ];

   122         }

   123 

   124     return presenceID;

   125     }

   126 

   127 

   128 // -----------------------------------------------------------------------------

   129 // CPEngTrackedPresenceIDCollection::TrackedPresenceID()

   130 // Tracked presence IDs.

   131 // -----------------------------------------------------------------------------

   132 //

   133 const CPEngTrackedPresenceIDEntry& CPEngTrackedPresenceIDCollection::TrackedPresenceID(

   134     TInt aIndex ) const

   135     {

   136     return *iTrackedIDs[ aIndex ];

   137     }

   138 

   139 

   140 // -----------------------------------------------------------------------------

   141 // CPEngTrackedPresenceIDCollection::NextTrackedPresenceID()

   142 // Tracked presence IDs.

   143 // -----------------------------------------------------------------------------

   144 //

   145 CPEngTrackedPresenceID2* CPEngTrackedPresenceIDCollection::NextTrackedPresenceID(

   146     TInt& aIterIx )

   147     {

   148     CPEngTrackedPresenceID2* idInterface = NULL;

   149 

   150     if ( iTrackedIDs.Count() > aIterIx )

   151         {

   152         idInterface = &iTrackedIDs[ aIterIx ]->Interface();

   153         aIterIx++;

   154         }

   155 

   156     return idInterface;

   157     }

   158 

   159 

   160 

   161 // -----------------------------------------------------------------------------

   162 // CPEngTrackedPresenceIDCollection::AddTrackedIdsL()

   163 // Tracked presence IDs.

   164 // -----------------------------------------------------------------------------

   165 //

   166 void CPEngTrackedPresenceIDCollection::AddTrackedIdsL( const MDesCArray& aPresenceIDs,

   167                                                        const TArray<TUint32>& aTypes )

   168     {

   169     __ASSERT_ALWAYS( aTypes.Count() > 0, User::Leave( KErrArgument ) );

   170 

   171 

   172     const TInt idCount = aPresenceIDs.MdcaCount();

   173     for ( TInt idIx = 0; idIx < idCount; idIx++ )

   174         {

   175         TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

   176         TLinearOrder< CPEngTrackedPresenceIDEntry > order

   177         ( CPEngTrackedPresenceIDEntry::Compare );

   178         TInt entryIx = KErrNotFound;

   179 

   180         iPresenceIdLookup->SetLookupKey( presenceID );

   181         TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

   182         iPresenceIdLookup->Reset();

   183 

   184         if ( entryExists == KErrNotFound )

   185             {

   186             CPEngTrackedPresenceIDEntry* entry = CPEngTrackedPresenceIDEntry::NewLC(

   187                                                      presenceID,

   188                                                      aTypes,

   189                                                      ENotIncludedToList );

   190             User::LeaveIfError( iTrackedIDs.Insert( entry, entryIx ) );

   191             CleanupStack::Pop( entry );

   192             }

   193         else

   194             {

   195             CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

   196             entry->AddTrackedAttributesL( aTypes );

   197             }

   198         }

   199     }

   200 

   201 

   202 // -----------------------------------------------------------------------------

   203 // CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

   204 // Tracked presence IDs.

   205 // -----------------------------------------------------------------------------

   206 //

   207 void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const MDesCArray& aPresenceIDs )

   208     {

   209     const TInt idCount = aPresenceIDs.MdcaCount();

   210     for ( TInt idIx = 0; idIx < idCount; idIx++ )

   211         {

   212         TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

   213         TLinearOrder< CPEngTrackedPresenceIDEntry > order

   214         ( CPEngTrackedPresenceIDEntry::Compare );

   215         TInt entryIx = KErrNotFound;

   216 

   217         iPresenceIdLookup->SetLookupKey( presenceID );

   218         TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

   219         iPresenceIdLookup->Reset();

   220 

   221         if ( entryExists == KErrNone )

   222             {

   223             delete iTrackedIDs[ entryIx ];

   224             iTrackedIDs.Remove( entryIx );

   225             }

   226         }

   227     }

   228 

   229 

   230 // -----------------------------------------------------------------------------

   231 // CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

   232 // Tracked presence IDs.

   233 // -----------------------------------------------------------------------------

   234 //

   235 void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const TArray<TUint32>& aTypes )

   236     {

   237     //go from end to start ==> remove is safe

   238     for ( TInt entryIx = ( iTrackedIDs.Count() - 1 ) ; entryIx >= 0; entryIx-- )

   239         {

   240         CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

   241         entry->RemoveTrackedAttributes( aTypes );

   242         if ( !entry->AttributesTracked() )

   243             {

   244             delete entry;

   245             iTrackedIDs.Remove( entryIx );

   246             }

   247         }

   248     }

   249 

   250 

   251 // -----------------------------------------------------------------------------

   252 // CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

   253 // Tracked presence IDs.

   254 // -----------------------------------------------------------------------------

   255 //

   256 void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const MDesCArray& aPresenceIDs,

   257                                                          const TArray<TUint32>& aTypes )

   258     {

   259     const TInt idCount = aPresenceIDs.MdcaCount();

   260     for ( TInt idIx = 0; idIx < idCount; idIx++ )

   261         {

   262         TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

   263         TLinearOrder< CPEngTrackedPresenceIDEntry > order

   264         ( CPEngTrackedPresenceIDEntry::Compare );

   265         TInt entryIx = KErrNotFound;

   266 

   267         iPresenceIdLookup->SetLookupKey( presenceID );

   268         TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

   269         iPresenceIdLookup->Reset();

   270 

   271         if ( entryExists == KErrNone )

   272             {

   273             CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

   274             entry->RemoveTrackedAttributes( aTypes );

   275             if ( !entry->AttributesTracked() )

   276                 {

   277                 delete entry;

   278                 iTrackedIDs.Remove( entryIx );

   279                 }

   280             }

   281         }

   282     }

   283 

   284 

   285 // -----------------------------------------------------------------------------

   286 // CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

   287 // Tracked presence IDs.

   288 // -----------------------------------------------------------------------------

   289 //

   290 void CPEngTrackedPresenceIDCollection::RemoveAllTrackedIds()

   291     {

   292     iTrackedIDs.ResetAndDestroy();

   293     }

   294 

   295 

   296 

   297 // -----------------------------------------------------------------------------

   298 // CPEngTrackedPresenceIDCollection::ResetPresenceChangeMarks()

   299 // List of changed presences

   300 // -----------------------------------------------------------------------------

   301 //

   302 void CPEngTrackedPresenceIDCollection::ResetPresenceChangeMarks()

   303     {

   304     const TInt entryCount = iTrackedIDs.Count();

   305     for ( TInt entryIx = 0; entryIx < entryCount; entryIx++ )

   306         {

   307         CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

   308         entry->ResetChangeMarks();

   309         }

   310     }

   311 

   312 

   313 

   314 // -----------------------------------------------------------------------------

   315 // CPEngTrackedPresenceIDCollection::MarkPresenceChange()

   316 // List of changed presences

   317 // -----------------------------------------------------------------------------

   318 //

   319 void CPEngTrackedPresenceIDCollection::MarkPresenceChange( const TDesC& aPresenceID )

   320     {

   321     TLinearOrder< CPEngTrackedPresenceIDEntry > order

   322     ( CPEngTrackedPresenceIDEntry::Compare );

   323     TInt entryIx = KErrNotFound;

   324 

   325     iPresenceIdLookup->SetLookupKey( aPresenceID );

   326     TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

   327     iPresenceIdLookup->Reset();

   328 

   329     if ( entryExists == KErrNone )

   330         {

   331         iTrackedIDs[ entryIx ]->MarkAllAttributesChanged();

   332         }

   333     }

   334 

   335 

   336 // -----------------------------------------------------------------------------

   337 // CPEngTrackedPresenceIDCollection::NextChangeMarkedPresenceID()

   338 // List of changed presences

   339 // -----------------------------------------------------------------------------

   340 //

   341 CPEngTrackedPresenceID2* CPEngTrackedPresenceIDCollection::NextChangeMarkedPresenceID(

   342     TInt& aIterIx )

   343 

   344     {

   345     CPEngTrackedPresenceID2* idInterface = NULL;

   346 

   347     while ( aIterIx < iTrackedIDs.Count()  )

   348         {

   349         CPEngTrackedPresenceIDEntry* trackedId = iTrackedIDs[ aIterIx ];

   350 

   351         if ( trackedId->AttributesChanged() )

   352             {

   353             idInterface = &trackedId->Interface();

   354             aIterIx++;

   355             break;

   356             }

   357 

   358         aIterIx++;

   359         }

   360 

   361     return idInterface;

   362     }

   363 

   364 

   365 

   366 

   367 // -----------------------------------------------------------------------------

   368 // CPEngTrackedPresenceIDCollection::ResetFilteredList()

   369 // Filtered list.

   370 // -----------------------------------------------------------------------------

   371 //

   372 

   373 void CPEngTrackedPresenceIDCollection::ResetFilteredList()

   374     {

   375     const TInt entryCount = iTrackedIDs.Count();

   376     for ( TInt entryIx = 0; entryIx < entryCount; entryIx++ )

   377         {

   378         CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

   379         entry->SetFilterFlag( ENotIncludedToList );

   380         }

   381     }

   382 

   383 

   384 // -----------------------------------------------------------------------------

   385 // CPEngTrackedPresenceIDCollection::IncludeToFilteredList()

   386 // Filtered list.

   387 // -----------------------------------------------------------------------------

   388 //

   389 void CPEngTrackedPresenceIDCollection::IncludeToFilteredList( TInt aIndex )

   390     {

   391     iTrackedIDs[ aIndex ]->SetFilterFlag( EIncludedToList );

   392     }

   393 

   394 

   395 // -----------------------------------------------------------------------------

   396 // CPEngTrackedPresenceIDCollection::FilteredList()

   397 // Filtered list.

   398 // -----------------------------------------------------------------------------

   399 //

   400 const MDesCArray& CPEngTrackedPresenceIDCollection::FilteredList() const

   401     {

   402     return *iEntryListFilter;

   403     }

   404 

   405 

   406 // -----------------------------------------------------------------------------

   407 // CPEngTrackedPresenceIDCollection::ResetTrackedEntriesIterators()

   408 // -----------------------------------------------------------------------------

   409 //

   410 void CPEngTrackedPresenceIDCollection::ResetTrackedEntriesIterators()

   411     {

   412     const TInt trackedIDsCount = iTrackedIDs.Count();

   413     for ( TInt ii = 0; ii < trackedIDsCount; ii++ )

   414         {

   415         CPEngTrackedPresenceID2& idInterface = iTrackedIDs[ ii ]->Interface();

   416         idInterface.ResetTrackedIterator();

   417         idInterface.ResetChangedIterator();

   418         }

   419     }

   420 

   421 

   422 

   423 

   424 //  End of File

   425 

   426 

   427