/*

* 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:  CXcapAppUsage

*

*/

#ifndef __XCAPAPPUSAGE__

#define __XCAPAPPUSAGE__

// INCLUDES

#include <ecom.h>

#include <XdmEngine.h>

#include <XdmProtocolUidList.h>

#include "XcapAppUsageDef.h"

// CONSTANTS

#ifdef _DEBUG

_LIT( KXdmAppUsageLogDir,                          "Xdm" );

_LIT( KXdmAppUsageLogFile,                         "XcapAppUsage.txt" );

const TInt KAppUsageLogBufferMaxSize                = 2000;

#endif

_LIT( KXdmDefaultNsAttrName, "xmlns");

_LIT( KXdmNonDefaultNsAttrName, "xmlns:");

const TInt KXdmMaxPrefixLength = 10;

// FORWARD DECLARATIONS

class CXdmDocument;

class MXcapUriInterface;

// NOTE

// If _NAMESPACES_TO_NODE_SELECTOR flag is defined, used namespaces will be added to the node selector

// when updating partial documents.

// The default namespace of the usage will not be added.

#define _NAMESPACES_TO_NODE_SELECTOR

// If _ADD_NAMESPACE_ATTRIBUTES flag is defined, namespace information is

// added as an node atttribute when updating partial documents.

// The default namespace of the usage will not be added.

#define _ADD_NAMESPACE_ATTRIBUTES

/**

* A helper class for  parameter passing from

* the XCAP protocol to the application usage

*

* NOTE: There will most probably be more than one parameter!

*

*/

class TXcapAppUsageParams

    {

    public:

        /**

        * @param CXdmEngine& XDM Engine

        * @return TXcapAppUsageParams

        */

        TXcapAppUsageParams( const CXdmEngine& aXdmEngine ) :

                             iXdmEngine( aXdmEngine ){}

    public:

        const CXdmEngine&    iXdmEngine;

    };

// CLASS DECLARATION

/**

* Application usage base class

*/

class CXcapAppUsage : public CBase

    {

    public:

        /**

        * Symbian OS constructor

        * @param aXdmEngine XdmEngine reference

        * @param aDocumentType Type of the document

        * @return CXcapAppUsage*

        * REMOVE THIS WHEN USAGE IN ENGINE CHANGED!!!

        */

        static CXcapAppUsage* NewL( const CXdmEngine& aXdmEngine,

                                    const TXdmDocType aDocumentType );

        /**

        * Symbian OS constructor

        * @param aXdmEngine XdmEngine reference

        * @param aDocumentType Type of the document

        * @return CXcapAppUsage*

        */

        IMPORT_C CXcapAppUsage* NewL( const CXdmEngine& aXdmEngine,

                                    const TInt aDocumentType );

        /**

        * Destructor

        */

        virtual ~CXcapAppUsage();

        /**

        * Validate the document in the parameter.

        * Calls ValidateNodeL( aXdmNode ) method from derived class

        * for each node in document and ValidateAttributeL( aXdmNodeAttr )

        * for each attribute in document. If the document is outgoing, 

        * calls also AddNamespaceInformationL method from derived class.

        * @param aXdmDocument document reference

        * @param aAddNamespaces if true, the namespaces will be added

        * @return KErrNone or error code.

        */

        IMPORT_C TInt Validate( CXdmDocument& aXdmDocument, TBool aAddNamespaces ) ;

        /**

        * Validate the node in the parameter.

        * Calls ValidateNodeL( aXdmNode ) method from derived class for 

        * current node and it's descendants and ValidateAttributeL( aXdmNodeAttr )

        * for each attribute. Stores the uri of the node.

        * @param aXdmNode node reference

        * @param TBool aIsGetOrDelete indication of http get or delete

        * @return KErrNone or error code.

        */

        IMPORT_C TInt Validate( CXdmDocumentNode& aXdmNode, 

                                MXcapUriInterface* aUriInterface,

                                TBool aIsGetOrDelete ) ;

    public:  // Application Usage API

        /**

        * AUID for this usage

        * @return AUID

        */

        virtual TPtrC8 AUID() const = 0;

        /**

        * MIME type for this usage

        * @return MIME type

        */

        virtual TPtrC8 ContentType() const = 0;

        /**

        * Default namespace for this usage

        * @return Default namespace definition

        */

        virtual TPtrC8 DefaultNamespace() const = 0;

        /**

        * Validate the node in the parameter

        * This method is called by base class for each node

        * in document, here we have to check element datatype,

        * restrictions for values and also do all checking that concerns  

        * the structure of the element. If the datatype is some of

        * the common datatypes defined in xcapappusage.h, the node

        * can pe passed to the base class for value validation.

        * @param CXdmDocumentNode& node reference

        * @return True, if the node belongs to the current namespace

        */

        virtual TBool ValidateNodeL( CXdmDocumentNode& aXdmNode ) = 0;

        /**

        * Validate the attribute in the parameter

        * This method is called by base class for each attribute

        * in document, here we have to define data types

        * for attributes, and pass them to the base class

        * for the actual data checking.

        * @param aXdmNodeAttr attribute reference

        */

        virtual void ValidateAttributeL( const CXdmNodeAttribute& aXdmNodeAttr ) = 0;

        /**

        * Add namespaces and namespace prefixes used in document

        * @param aXdmDocument document reference

        */

        virtual void AddNamespaceInformationL( CXdmDocument& aXdmDocument ) = 0;

    protected:

        /**

        * C++ constructor

        */

        CXcapAppUsage( const CXdmEngine& aXdmEngine );

        /**

        * Validates basic data types

        * @param aDataType type of the data

        * @param aXdmNode node reference

        */

        void ValidateDataL ( TDataType aDataType, CXdmDocumentNode& aXdmNode );

       /**

        * Validates basic data types

        * @param aDataType type of the data

        * @param aXdmNodeAttr attribute reference

        */

        void ValidateDataL ( TDataType aDataType, const CXdmNodeAttribute& aXdmNodeAttr );

        /**

        * If outgoing document, adds namespacePrefix 

        * to the node in parameter

        * @param aXdmNode node reference

        * @param aPrefix namespace prefix

        */

        void SetPrefixL( CXdmDocumentNode& aXdmNode, const TDesC8& aPrefix );

        /**

        * Helper method for string comparison

        * @param aLeft first string

        * @param aRight second string

        * @return ETrue, if the strings are equal

        */

        TBool Match( const TDesC& aLeft, const TDesC& aRight );

        /**

        * Helper method for string comparison

        * @param aLeft first string

        * @param aRight second string

        * @return ETrue, if the strings are equal

        */

        TBool Match( const TDesC8& aLeft, const TDesC8& aRight );

        /**

        * To be used when an error occurs, however if the node is

        * for http get or delete request, this do not leave

        * @param aErrorCode function will leave with this error code

        */

        void LeaveWithErrorL( TInt aErrorCode );

#ifdef _DEBUG        

        /**

        * Writes logs to file.

        */

        void WriteToLog( TRefByValue<const TDesC8> aFmt,... );

#endif

    private:

        /**

        * Validate the document in the parameter.

        * @param aXdmDocument document reference

        */

        void DoValidateL( CXdmDocument& aXdmDocument ) ;

        /**

        * Validate the node in the parameter. 

        * @param aXdmNode node reference

        */

        void DoValidateL( CXdmDocumentNode& aXdmNode ) ;

        /**

        * Validates basic data types

        * @param aDataType type of the data

        * @param aData validated data

        */

        void ValidateDataL ( TDataType aDataType, TDesC8& aData );

        /**

        * Updates member variables for used namespaces

        * @param aPrefix prefix of the namespace

        */        

        void AddUsedNamespace( const TDesC8& aPrefix ) ;

        /**

        * Resets member variables for used namespaces

        */

        void ResetUsedNamespaces( ); 

        /**

        * Appends namespace information to the node's uri interface. 

        * Called if _NAMESPACES_TO_NODE_SELECTOR defined.

        * @param aUriInterface interface for storing the uri

        */

        void AppendUsedNamespacesL( MXcapUriInterface* aUriInterface ); 

        /**

        * Creates namespace attribute for the node. 

        * Called if _ADD_NAMESPACE_ATTRIBUTES is defined

        * and validating partial document.

        * @param aXdmNode node for storing the uri

        */

        void CreateNamespaceAttributesL( CXdmDocumentNode& aXdmNode, MXcapUriInterface* aUriInterface );

        /**

        * Removes namespace attributes from the node

        * and it's child nodes

        * @param aXdmNode 

        */

        void RemoveNamespaceAttributesL( CXdmDocumentNode& aXdmNode ); 

        /**

        * Adds namespace attributes that are used in 

        * partial document

        * @param aXdmNode 

        */

        void AppendNamespaceAttributesL( CXdmDocumentNode& aXdmNode ) ;

        /**

        * Creates namespace attribute for node

        * @param aXdmNode 

        * @param aPrefix prefix of the namespace

        * @param aNamespace namespace definition

        */

        void CreateNamespaceAttributeL( CXdmDocumentNode& aXdmNode, const TDesC8& aPrefix, const TDesC8& aNamespace );

        /**

        * Goes through all nodes and checks if 

        * default namespace is used in document fragment

        * the namespace given in parameter

        * @param aXdmNode 

        * @return ETrue or EFalse

        */

        TBool DefaultNamespaceUsed( CXdmDocumentNode& aXdmNode );

    protected:  // Data

        CXdmEngine&                 iXdmEngine;

    private:  // Data

        TBool                       iAddNamespaces;

        TBool                       iNsToNodeSelector;

        TBool                       iAddNsAttributes;

        TBool                       iIsGetOrDelete;

        TUid                        iDestructorKey;

		// Variables for used namespaces

		// Add new one here if needed

        TBool iRL;

        TBool iCR;

        TBool iCP ;

        TBool iPR;

        TBool iLS;

        TBool iPOC;

        TBool iOPR;

        TBool iRLS;

        TBool iOU;

    // add new prefix definitions here 

    };

// ----------------------------------------------------

// CXcapAppUsage::NewL

// Create a new application usage implementation

// REMOVE THIS WHEN USAGE IN ENGINE CHANGED!!!

// ----------------------------------------------------

//

inline CXcapAppUsage* CXcapAppUsage::NewL( const CXdmEngine& aXdmEngine,

                                           const TXdmDocType aDocumentType )

    {

    TAny* ptr = NULL;

    TXcapAppUsageParams params( aXdmEngine );

    switch( aDocumentType )

        {

        case EXdmCapabilities:

            {

            TUid KDefaultImplementationUid = { 0x10207418 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

        case EXdmDirectory:

            {

            TUid KDefaultImplementationUid = { 0x10207419 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

        case EXdmTestDocType:

            {

            TUid KDefaultImplementationUid = { 0x1020741A };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

        case EXdmPoCGroup:

            {

            TUid KDefaultImplementationUid = { 0x1020741B };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

        case EXdmPoCUserAccessPolicy:

            {

            TUid KDefaultImplementationUid = { 0x1020741C };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

        case EXdmSharedXdm:

            {

            TUid KDefaultImplementationUid = { 0x1020741D };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

       case EXdmRlsServices:

            {

            TUid KDefaultImplementationUid = { 0x1020741E };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

      case EXdmResourceLists:

            {

            TUid KDefaultImplementationUid = { 0x10275080 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

      case EXdmIetfCommonPolicy:

            {

            TUid KDefaultImplementationUid = { 0x10275081 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

      case EXdmOmaCommonPolicy:

            {

            TUid KDefaultImplementationUid = { 0x10275082 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

      case EXdmIetfPresenceRules:

            {

            TUid KDefaultImplementationUid = { 0x10275083 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

      case EXdmOmaPresenceRules:

            {

            TUid KDefaultImplementationUid = { 0x102750AB };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                   KDefaultImplementationUid,

                   _FOFF( CXcapAppUsage, iDestructorKey ),

                   ( TAny* )&params ) );

            }

            break;

// PRES-CONTENT STARTS

      case EXdmPresContent:

            {

            TUid KDefaultImplementationUid = { 0x20028701 };

            TRAPD( error, ptr = REComSession::CreateImplementationL( 

                KDefaultImplementationUid,

                _FOFF( CXcapAppUsage, iDestructorKey ),

               ( TAny* )&params ) );

            }

            break;

// PRES-CONTENT ENDS

        default:

            User::Leave( KErrNotSupported );

        }

    return reinterpret_cast<CXcapAppUsage*>( ptr );

    }

#endif          //__XCAPAPPUSAGE__

// End of File