1 /*

     2 * Copyright (c) 2006 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 COperationSubscribeOwnPresence

    15  *

    16 */

    17 

    18 

    19 #include <ximpprotocolconnection.h>

    20 #include <protocolpresencepublishing.h>

    21 #include <protocolpresencefeatures.h>

    22 

    23 #include "operationsubscribeownpresence.h"

    24 #include "presenceinfofilterimp.h"

    25 #include "ximpobjecthelpers.h"

    26 #include "documentutils.h"

    27 #include "presencedatacacheimp.h"

    28 #include "ximppanics.h"

    29 #include "operationsynthesisesubscriptionevent.h"

    30 #include "ximphost.h"

    31 #include "ximpstatusimp.h"

    32 #include "ximppsccontextimp.h"

    33 #include "protocolpresencedatahostimp.h"

    34 

    35 #include "ximptrace.h"

    36 // ============================ MEMBER FUNCTIONS =============================

    37 

    38 // ---------------------------------------------------------------------------

    39 // COperationSubscribeOwnPresence::COperationSubscribeOwnPresence()

    40 // ---------------------------------------------------------------------------

    41 //

    42 EXPORT_C COperationSubscribeOwnPresence::COperationSubscribeOwnPresence()

    43     {

    44     }

    45 

    46 

    47 // ---------------------------------------------------------------------------

    48 // COperationSubscribeOwnPresence::~COperationSubscribeOwnPresence()

    49 // ---------------------------------------------------------------------------

    50 //

    51 COperationSubscribeOwnPresence::~COperationSubscribeOwnPresence()

    52     {

    53     delete iPif;

    54     delete iMergedPif;

    55     if( iOwnPresence )

    56         {

    57         iOwnPresence->Close();

    58         }    

    59     }

    60 

    61 // ---------------------------------------------------------------------------

    62 // COperationSubscribeOwnPresence::ConstructL()

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

    64 //

    65 void COperationSubscribeOwnPresence::ConstructL( const TDesC8& aParamPck )

    66     {

    67     iPif = CPresenceInfoFilterImp::NewL();

    68     TXIMPObjectPacker< CPresenceInfoFilterImp >::UnPackL( *iPif,

    69             aParamPck );

    70     }

    71 

    72 

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

    74 // COperationSubscribeOwnPresence::ProcessL()

    75 // ---------------------------------------------------------------------------

    76 //

    77 void COperationSubscribeOwnPresence::ProcessL()

    78     {

    79     TRACE(_L("COperationSubscribeOwnPresence::ProcessL()" ) );

    80     CXIMPOperationBase::ProcessL();

    81 

    82     COwnPresenceSubscriptionItem& ownPresence = 

    83         iMyHost->PresenceDataAccess().PresenceDataCache().OwnPresenceSubscriptionItemLC();

    84     CleanupStack::Pop(); // ownPresence    

    85     iOwnPresence = &ownPresence;

    86 

    87     iSubscriptionStatus = iOwnPresence->SubscriptionStatus( iContext );

    88 

    89     MProtocolPresencePublishing& publishing = iMyHost->GetConnection().ProtocolPresenceFeatures().PresencePublishing();

    90 

    91     switch( iSubscriptionStatus )

    92         {

    93         case COwnPresenceSubscriptionItem::ENotSubscribedAtAll:

    94             {

    95             // Do subscribe

    96             iMergedPif = TXIMPObjectCloner< CPresenceInfoFilterImp >::CloneL( *iPif );

    97             publishing.DoSubscribeOwnPresenceL( *iMergedPif, iReqId );

    98             break;

    99             }

   100         case COwnPresenceSubscriptionItem::ESubscribedForOtherCtxOnly:

   101             {

   102             // Check aggregate and if needed.. update subscription

   103             iMergedPif = DocumentUtils::InfoFilterUnionL( iOwnPresence->SubscriptionPif(), *iPif );

   104             if( iMergedPif->Contains( *iPif ) )

   105                 {

   106                 publishing.DoUpdateOwnPresenceSubscriptionPifL( *iMergedPif, iReqId );

   107                 }

   108             else

   109                 {

   110                 iMyHost->FakeCompleteRequest( iReqId, KErrNone );

   111                 }

   112             break;

   113             }

   114             

   115         case COwnPresenceSubscriptionItem::ESubscribedForCtxOnly:

   116         case COwnPresenceSubscriptionItem::ESubscribedForCtxAndOthers:

   117             {

   118             CPresenceInfoFilterImp* oldPif = 

   119                     iContext->PresenceInfoFilter( MXIMPPscContext::EOwnPresenceFilter );

   120             CPresenceInfoFilterImp& oldMergedPif = iOwnPresence->SubscriptionPif();

   121             TBool fake = ETrue;

   122             TBool makeUnion( EFalse );

   123             if( !oldPif )

   124                 {

   125                 TRACE(_L("COperationSubscribeOwnPresence::ProcessL() no old pif" ) );

   126                 makeUnion = ETrue;

   127                 }

   128             else if ( *oldPif != *iPif ) 

   129                 {

   130                 makeUnion = ETrue;

   131                 }

   132             if( makeUnion )

   133                 {

   134                 iDoNotForce = ETrue;

   135                 CPresenceInfoFilterImp* withoutPif = 

   136                             iOwnPresence->CollectSubscriptionPifWithoutCtxL( iContext );

   137                 CleanupStack::PushL( withoutPif );

   138                 iMergedPif = DocumentUtils::InfoFilterUnionL( *withoutPif, *iPif );

   139                 CleanupStack::PopAndDestroy( withoutPif );

   140                 if( iMergedPif->Contains( oldMergedPif ) )

   141                     {

   142                     fake = EFalse;

   143                     publishing.DoUpdateOwnPresenceSubscriptionPifL( *iMergedPif, iReqId );

   144                     }

   145                 }

   146             else

   147                 {

   148                 iMergedPif = TXIMPObjectCloner< CPresenceInfoFilterImp >::CloneL( oldMergedPif );

   149                 }

   150                 

   151             if( fake )

   152                 {

   153                 iMyHost->FakeCompleteRequest( iReqId, KErrNone );

   154                 }

   155             break;

   156             }

   157         XIMP_DEFAULT_CASE_UNSUPPORTED( NXIMPPrivPanic::EInvalidSubscriptionStatus );

   158         }

   159     }

   160 

   161 

   162 // ---------------------------------------------------------------------------

   163 // COperationSubscribeOwnPresence::RequestCompleted()

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

   165 //

   166 void COperationSubscribeOwnPresence::RequestCompletedL()

   167     {

   168     TRACE(_L("COperationSubscribeOwnPresence::RequestCompletedL()" ) );

   169     CXIMPOperationBase::RequestCompletedL();

   170 

   171     if( iStatusObj->ResultCode() == KErrNone )

   172         {

   173         iContext->SetPresenceInfoFilterL( MXIMPPscContext::EOwnPresenceFilter,

   174                 iPif, NULL );

   175         iPif = NULL;

   176         iOwnPresence->SetSubscriptionPif( iMergedPif );

   177         iMergedPif = NULL;

   178 

   179         switch( iSubscriptionStatus )

   180             {

   181             case COwnPresenceSubscriptionItem::ENotSubscribedAtAll:

   182             case COwnPresenceSubscriptionItem::ESubscribedForOtherCtxOnly:

   183                 {

   184                 iOwnPresence->AddSubscriberL( iContext );

   185                 break;

   186                 }

   187             case COwnPresenceSubscriptionItem::ESubscribedForCtxOnly:

   188             case COwnPresenceSubscriptionItem::ESubscribedForCtxAndOthers:

   189                 {

   190                 break;

   191                 }

   192 

   193             XIMP_DEFAULT_CASE_UNSUPPORTED( NXIMPPrivPanic::EInvalidSubscriptionStatus );

   194             }

   195         

   196         SynthesiseEventL();

   197         }     

   198     }

   199 

   200 

   201 // ---------------------------------------------------------------------------

   202 // COperationSubscribeOwnPresence::Type()

   203 // ---------------------------------------------------------------------------

   204 //

   205 TInt 

   206     COperationSubscribeOwnPresence::Type() const

   207     {

   208     return NPresenceOps::EPrSubscribeOwnPresence;

   209     }

   210 

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

   212 // COperationSubscribeOwnPresence::SynthesiseEventL()

   213 // ---------------------------------------------------------------------------

   214 //

   215 void COperationSubscribeOwnPresence::SynthesiseEventL()

   216     {

   217     TBool force = 

   218     ( iSubscriptionStatus == COwnPresenceSubscriptionItem::ESubscribedForCtxOnly ||

   219       iSubscriptionStatus == COwnPresenceSubscriptionItem::ESubscribedForCtxAndOthers ) ? ETrue : EFalse;

   220     

   221     COperationSynthesiseSubscriptionEvent* synthOp = 

   222             new ( ELeave ) COperationSynthesiseSubscriptionEvent( 

   223                              COperationSynthesiseSubscriptionEvent::EOwnPresence, force && !iDoNotForce );

   224     CleanupStack::PushL( synthOp );

   225     synthOp->BaseConstructL( TXIMPRequestId(), iContext );        

   226     iMyHost->AddNewOperationL( *synthOp );

   227     CleanupStack::Pop( synthOp );    

   228     }

   229 

   230 

   231 

   232 // End of file