/*

* 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