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:  Presence attribute transaction environment.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <E32Base.h>

    20 #include <bamdesca.h>

    21 #include "CPEngPresenceAttrTransactionEnv.h"

    22 #include "CPEngPresenceNotificationHandler.h"

    23 #include "MPEngPresenceAttrManager.h"

    24 #include "MPEngPresenceAttrModel2.h"

    25 #include "MPEngPresenceAdvancedAttrModel2.h"

    26 #include "MPEngXMLParser.h"

    27 #include "RObjectArray.h"

    28 #include "CPEngSessionSlotId.h"

    29 #include "PEngAddressUtils.h"

    30 #include "PEngAttrModelHelper.h"

    31 

    32 #include "CPEngSubscribedUsers.h"

    33 #include "CPEngSubscribedUser.h"

    34 #include "CPEngOrphanNotificationQue.h"

    35 #include "PresenceDebugPrint.h"

    36 

    37 

    38 //CONSTANTS

    39 const TInt KQuedOrphanNotifications = 10;

    40 

    41 

    42 

    43 // ============================ MEMBER FUNCTIONS ===============================

    44 

    45 // -----------------------------------------------------------------------------

    46 // CPEngPresenceAttrTransactionEnv::NewL

    47 // Two-phased constructor.

    48 // -----------------------------------------------------------------------------

    49 //

    50 CPEngPresenceAttrTransactionEnv* CPEngPresenceAttrTransactionEnv::NewL(

    51     const CPEngSessionSlotId& aSlotId,

    52     MPEngPresenceAttrManager& aAttrMan )

    53     {

    54     CPEngPresenceAttrTransactionEnv* self = new ( ELeave ) CPEngPresenceAttrTransactionEnv

    55     ( aAttrMan );

    56 

    57     CleanupClosePushL( *self ); //Reference counted object

    58     self->ConstructL( aSlotId );

    59     CleanupStack::Pop(); //self

    60 

    61     return self;

    62     }

    63 

    64 

    65 // Destructor

    66 CPEngPresenceAttrTransactionEnv::~CPEngPresenceAttrTransactionEnv()

    67     {

    68     PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::~CPEngPresenceAttrTransactionEnv()" ) );

    69     delete iSubscribedUsers;

    70     delete iOrphanNotifications;

    71     iSessTracingAttribs.ResetAndDestroy();

    72     delete iDomain;

    73 

    74     if ( iAttributeManagerOwned )

    75         {

    76         iAttributeManager.Close();

    77         }

    78     }

    79 

    80 

    81 

    82 // -----------------------------------------------------------------------------

    83 // CPEngPresenceAttrTransactionEnv::CPEngPresenceAttrTransactionEnv

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

    85 // might leave.

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

    87 //

    88 CPEngPresenceAttrTransactionEnv::CPEngPresenceAttrTransactionEnv( MPEngPresenceAttrManager& aAttrMan )

    89         : iAttributeManager( aAttrMan ),

    90         iAttributeManagerOwned( EFalse )

    91     {

    92     PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::CPEngPresenceAttrTransactionEnv()" ) );

    93     }

    94 

    95 

    96 // -----------------------------------------------------------------------------

    97 // CPEngPresenceAttrTransactionEnv::ConstructL

    98 // Symbian 2nd phase constructor can leave.

    99 // -----------------------------------------------------------------------------

   100 //

   101 void CPEngPresenceAttrTransactionEnv::ConstructL( const CPEngSessionSlotId& aSlotId )

   102     {

   103     CPEngSessionSlotObject::ConstructL( aSlotId );

   104 

   105     //resolve transaction domain

   106     iDomain = PEngAddressUtils::WVDomain( aSlotId.UserId() ).AllocL();

   107 

   108     iSubscribedUsers = CPEngSubscribedUsers::NewL();

   109     iOrphanNotifications = CPEngOrphanNotificationQue::NewL( KQuedOrphanNotifications );

   110 

   111     iAttributeManagerOwned = ETrue;

   112     }

   113 

   114 

   115 

   116 // -----------------------------------------------------------------------------

   117 // CPEngPresenceAttrTransactionEnv::Close()

   118 // -----------------------------------------------------------------------------

   119 //

   120 void CPEngPresenceAttrTransactionEnv::Close()

   121     {

   122     CPEngSessionSlotObject::Close();

   123     }

   124 

   125 // -----------------------------------------------------------------------------

   126 // CPEngPresenceAttrTransactionEnv::AddSubscriptionL()

   127 // -----------------------------------------------------------------------------

   128 //

   129 void CPEngPresenceAttrTransactionEnv::AddSubscriptionL( const TDesC& aPresenceID )

   130 

   131     {

   132     PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::AddSubscriptionL() [%S]" ),

   133              &aPresenceID );

   134 

   135     __ASSERT_ALWAYS( aPresenceID.Length() > 0, User::Leave( KErrArgument ) );

   136 

   137 

   138     //Locate existing user subscription entry or create a new one

   139     const TInt uIndex = iSubscribedUsers->FindSubscribedUser( aPresenceID );

   140     if ( uIndex == KErrNotFound )

   141         {

   142         PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::AddSubscriptionL() - adding new" ) );

   143 

   144         CPEngSubscribedUser* userDetails = CPEngSubscribedUser::NewLC( aPresenceID );

   145         userDetails->AddSubscription(); //increase subscription count

   146         iSubscribedUsers->AddSubscribedUserL( userDetails );

   147         CleanupStack::Pop(); //userDetails

   148 

   149         DoInitializeAttributesToCacheL( aPresenceID );

   150 

   151         //New subscription added

   152         //Process possibly pending orphan presence notifications.

   153         DoProcessAndStoreOrphanNotificationsL();

   154         }

   155 

   156     else

   157         {

   158         CPEngSubscribedUser& userDetails = iSubscribedUsers->SubscribedUser( uIndex );

   159 

   160         PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::AddSubscriptionL() - Increasing existing, count %d" ),

   161                  userDetails.SubscriptionsCount() );

   162 

   163 

   164         userDetails.AddSubscription(); //increase subscription count

   165         }

   166     }

   167 

   168 

   169 

   170 // -----------------------------------------------------------------------------

   171 // CPEngPresenceAttrTransactionEnv::RemoveSubscriptionL()

   172 // -----------------------------------------------------------------------------

   173 //

   174 void CPEngPresenceAttrTransactionEnv::RemoveSubscriptionL( const TDesC& aPresenceID )

   175     {

   176     PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::RemoveSubscriptionL() [%S]" ),

   177              &aPresenceID );

   178 

   179 

   180     if ( aPresenceID.Length() == 0 )

   181         {

   182         return;

   183         }

   184 

   185 

   186     const TInt uIndex = iSubscribedUsers->FindSubscribedUser( aPresenceID );

   187     if ( uIndex != KErrNotFound )

   188         {

   189         CPEngSubscribedUser& userDetails = iSubscribedUsers->SubscribedUser( uIndex );

   190         userDetails.RemoveSubscription();

   191 

   192         PENG_DP( D_PENG_LIT( "CPEngPresenceAttrTransactionEnv::RemoveSubscription() - Subscription removed, Subscriptions left %d" ),

   193                  userDetails.SubscriptionsCount() );

   194 

   195         if ( userDetails.SubscriptionsCount() == 0 )

   196             {

   197             //no active subscription anymore for this user

   198             //==> all stored subscribed attributes can be deleted from storage

   199             DoClearAttributesFromCacheL( aPresenceID );

   200 

   201             //and actual subscription entry also

   202             iSubscribedUsers->DeleteSubscribeUser( uIndex );

   203             }

   204         }

   205     }

   206 

   207 

   208 

   209 // -----------------------------------------------------------------------------

   210 // CPEngPresenceAttrTransactionEnv::SubscribedPresenceIDs()

   211 // -----------------------------------------------------------------------------

   212 //

   213 const MDesCArray& CPEngPresenceAttrTransactionEnv::SubscribedPresenceIDs() const

   214     {

   215     return *iSubscribedUsers;

   216     }

   217 

   218 

   219 

   220 // -----------------------------------------------------------------------------

   221 // CPEngPresenceAttrTransactionEnv::SetSessionTracingAttributesL()

   222 // -----------------------------------------------------------------------------

   223 //

   224 void CPEngPresenceAttrTransactionEnv::SetSessionTracingAttributesL(

   225     RPointerArray< MPEngPresenceAttrModel2 >& aAttributeModels  )

   226     {

   227     __ASSERT_DEBUG( !PEngAttrModelHelper::HasDuplicateTypes( aAttributeModels ),

   228                     User::Leave( KErrAlreadyExists ) );

   229 

   230     //Replace internal model array with given ones

   231     iSessTracingAttribs.ResetAndDestroy();

   232     PEngAttrModelHelper::MoveModelsL( aAttributeModels, iSessTracingAttribs );

   233     }

   234 

   235 

   236 

   237 // -----------------------------------------------------------------------------

   238 // CPEngPresenceAttrTransactionEnv::UpdateSessionTracingAttributesL()

   239 // -----------------------------------------------------------------------------

   240 //

   241 void CPEngPresenceAttrTransactionEnv::UpdateSessionTracingAttributesL(

   242     RPointerArray< MPEngPresenceAttrModel2 >& aAttributeModels )

   243     {

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

   245     for ( TInt sourceIx = ( aAttributeModels.Count() - 1 ); sourceIx >= 0; sourceIx-- )

   246         {

   247         MPEngPresenceAttrModel2* sourceModel = aAttributeModels [ sourceIx ];

   248 

   249         const TInt tracedCount = iSessTracingAttribs.Count();

   250         for ( TInt tracedIx = 0; tracedIx < tracedCount; tracedIx++ )

   251             {

   252             MPEngPresenceAttrModel2* tracedModel = iSessTracingAttribs[ tracedIx ];

   253             if ( ( sourceModel->Type() == tracedModel->Type() ) &&

   254                  ( sourceModel->PresenceID() == tracedModel->PresenceID() ) )

   255                 {

   256                 //replace traced model with new one instance

   257                 //and remove new instance from source array

   258                 delete iSessTracingAttribs[ tracedIx ];

   259                 iSessTracingAttribs[ tracedIx ] = sourceModel;

   260                 aAttributeModels.Remove( sourceIx );

   261                 break;

   262                 }

   263             }

   264         }

   265     }

   266 

   267 

   268 

   269 // -----------------------------------------------------------------------------

   270 // CPEngPresenceAttrTransactionEnv::HandleNetworkSessionStateChangeL()

   271 // -----------------------------------------------------------------------------

   272 //

   273 void CPEngPresenceAttrTransactionEnv::HandleNetworkSessionStateChangeL(

   274     TBool aSessionOpen )

   275     {

   276     const TInt count = iSessTracingAttribs.Count();

   277     for ( TInt ii = 0; ii < count; ii++ )

   278         {

   279         MPEngPresenceAttrModel2* model = iSessTracingAttribs[ ii ];

   280         model->Advanced()->HandleNetworkSessionStateChangeL( aSessionOpen );

   281         }

   282 

   283     iAttributeManager.ForceStoreBatchL( iSessTracingAttribs );

   284     }

   285 

   286 

   287 

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

   289 // CPEngPresenceAttrTransactionEnv::QueOrphanNotificationL()

   290 // -----------------------------------------------------------------------------

   291 //

   292 void CPEngPresenceAttrTransactionEnv::QueOrphanNotificationL(

   293     const TDesC8& aPresenceBlock )

   294     {

   295     iOrphanNotifications->AddToQueL( aPresenceBlock );

   296     }

   297 

   298 

   299 // -----------------------------------------------------------------------------

   300 // CPEngPresenceAttrTransactionEnv::ProcessOrphanNotificationsL()

   301 // -----------------------------------------------------------------------------

   302 //

   303 void CPEngPresenceAttrTransactionEnv::ProcessOrphanNotificationsL(

   304     RPointerArray< MPEngPresenceAttrModel2 >& aModels )

   305     {

   306     MPEngXMLParser* xmlParser = CreateXMLParserLC();

   307     const TDesC8* notification = iOrphanNotifications->GetFirst();

   308 

   309     while ( notification )

   310         {

   311         TBool notificationMached =

   312             CPEngPresenceNotificationHandler::ProcessNotifyBlockL( *notification,

   313                                                                    *iDomain,

   314                                                                    *iSubscribedUsers,

   315                                                                    iAttributeManager,

   316                                                                    *xmlParser,

   317                                                                    aModels );

   318 

   319         //If notification matched to subscribed user => discard the cache entry

   320         //Otherwise proceed to next cache entry

   321         if ( notificationMached )

   322             {

   323             notification = iOrphanNotifications->DeleteCurrentAndGetNext();

   324             }

   325         else

   326             {

   327             notification = iOrphanNotifications->GetNext();

   328             }

   329         }

   330 

   331     CleanupStack::PopAndDestroy(); //xmlParser

   332     }

   333 

   334 

   335 // -----------------------------------------------------------------------------

   336 // CPEngPresenceAttrTransactionEnv::DoInitializeAttributesToCacheL()

   337 // -----------------------------------------------------------------------------

   338 //

   339 void CPEngPresenceAttrTransactionEnv::DoInitializeAttributesToCacheL(

   340     const TDesC& aPresenceID )

   341     {

   342     TArray<TUint32> attributes = iAttributeManager.KnownAttributeTypes();

   343     const TInt count = attributes.Count();

   344 

   345     RObjectArray<MPEngPresenceAttrModel2> models;

   346     CleanupClosePushL( models );

   347 

   348     for ( TInt ii = 0; ii < count; ii++ )

   349         {

   350         TUint32 attribute = attributes[ ii ];

   351         MPEngPresenceAttrModel2* model = NULL;

   352         TInt err = iAttributeManager.LoadAttributeLC( model,

   353                                                       aPresenceID,

   354                                                       attribute,

   355                                                       EPEngStorableModel );

   356         if ( err == KErrNotFound )

   357             {

   358             models.AppendL( model );

   359             CleanupStack::Pop(); //model

   360             }

   361         else

   362             {

   363             CleanupStack::PopAndDestroy(); //model

   364             }

   365         }

   366 

   367     iAttributeManager.ForceStoreBatchL( models );

   368     CleanupStack::PopAndDestroy(); //models

   369     }

   370 

   371 

   372 // -----------------------------------------------------------------------------

   373 // CPEngPresenceAttrTransactionEnv::DoClearAttributesFromCacheL()

   374 // -----------------------------------------------------------------------------

   375 //

   376 void CPEngPresenceAttrTransactionEnv::DoClearAttributesFromCacheL(

   377     const TDesC& aPresenceID )

   378     {

   379     TArray<TUint32> attributes = iAttributeManager.KnownAttributeTypes();

   380     const TInt count = attributes.Count();

   381 

   382     RObjectArray<MPEngPresenceAttrModel2> models;

   383     CleanupClosePushL( models );

   384 

   385     for ( TInt ii = 0; ii < count; ii++ )

   386         {

   387         TUint32 attribute = attributes[ ii ];

   388         MPEngPresenceAttrModel2* model = NULL;

   389         TInt err = iAttributeManager.LoadAttributeLC( model,

   390                                                       aPresenceID,

   391                                                       attribute,

   392                                                       EPEngStorableModel );

   393         if ( err == KErrNone )

   394             {

   395             models.AppendL( model );

   396             CleanupStack::Pop(); //model

   397             }

   398         else

   399             {

   400             CleanupStack::PopAndDestroy(); //model

   401             }

   402         }

   403 

   404     iAttributeManager.ForceRemoveFromStoreBatchL( models );

   405     CleanupStack::PopAndDestroy(); //models

   406     }

   407 

   408 

   409 

   410 

   411 // -----------------------------------------------------------------------------

   412 // CPEngPresenceAttrTransactionEnv::DoProcessAndStoreOrphanNotificationsL()

   413 // -----------------------------------------------------------------------------

   414 //

   415 void CPEngPresenceAttrTransactionEnv::DoProcessAndStoreOrphanNotificationsL()

   416     {

   417     RObjectArray<MPEngPresenceAttrModel2> models;

   418     CleanupClosePushL( models );

   419 

   420     ProcessOrphanNotificationsL( models );

   421 

   422     iAttributeManager.ForceStoreBatchL( models );

   423     CleanupStack::PopAndDestroy(); //models

   424     }

   425 

   426 

   427 //  End of File

   428