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:  Presence connection host

    15  *

    16 */

    17 

    18 #ifndef CPSCHOSTIMP_H

    19 #define CPSCHOSTIMP_H

    20 

    21 #include <e32base.h>

    22 #include <ximpprotocolconnectionhost.h>

    23 #include <ximpcontext.h>

    24 

    25 #include "ximpapiobjbase.h"

    26 #include "ximphost.h"

    27 #include "ximpoperationdefs.h"

    28 #include "ximprequestidbuilder.h"

    29 

    30 

    31 class CXIMPOperationBase;

    32 class CXIMPEventManager;

    33 class MXIMPObjectFactory;

    34 class CXIMPObjectFactoryImp;

    35 class CXIMPPscContext;

    36 class MPresenceDataCache;

    37 class CPresenceDataCache;

    38 class CXIMPContextStateEventImp;

    39 class CPeriodic;

    40 class MXIMPProtocolConnection;

    41 class CProtocolPresenceAuthorizationDataHostImp;

    42 class MProtocolPresenceAuthorizationDataHost;

    43 class CProtocolPresencePublishingDataHostImp;

    44 class MProtocolPresencePublishingDataHost;

    45 class CProtocolPresenceWatchingDataHostImp;

    46 class MProtocolPresenceWatchingDataHost;

    47 class CProtocolPresentityGroupsDataHostImp;

    48 class MProtocolPresentityGroupsDataHost;

    49 class CXIMPRestrictedCollectionImp;

    50 class CXIMPProtocolRequestCompleteEventImp;

    51 class MProtocolPresenceDataHost;

    52 class CProtocolPresenceDataHostImp;

    53 class MProtocolDataHost;

    54 

    55 

    56 /**

    57  * Presence connection host.

    58  *

    59  * @lib ximpprocessor.lib

    60  * @since S60 v3.2

    61  */

    62 class CXIMPHost : public CXIMPApiObjBase,

    63                  public MXIMPProtocolConnectionHost,

    64                  public MXIMPHost

    65 

    66     {

    67 public:

    68     /** The class ID. */

    69     enum { KClassId = XIMPIMP_CLSID_CXIMPPSCHOST };

    70 

    71 public:

    72 

    73     IMPORT_C static CXIMPHost* NewLC( MXIMPProtocolConnection& aConnection, TInt32 aProtocolUid );

    74 

    75     /**

    76      * Mark a reference to this object.

    77      */

    78     void Open();

    79 

    80     /**

    81      * Remove a reference to this object.

    82      * Once all references are removed, the class destroys itself.

    83      */

    84     void Close();

    85 

    86 protected:

    87 

    88     /**

    89      * Reference counted. Use Close to remove a reference, and Open to open it.

    90      * Can't be CObject-derived, since already derives from another C-class.

    91      */

    92     virtual ~CXIMPHost();

    93 

    94     CXIMPHost( MXIMPProtocolConnection& aConnection, TInt32 aProtocolUid );

    95     void ConstructL();

    96 

    97 public: // From MXIMPBase

    98 

    99     /**

   100      * Implementation of MXIMPBase interface methods

   101      * @see MXIMPBase

   102      */

   103     XIMPIMP_DECLARE_IF_BASE_METHODS

   104 

   105 

   106 public: // From MXIMPProtocolConnectionHost

   107 

   108     void HandleRequestCompleted( TXIMPRequestId aReqId, TInt aResultCode );

   109     void HandleRequestCompleted( TXIMPRequestId aReqId, MXIMPStatus* aResult );

   110     void HandleRequestCompleted( TXIMPRequestId aReqId,

   111                                  MXIMPStatus* aResult,

   112                                  MXIMPBase* aParameter );

   113     TXIMPRequestId HandleConnectionTerminated( MXIMPStatus* aReason );

   114     MXIMPObjectFactory& ObjectFactory();

   115     MProtocolPresenceDataHost& ProtocolPresenceDataHost();

   116     

   117 

   118    

   119     void RegisterObserverL(

   120             MXIMPProtocolConnectionHostObserver& aObserver,

   121             const TArray<TInt32>* aEventFilter = NULL );

   122     void UnregisterConnectionHostObserver(

   123             MXIMPProtocolConnectionHostObserver& aObserver );

   124 

   125 

   126 public: // MXIMPHost

   127 

   128     MXIMPProtocolConnection& GetConnection() const;

   129 

   130     void AddEventL( CXIMPApiEventBase& aEvent, MXIMPPscContext* aContext  );

   131     void ActivateEventL( CXIMPApiEventBase& aEvent, MXIMPPscContext* aContext );

   132 

   133     void UnregisterSession( CXIMPPscContext* aContext );

   134 

   135     void FakeCompleteRequest( TXIMPRequestId aReqId, TInt aResult );

   136     void HandleAdaptationRequestCompleted( TXIMPRequestId aReqId, TInt aResult );

   137     void HandleSessionMgmtRequestCompleted( TXIMPRequestId aReqId, TInt aResult );

   138     void HandleInternalRequestCompleted( TXIMPRequestId aReqId, TInt aResult );

   139 

   140     CProtocolPresenceDataHostImp& PresenceDataAccess();

   141     

   142 

   143     // get corresponding protocol host from the array of hosts

   144     TAny* GetProtocolHost(TInt aInterfaceId) ;

   145     

   146 /*    CPresenceDataCache& DataAccess();

   147     CProtocolPresenceAuthorizationDataHostImp& AuthorizationDataAccess();

   148     CProtocolPresencePublishingDataHostImp& PublishingDataAccess();

   149     CProtocolPresenceWatchingDataHostImp& WatchingDataAccess();

   150     CProtocolPresentityGroupsDataHostImp& GroupsDataAccess();

   151 */

   152     void AddNewOperationL( CXIMPOperationBase& aOperation );

   153     TXIMPRequestId AddNewOperationL( CXIMPOperationBase* aOperation );

   154 

   155     void ForcedTeardownL();

   156 

   157     void StartCleanerTimer();

   158     

   159     TXIMPRequestId AddNewOperationL( 

   160                 TInt aOperation, MXIMPBase* aParam, MXIMPBase* aParam2 = NULL );    

   161     TXIMPRequestId AddNewOperationL( 

   162                 TInt aOperation, CXIMPRestrictedObjectCollectionImp* aParams );

   163     

   164     TInt32 ProtocolUID( );

   165     

   166     // to set the specific prtocol hosts

   167     void SetProtocolHosts();

   168 

   169 public: // New functions

   170 

   171     void AddEventL( CXIMPApiEventBase& aEvent, CXIMPPscContext* aContext  );

   172     void ActivateEventL( CXIMPApiEventBase& aEvent, CXIMPPscContext* aContext );

   173 

   174 

   175     void RegisterSessionL( CXIMPPscContext* aContext );

   176 

   177 private:

   178 

   179     /**

   180      * Delete old operation and try to launch processing.

   181      */

   182     void StartProcessing();

   183 

   184     /**

   185      * Activate next operation for processing and start processing.

   186      */

   187     void ActivateProcessing();

   188 

   189     /**

   190      * Helper for completing the request, to avoid cyclical

   191      * call chain from StartProcessingL to HandleRequestCompleted and back.

   192      * @param aResult The error code

   193      * @see HandleRequestCompleted

   194      */

   195     void CompleteRequest( TXIMPRequestId aReqId );

   196 

   197     /**

   198      * Callback method for process starting.

   199      */

   200     static TInt StartProcessCallback( TAny *aInstance );

   201 

   202     /**

   203      * Leaving version of Callback method for process starting.

   204      */

   205     void DoStartProcessCallback();

   206 

   207     /**

   208      * Callback method for request complete.

   209      */

   210     static TInt CompleteRequestCallback( TAny *aInstance );

   211     static TInt CompleteAdaptationRequestCallback( TAny* aInstance );

   212     static TInt CompleteSessionMgmtRequestCallback( TAny* aInstance );

   213     static TInt CompleteInternalRequestCallback( TAny* aInstance );

   214 

   215     /**

   216      * Leaving version of Callback method for request complete.

   217      */

   218     void DoCompleteRequestCallback();

   219     void DoCompleteAdaptationRequestCallback();

   220     void DoCompleteSessionMgmtRequestCallback();

   221     void DoCompleteInternalRequestCallback();

   222 

   223     /**

   224      * Callback for timer cleaner

   225      * @see TCallBack

   226      */

   227     static TInt CleanerCallback( TAny* aMyself );

   228 

   229     /**

   230      * Actual callback called from CleanerCallback.

   231      */

   232     void DoCleanerCallback();

   233 

   234     /**

   235      * Leaving version of cleaner timer callback.

   236      */

   237     void DoCleanerCallbackL();

   238     

   239     /**

   240      * This panics if active operation is not found for requestid.

   241      */

   242     CXIMPOperationBase& OperationForRequestId( TXIMPRequestId aReqId );

   243 

   244     TXIMPRequestId AddNewOperationL( NXIMPOps::TXIMPOpTypes aOpType );

   245     

   246      /**

   247      * This is to load all the protocol hosts 

   248      */

   249     void LoadDataHostArrayL() ;

   250     

   251 private: // data

   252 

   253     /**

   254      * iConnection

   255      */

   256     MXIMPProtocolConnection& iConnection;

   257 

   258     /**

   259      * Uid for protocol to use for request id builder

   260      */

   261     TInt32 iProtocolUid;

   262     

   263     /**

   264      * Reference counter

   265      */

   266     TInt iReferences;

   267 

   268     /**

   269      * State identifier

   270      */

   271      TBool iProcessing;

   272 

   273     /**

   274      * Container for the operations. Owns the operations.

   275      * Own.

   276      */

   277     RXIMPObjOwningPtrArray< CXIMPOperationBase > iOperations;

   278 

   279     TBool iRunFromContextActivated;

   280     CXIMPOperationBase* iCurrentOperation;

   281 

   282     // not owned

   283 

   284     CXIMPEventManager* iEventManager;

   285 

   286 

   287     /**

   288      * Container for session datas that are registered to this

   289      * host.

   290      * Shared ownership. Cleanup for items must be done with close method. Not delete.

   291      */

   292     RPointerArray< CXIMPPscContext > iRegSessions;

   293 

   294     /**

   295      * Internal state of the host

   296      */

   297     NXIMPHost::THostStates iState;

   298 

   299     /**

   300      * Timer for clean operation creation.

   301      */

   302     CPeriodic* iCleanerTimer;

   303 

   304     /**

   305      * Object factory.

   306      */

   307     CXIMPObjectFactoryImp*  iObjFactory;

   308 

   309     /**

   310      * Data cache

   311      */

   312 //    CPresenceDataCache* iDataCache;

   313 

   314     /**

   315      * Data hosts

   316      */

   317      

   318     CProtocolPresenceDataHostImp* iPresenceDataHost;

   319     

   320     /**

   321      * array to hold data hosts

   322      */

   323     CArrayFixFlat<MProtocolDataHost*>* iDataHostArray;

   324     

   325 /*    CProtocolPresenceAuthorizationDataHostImp* iAuthDataHost;

   326     CProtocolPresencePublishingDataHostImp* iPublishingDataHost;

   327     CProtocolPresenceWatchingDataHostImp* iWatchingDataHost;

   328     CProtocolPresentityGroupsDataHostImp* iGroupsDataHost;

   329 */

   330     /**

   331      * Operation index for host-originated operations

   332      * (currently only reconnect operation)

   333      */

   334     TInt iHostOriginatedOpIndex;

   335 

   336     /**

   337      * Active object for async calls.

   338      */

   339     //CAsyncCallBack* iCallBack;

   340     enum

   341         {

   342         ECompleteRequestCallback = 0,

   343         ECompleteAdaptationRequestCallback,

   344         ECompleteSessionMgmtRequestCallback,

   345         ECompleteInternalRequestCallback,

   346         EStartProcessCallback

   347         };

   348     RPointerArray< CAsyncCallBack > iCallBack;

   349 

   350     /**

   351      *

   352      */

   353     TInt iAdaptationOperationIndex;

   354 

   355 

   356     /**

   357      * Builder for TXIMPRequestIds. Owned.

   358      */

   359     TXIMPRequestIdBuilder iReqIdBuilder;

   360     

   361     /**

   362      * Observers for adaptation requests.

   363      */

   364     RPointerArray< MXIMPProtocolConnectionHostObserver > iConnectionHostObservers;

   365     

   366     

   367     /**

   368      * Adaptation request complete event.

   369      */

   370     CXIMPProtocolRequestCompleteEventImp* iAdaptationReqCompleteEvent;

   371     

   372     /**

   373      * Forced tear down flag.

   374     */

   375     

   376     TBool iForcedTearDown;

   377     };

   378 

   379 

   380 #endif // CPSCHOST_H

   381