/*

* Copyright (c) 2002-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:    Header declaration

*

*/

#ifndef SEN_PROVIDER_H

#define SEN_PROVIDER_H

//  INCLUDES

#include <ecom/ecom.h>

#include <e32std.h>   // for RCriticalSection

#include <MSenServiceDescription.h>

#include "senwsdescription.h"

#include <SenFacet.h>

#include "senidentifier.h" // internal Utils\inc

#include "msenprovider.h" // internal Framework\inc

// FORWARD DECLARE

class CSenLocalRequest;

// CLASS DECLARATION

/**

* Class for delivering SOAP request to Serene and response back.

* Sub-classing actual Service Providers have to implement MSenProvider

* interface.

*

*/       

class CSenProvider : public CBase, public MSenProvider

    {

    public: // Constructors and destructor

            /**

            * Two-phased constructor.

        */

        static CSenProvider* NewL(const TDesC8& aMatch);

        static CSenProvider* NewL();

        /**

        * Function:    ~CSenProvider

        *

        * Description: Destroy the object

        */

        virtual ~CSenProvider();

        // From MSenHostlet:

        /** 

        * Default implementation returns the ECOM cue as endpoint of this local provider.

        * @return ECOM cue of this plug-in implementation

        */

        inline virtual TPtrC8 Endpoint() const;

        /**

    	* Method provides the default implementation of adding facets in the SD after 

    	* checking the  default values of the provider properties (exposed, shareable, 

    	* complete client message etc). Each overriden default facet value is added

    	* to the service description (SD).

        *

        * @param aSD is the service description into which all the facets of this

        * hostlet (local service provider) will be added. 

        *

        * Method provides means of "auto-configuration" for service session creation.

        * The sessions themself can read properties of the provider from the altered

        * XML service description. This way, provider deployment does not need to be 

        * followed by explicit Service Management API calls (configuration) to add 

        * these facet.

    	*/

        inline virtual void DescribeServiceL(CSenWSDescription& aSD);

        /**

        * This default, inline version returns EFalse. Any service exposed to outside world should

        * override to return ETrue instead. That would cause inline method 

        * InitServiceSession to add corresponding facet to the session.

        * @see MSenProvider interface

        */

        inline virtual TBool Exposed() const;

        /**

        * This default, inline version version returns EFalse. Sharable, sub-classing providers need 

        * to override this to return ETrue instead, if they allow multiple service consumers to have

        * queued access to the ServiceL() of the same provider instance.

        * @see MSenProvider interface

        */

        inline virtual TBool Sharable() const;

        /**

        * This default, inline version version returns EFalse. Providers, which wish to receive

        * complete messages (with header information) need to override this to return ETrue instead.

        * @see MSenProvider interface

        */

        inline virtual TBool CompleteClientMessages() const;

        /**

        * This default, inline version version returns EFalse. Providers, which have slow construction

        * mechanism should make this return ETrue, to make WSF Core Service Manager to pre-load them

        * after that (Symbian server) process is created and sensessions.xml database is being loaded.

        * @see MSenProvider interface

        */

        inline virtual TBool LoadOnStartup() const;

        /**

        * This default, inline version version returns ETrue. Providers, which wish to permit

        * un-thread-safe access to their ServiceL need to make this return EFalse instead.

        * @see MSenProvider interface

        */

        inline virtual TBool Threadsafe() const;

        /**

        * This default, inline version version returns EFalse. Providers, which allow themselves

        * to be re-cycled (reused) need to make this return EFalse. 

        * @see MSenProvider interface

        */

        inline virtual TBool Reinitializable() const;

        /**

        * This default, inline version version returns EFalse. Providers, which want themselves

        * to be left on background as long as main thread (Core Service Manager) is alive, need

        * to make this return ETrue instead.

        * @see MSenProvider interface

        */

        inline virtual TBool StayOnBackground() const;

        /** 

        * Default implementation does nothing, and

        * returns KErrNotSupported.

        * Subclasses should override this method in

        * order to re-initialize any state variables

        * that are not related to exact construction

        * phase; for example, some provider might

        * reset any state data it has, but still it

        * might decide to keep negotiated client

        * (connection) to some server open, making

        * just corresponding "re-init" to that service

        * being internally consumed by that provider.

        *

        * Typically, this method is a pair to Reinitializable()

        * function, meaning that when one develops such provider 

        * which supports reinitialization, that re-init should be 

        * implemented behind this ReinitL() method.

        *

        * @see MSenProvider

        */

        inline virtual TInt ReinitL();

        /**

        * Default implementation does nothing. Subclasses should override this.

        */

        //inline virtual void ThreadInitL(const TDesC& /* aThreadId */) { ; }

        /**

        * Default implementation does nothing. Subclasses should override this.

        */

        //inline virtual void ThreadDestroy(const TDesC& /* aThreadId */) { ; }

    private:

        /** iDtor_ID_Key Instance identifier key. When instance of an

        *               implementation is created by ECOM framework, the

        *               framework will assign UID for it. The UID is used in

        *               destructor to notify framework that this instance is

        *               being destroyed and resources can be released.

        */

        TUid iDtor_ID_Key;

        HBufC8* iCue;

        TAny* _reserved;

        TAny* _reserved2;

    };

#include "senprovider.inl"

#endif 

// End of File