diff -r 000000000000 -r 094583676ce7 wvuing/wvuieng/EngInc/Ccaengine.h --- /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 +#include +#include +#include + +// 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* 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