wvuing/wvuieng/EngInc/Ccaengine.h
changeset 0 094583676ce7
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wvuing/wvuieng/EngInc/Ccaengine.h	Thu Dec 17 08:41:52 2009 +0200
@@ -0,0 +1,449 @@
+/*
+* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  This interface is used by UI to access network services i.e.
+*                sending messages and joining to groups e.g. This class is
+*                also used to get different interfaces to the services
+*                offered by the CCAEngine.dll.
+*
+*/
+
+
+#ifndef CCAENGINE_H
+#define CCAENGINE_H
+
+//  INCLUDES
+#include    "PublicEngineDefinitions.h"
+#include    "MCASettingsObserver.h"
+#include    "MCASearchObserverInterface.h"
+#include    "MCABackgroundTask.h"
+#include    "MCABackgroundObserver.h"
+#include    "MCAMessageUtils.h"
+#include 	"MCABackgroundTaskObserver.h"
+
+#include    <e32base.h>
+#include    <ImpsClient.h>
+#include    <ImpsFundamental.h>
+#include    <PEngWVServices2.h>
+
+// FORWARD DECLARATIONS
+class   CCAGroupManager;
+class   MCAPresence;
+class   CCASearchManager;
+class   CCABlockingManager;
+class   CCASettingsManager;
+class   CCAInviteManager;
+class   CCAPartialSuccessData;
+class	CCARequestMapper;
+class   MCAError;
+class   MCASearchInterface;
+class   MCAPresence;
+class   MCAInvite;
+class   MCABlocking;
+class   MCASettings;
+class	MCAImpsImClient;
+class	MCAImpsGroupClient;
+class	MCAImpsFundClient;
+class   MCAStoredGroups;
+class   MCAGroupManagerInterface;
+class	MCABackgroundInterface;
+class	CCAStorageObserver;
+class	TCALoggerMessageFactory;
+class	MCALoggerHeadersInterface;
+class   CCAImageLoader;
+class   CCAContactListModel;
+
+class   MCAChatInterface;
+class   CCAChatContainer;
+class   CCAMessageHandler;
+class   CCAMessageCreator;
+
+class   CPEngNWSessionSlotID2;
+class   MCAAccessInterface;
+class   CCAAccessManager;
+class   MCAContactListModel;
+
+class 	MCABackgroundTaskObserver;
+struct SServerPrefers;
+
+/**
+ *  CCAEngine provides one of the interfaces to the engine.
+ *  This interface is used by UI to access network services i.e.
+ *  sending messages and joining to groups e.g. This class is
+ *  also used to get different interfaces to the services
+ *  offered by the CCAEngine.dll.
+ *
+ *  @lib CAEngine.lib
+ *  @since 1.2
+ */
+class CCAEngine : public CBase,
+            public MCABackgroundTask,
+            public MCABackgroundObserver,
+            public MCAMessageUtils,
+            private MImpsErrorHandler2,
+            private MCASettingsObserver,
+            private MCASearchObserverInterface
+    {
+    public: // Structures and enumerations
+
+    public:  // Constructors and destructor
+
+        /**
+         * Two-phased constructor.
+         * @param aAppUid is the application's UID.
+         */
+        IMPORT_C static CCAEngine* NewL( TUid aAppUid );
+
+        /**
+         * Destructor.
+         */
+        IMPORT_C virtual ~CCAEngine();
+
+    public: // Settings related functions
+
+        /**
+         * Gets internal settings handling interface.
+         * @return Pointer to internal settings handler.
+         */
+        IMPORT_C MCASettings* GetInternalSettingsInterface() const;
+
+    public: // Search related functions
+
+        /**
+         * Gets search handling interface.
+         * @return Pointer to the search handler.
+         */
+        IMPORT_C MCASearchInterface* GetSearchInterface() const;
+
+    public: // Invite related functions
+
+        /**
+         * Get invite related functions.
+         * @return Pointer to the invite interface.
+         */
+        IMPORT_C MCAInvite* GetInvitationInterface() const;
+
+    public: // Blocking related functions
+
+        /**
+         * Get blocking handling interface.
+         * @return Pointer to the blocking interface.
+         */
+        IMPORT_C MCABlocking* GetBlockingInterface() const;
+
+    public: // Imps fund client accessor
+
+        /**
+         * Get Imps fundamental client
+         * @return Pointer to the Imps fundamental client
+         */
+        IMPORT_C MCAImpsFundClient* GetFundClientInterface() const;
+
+    public: // Access interface
+
+        /**
+         * Get Imps access interface
+         */
+        IMPORT_C MCAAccessInterface* GetAccessInterface() const;
+
+    public:
+
+        /**
+         * Get interface for contact list model
+         */
+        IMPORT_C MCAContactListModel& ContactListModel() const;
+
+
+        /**
+         * Get interface for message handling.
+         */
+        IMPORT_C MCAChatInterface& ChatInterface() const;
+
+        /**
+         * Get interface to message utils like messagecreator etc.
+         */
+        IMPORT_C const MCAMessageUtils& MessageUtils() const;
+
+    public: // Database interfaces
+
+        /**
+         * Get group interface.
+         * @return Pointer to the group interface.
+         */
+        IMPORT_C MCAGroupManagerInterface* GetGroupInterface() const;
+
+
+    public: // Background specific functions
+
+        /**
+        * Get Background interface.
+        * @return Pointer to the Background interface.
+        */
+        IMPORT_C MCABackgroundInterface* BackgroundInterface() const;
+
+    public: // From MCABackgroundTask
+
+        /**
+         * Handler for the background task event
+         * @see MCABackgroundTask
+         */
+        void HandleBackgroundTaskL( TInt aSubTask );
+
+    public: // From MCABackgroundObserver
+        /**
+         * Observers background task events
+         * @see MCABackgroudObserver::HandleBackgroundEvent
+         */
+        void HandleBackgroundEvent(
+            MCABackgroundInterface::TCABackgroundTasks aEventSource,
+            MCABackgroundInterface::TCABackgroundStatus aStatus,
+            TInt aSubTaskNumber,
+            TInt aLeaveCode
+        );
+
+    private: // From MCAMessageUtils
+
+        /**
+         * @see MCAMessageUtils
+         */
+        MCAMessageCreator& MessageCreator() const;
+
+        /**
+         * @see MCAMessageUtils
+         */
+        MCAMessageErrorInformer& MessageErrorInformer() const;
+
+        /**
+         * @see MCAMessageUtils
+         */
+        MCAContentProcessor& ImageScaler() const;
+
+        /**
+         * @see MCAMessageUtils
+         */
+        MCABufferMemoryHandler& MemoryHandler() const;
+
+    public: // New functions
+
+        /**
+         * Handles engine logic in login/logout events.
+         * @param aLoggedIn If new state is online.
+         * @param aNewUSerID specifies the new wv id.
+         * @param aServerPrefers. Some preferred states like enable/disable
+         *                        grantlist etc.
+         */
+        IMPORT_C void HandleNetworkStateChangeL(
+            TNetworkState  aState,
+            TPEngWVCspServicesTree2* aServicesSupported,
+            const SServerPrefers& aServerPrefers,
+            CPEngNWSessionSlotID2* aSessionSlotID = NULL );
+
+        /**
+         * Returns the latest operations partially successful error codes.
+         * @return Holds an array of error codes.
+         */
+        IMPORT_C const RPointerArray<MCAError>* PartialSuccessData() const;
+
+        /**
+         * Checks CAEngine if its ready for shutdown.
+         * @return ETrue if ready.
+         */
+        IMPORT_C TBool ReadyForShutdown();
+
+        /**
+         * Cancels pending requests in request mapper.
+         */
+        IMPORT_C void CancelAllRequests();
+
+        /**
+         *	Get logger headers interface
+         *	@return pointer to logger header access.
+         */
+        IMPORT_C MCALoggerHeadersInterface* GetLoggerHeadersInterface();
+
+        /**
+         * Finalize the engine construction. It's done in two phases
+         * for performance reasons. We need to delay the initialization
+         * of IMPS Engine until after the login query, to appear fast.
+         */
+        IMPORT_C void FinalizeEngineConstructionL();
+
+        /**
+         * Check if engine is fully finalized
+         * This should be checked before accessing the interfaces
+         */
+        IMPORT_C TBool IsFinalized();
+
+        /**
+         * Register to receive notifications related to
+         * start and completetion of background task
+         * @param MCABackGroundTaskObserver- object
+         */
+        IMPORT_C void RegisterBackGroundTaskObserver( MCABackGroundTaskObserver* aObserver );
+
+        /**
+         * UnRegister from receiving notifications related to
+         * start and completetion of backgroundtask
+         */
+        IMPORT_C void UnRegisterBackGroundTaskObserver( MCABackGroundTaskObserver* aObserver );
+
+        /**
+         * To know whether Background task has started
+         * @return TBool
+         */
+        IMPORT_C TBool IsBackgroundTaskPending();
+
+
+
+        IMPORT_C void ResetLoggers();
+
+
+    private: // Functions from MImpsErrorHandler
+
+        /**
+         * From MImpsErrorHandler.
+         * @see MImpsErrorHandler::HandleErrorL
+         */
+        void HandleErrorL( TInt aStatus,
+                           TInt aOpId,
+                           const TDesC* aDescription,
+                           const CImpsDetailed* aDetailedRes,
+                           TImpsCspIdentifier& aCspId );
+
+    private: // From MCASettingsObserver
+
+        /**
+         * Handles setting changes.
+         * @param aChangedSettingEnum specifies the changed setting.
+         */
+        void HandleSettingsChangeL( TInt aChangedSettingEnum );
+
+    private: // from MCASearchObserverInterface
+
+        /**
+         * @see MCASearchObserverInterface::HandleSearchError
+         */
+        void HandleSearchError( TInt aErrorCode );
+
+        /**
+         * @see MCASearchObserverInterface::HandleSearchFinished
+         */
+        void HandleSearchFinished();
+
+    private: // new methods
+
+
+        /**
+         * Notifies the observers of group synchronisation
+         * @param aCompleted - ETrue if group synchro is complete else EFalse
+         */
+        //void NotifyGroupSyncObservers(MCABackgroundTaskObserver::TCAGroupSyncEventType aCompleted)	;
+        /**
+         * Prepares and starts the synchronizing process if search
+         * service available.
+         * @param aServicesSupported The supported imps services
+         */
+        void SynchronizeGroupsL( TPEngWVCspServicesTree2* aServicesSupported );
+
+        /**
+         * Handler for finished searches
+         */
+        void DoHandleSearchFinishedL();
+
+        /**
+         * Synchronize the storage with the groups created by the user
+         * (in this server). This method is asynchronous, although there
+         * is a small delay when calling the initial search.
+         */
+        void StartSynchronizeGroupsL();
+
+        /**
+         * Stop the synchronization of groups created by the user
+         * (in this server). Use this to force stop the StartSynchronizeGroupsL.
+         */
+        void StopSynchronizeGroupsL();
+
+    private:
+
+        /**
+         * By default Symbian OS constructor is private.
+         */
+        void ConstructL();
+
+        /**
+         * C++ default constructor.
+         * @see CCAEngine::NewL.
+         */
+        CCAEngine( TUid aAppUid );
+
+    private:    // Data
+
+        // Owns (unless otherwise noted)///////////////////////////////////////
+        MCAPresence*            iPresenceManager;
+        CCASettingsManager*	    iSettingsManager;
+        MCAImpsImClient*        iImpsImServer;
+        MCAImpsGroupClient*     iImpsGroupServer;
+        MCAImpsFundClient*	    iImpsFundAPI;
+        CCASearchManager*       iSearchManager;
+        CCABlockingManager*	    iBlockingManager;
+        CCAInviteManager*       iInviteManager;
+        CCARequestMapper*	    iRequestMapper;
+        CCAStorageObserver*		iStorageObserver;
+        CCAGroupManager*        iGroupManager;
+        CCAAccessManager*       iAccessManager;
+
+        CCAChatContainer*       iChatContainer;
+        CCAMessageHandler*      iMessageHandler;
+        CCAMessageCreator*      iMessageCreator;
+        CCAImageLoader*         iImageLoader;
+        CCAContactListModel*    iContactListModel;
+        // ////////////////////////////////////////////////////////////////////
+
+        // not owned (from Storage Manager)
+        MCAStoredGroups*        iStoredGroups;
+
+        // Application UID received from the Application UI
+        TUid iAppUid;
+
+        // Owns
+        CCAPartialSuccessData* iPartialSuccessData;
+
+        // group synchronizing
+        TInt                    iSearchResults;
+        HBufC*                  iLoggedUserId;   // owns
+        CSearchPairs*           iPairs;   // owns
+        CImpsSearchRequest*     iRequest; // owns
+
+        // protection from bogus network state changes, finite state machine
+        // logic is inside HandleNetworkStateChangeL
+        TNetworkState iState;
+
+        // This is passed to MCALoggerReadInterface when instance called.
+        // Pointer to T-class is used so that we do not have to include
+        // header of TCALoggerMessageFactory in this header file.
+        TCALoggerMessageFactory* iLoggerMessageFactory;
+
+        //Interface to access  logger headers. Owns
+        MCALoggerHeadersInterface* iLoggerHeadersInterface;
+
+        // ETrue when the engine has been fully constructed
+        TBool iFullyConstructed;
+
+        TBool iGroupSynchronizing;
+
+
+    };
+
+#endif      // CCAEngine_H
+
+// End of File