/*
* Copyright (c) 2004 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:  Event notifier implementation base
*
*/

#ifndef __CIMPSCONNUIPRESEVENTNOTIFIERIMPBASE_H
#define __CIMPSCONNUIPRESEVENTNOTIFIERIMPBASE_H

//  INCLUDES
#include <E32Base.h>
#include <impspresenceconnectionuiconstsng.h>
#include <PEngPresenceEngineConsts2.h>
#include "RGenericObserverArray.h"


// FORWARD DECLARATIONS
class MIMPSConnUiPresenceEventObserver;
class CIMPSConnUiPresEventNotifier;
class CIMPSConnUiPresEventNotifierImpBase;
class CPEngNWSessionSlotID2;

// CLASS DECLARATION
/**
 * CIMPSConnUiPresEventNotifierImpBase.
 * Implements the event notifier
 * base features.
 *
 * @since 2.1
 */
NONSHARABLE_CLASS( CIMPSConnUiPresEventNotifierImpBase ) :
        public CBase,
        public MGenObserverNotifyMediator < MIMPSConnUiPresenceEventObserver,
        TIMPSPresenceServiceEvent >
    {
public: //destructor.

    /**
     * Destructor.
     * Concrete implementation object can be
     * destroyed using base class.
     */
    ~CIMPSConnUiPresEventNotifierImpBase();

protected: //constructor.

    /**
     * C++ constructor.
     * Takes a reference to implemented interface.
     * This interface is givent to notified observers.
     *
     * @param aInterface The implemented interface.
     * No ownership taken.
     */
    CIMPSConnUiPresEventNotifierImpBase( CIMPSConnUiPresEventNotifier& aInterface );


public:  //Implementation methods for public APIs

    /**
     * Implements notify start.
     *
     * Implements notify start by making sanity checks
     * for internal state and calling the virtual template
     * method DoStartL() to issue real notification.
     *
     * StartL() traps internally the DoStartL() call and
     * if the DoStartL() leaves, the partly constructed
     * notification service is stopped by calling DoStop().
     *
     * Starting fails if:
     * - already started
     * - no observers registered
     * @since 2.1
     */
    void StartL();


    /**
     * Implements notify stop.
     *
     * If notifier isn't running, does nothing.
     * If notifier is running, calls the virtual
     * template method DoStop() to stop the
     * real notify service.
     *
     * @since 2.1
     */
    void Stop();


    /**
     * Implements add observer.
     *
     * @since 2.1
     * @param aObserver The observer to add.
     */
    void AddObserverL( MIMPSConnUiPresenceEventObserver* aObserver );


    /**
     * Implements remove observer.
     *
     * @since 2.1
     * @param aObserver The observer to remove.
     * @return KErrNone if observer was found, else KErrNotFound.
     */
    TInt RemoveObserver( MIMPSConnUiPresenceEventObserver* aObserver );


    /**
     * Virtual template method to implement service status get.
     *
     * @since 2.1
     * @return Current service status as application level enumeration.
     */
    virtual const CPEngNWSessionSlotID2* AppServiceStatusL(
        TIMPSConnectionClient aClient ) = 0;



protected:  // Template methods for derived implementations

    /**
     * Virtual template method to implement
     * real notify start.
     *
     * This method implementation must
     * requested notification from
     * all qiven PEC presence events.
     *
     * @see CIMPSConnUiPresEventNotifierImp
     * @see CIMPSConnUiClntFilteredEventNotifierImp
     * @since 2.1
     *
     * @param aEvents The events where from to
     * get notifications
     */
    virtual void DoStartL( const TArray<TPEngNWSessionSlotEvent>& aEvents ) = 0;


    /**
     * Virtual template method to implement
     * real notify stop.
     *
     * This method implementation must
     * cancel any previous notification request.
     *
     * @see CIMPSConnUiPresEventNotifierImp
     * @see CIMPSConnUiClntFilteredEventNotifierImp
     * @since 2.1
     */
    virtual void DoStop() = 0;



protected:  // Helper methods for derived implementations

    /**
     * This must be called in derived notifier
     * implementations at the beginning of their
     * destructor.
     *
     * Sets the dying flag on (prevents further starting the
     * notifier and error and event notifying) Stops the notifier
     * if running.
     *
     * @since 2.1
     */
    void Dying();


    /**
     * Notifies registered observers from given presence event.
     * If notifier isn't running,
     * ignores given presence event.
     *
     * @since 2.1
     * @param aEvent The event to notify.
     */
    void NotifyObserversFromEvent( const CPEngNWSessionSlotID2& aSessionSlotID,
                                   TIMPSConnectionClient aClient,
                                   TIMPSPresenceServiceEvent aEvent );


    /**
     * Notifies registered observers from given error.
     *
     * If notifier isn't running, ignores given error.
     *
     * Before notifying the error,
     * the notifier.is stopped. (Client can restart
     * the notifier in the error callback.)
     *
     * @since 2.1
     * @param aError The error to report.
     */
    void StopAndNotifyObserversFromError( TInt aError );



private: //Notify mediators from MGenObserverNotifyMediator

    /**
     * Implements the observer notification.
     *
     * @since 2.1
     * @param The observer to notify.
     * @param aNotifyData The structure holding notify data.
     */
    void MediateNotifyL( MIMPSConnUiPresenceEventObserver& aObserverToNotify,
                         TIMPSPresenceServiceEvent& aNotifyData );


    /**
     * Observer notification from error.
     *
     * @since 2.1
     * @param aObserverToNotify The notified observer which leaved.
     * @param aLeaveError The propagated leave code.
     */
    void MediateNotifyError( MIMPSConnUiPresenceEventObserver& aObserverToNotify,
                             TInt aLeaveError );

    /**
     * Observer notification from error.
     *
     * @since 2.1
     * @param aObserverToNotify The notified observer which leaved.
     * @param aLeaveError The propagated leave code.
     */
    void MediateError( MIMPSConnUiPresenceEventObserver& aObserverToNotify,
                       TInt aError );

private: //Data

    ///< Reference to owning interface, interface not owned
    CIMPSConnUiPresEventNotifier&                      iInterface;

    ///< Observer array, array owned, observers not
    RGenericObserverArray < MIMPSConnUiPresenceEventObserver,
    TIMPSPresenceServiceEvent > iObserverArray;


    CPEngNWSessionSlotID2* iSessionSlotID;
    TIMPSConnectionClient  iClient;
    ///< Flags describing the notifier state, owned
    ///< Flag contents are either EFalse or ETrue
    TInt8   iStarted;
    TInt8   iDying;
    TInt8   iReserved1;
    TInt8   iReserved2;

    };

#endif      //__CIMPSCONNUIPRESEVENTNOTIFIERIMPBASE_H
//  End of File