/*

* Copyright (c) 2008 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:  Utility for common code.

*

*/

#include "hspsthememanagement.h"

#include "hspsserverutil.h"

#include "hspsodt.h"

#include "hspsdomdepthiterator.h"

#include "hspsdomnode.h"

#include "hspsdomdocument.h"

#include "hspsconfiguration.h"

#include "hspsdomlist.h"

#include "hspsresource.h"

#include "hspsdomattribute.h"

#include "hspsmanifest.h"

#include "bautils.h" 

#include "sysutil.h"

#include <syslangutil.h>

_LIT(KHspsFolder, "\\200159c0\\themes\\" );

_LIT(KSourcesFolder, "\\sources\\");

_LIT( KThemesFolder, "\\themes\\" );

_LIT( KDoubleBackSlash, "\\" );

_LIT8( KHexPrefix8, "0x" );

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

// hspsServerUtil::GenerateConfigurationAttributesL

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

//

void hspsServerUtil::GenerateConfigurationAttributesL( ChspsODT& aOdt )

    {

    ChspsDomDocument& dom = aOdt.DomDocument();

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( *dom.RootNode() );   

    CleanupStack::PushL( iter );

    ChspsDomNode* prevNode = NULL;

    ChspsDomNode* node = iter->First();

    while( node && prevNode != node )

        {           

        const TDesC8& name = node->Name();

        // Configuration element 

        if ( name == KConfigurationElement )

            {                                                   

            // Add attributes for the configuration node        

            // NOTE! ID attribute is not set here           

            TPtrC8 ptr = KManifestTypeApp().Ptr();

            switch ( aOdt.ConfigurationType() )

                {

                case EhspsViewConfiguration:

                    {

                    ptr.Set( KManifestTypeView );

                    }

                    break;

                case EhspsWidgetConfiguration:

                    {

                    ptr.Set( KManifestTypeWidget );

                    }

                    break;

                case EhspsTemplateConfiguration:

                    {

                    ptr.Set( KManifestTypeTemplate );

                    }

                    break;

                default:

                    {                   

                    }

                }

            AddAttributeDescL( *node, KConfigurationAttrType, ptr );

            AddAttributeNumericL( *node, KConfigurationAttrInterface, aOdt.RootUid(), EHex );

            AddAttributeNumericL( *node, KConfigurationAttrUid, aOdt.ThemeUid(), EHex );

            // Create "name" and "_name" attributes, of which latter holds the entity reference 

            // (logical key for finding localizad strings)

            HBufC8* nameBuf = HBufC8::NewLC( aOdt.ThemeFullName().Length() );

            TPtr8 namePtr( nameBuf->Des() );

            namePtr.Copy( aOdt.ThemeFullName() );

            AddAttributeDescL( *node, KConfigurationAttrName, namePtr ); // will be updated when localized

            AddAttributeDescL( *node, KConfigurationAttrNameEntity, namePtr ); // logical id

            CleanupStack::PopAndDestroy( nameBuf );                        

            // Create theme version attribute

            HBufC8* tv = HBufC8::NewLC( aOdt.ThemeVersion().Length() );

            TPtr8 tvPtr( tv->Des() );

            tvPtr.Copy( aOdt.ThemeVersion() );

            AddAttributeDescL( *node, KConfigurationAttrVersion, tvPtr );

            CleanupStack::PopAndDestroy( tv );

            AddAttributeNumericL ( *node, KConfigurationAttrMultiInstance,

                aOdt.MultiInstance(), EDecimal );

            AddAttributeDescL( *node, KConfigurationAttrState, KConfStateNotConfirmed );

            const TInt descLength = aOdt.Description().Length();

            if ( descLength )

                {

                // Add description of the widget (16 > 8bit conversion) 

                HBufC8* buf = HBufC8::NewLC( descLength );

                TPtr8 bufPtr( buf->Des() );

                bufPtr.Copy( aOdt.Description() );

                AddAttributeDescL( *node, KConfigurationAttrDesc, bufPtr ); // will be updated when localized

                AddAttributeDescL( *node, KConfigurationAttrDescEntity, bufPtr ); // logical id

                CleanupStack::PopAndDestroy( buf );

                }

            else

                {

                AddAttributeDescL( *node, KConfigurationAttrDesc, KNullDesC8 );

                }

            }       

        prevNode = node;    

        node = iter->NextL();

        }

    CleanupStack::PopAndDestroy( iter );

    }

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

// ChspsInstallationHandler::GenerateObjectAttributesL()

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

//

void hspsServerUtil::GenerateObjectAttributesL( ChspsODT& aOdt )

    {

    // Find the configuration node

    ChspsDomDocument& dom = aOdt.DomDocument();     

    ChspsDomNode* configurationNode = dom.RootNode();

    if ( !configurationNode )

        {

#ifdef _hsps_DEBUG_       

        RDebug::Print( _L("hspsServerUtil::GenerateObjectAttributesL(): - invalid ODT!") );

#endif      

        User::Leave( KErrGeneral );

        }

    // Find resources node from the XML definition (child of the configuration node)

    ChspsDomList& childsList = configurationNode->ChildNodes(); 

    ChspsDomNode* resourcesNode = (ChspsDomNode *)childsList.FindByName( KResourcesElement );

    TInt popResources = EFalse;

    if ( !resourcesNode )

        {

        // Create a node and add it into the configuration node

        resourcesNode = dom.CreateElementNSL( 

            KResourcesElement,      

            configurationNode->Namespace()          

            );                              

        CleanupStack::PushL( resourcesNode );

        popResources = ETrue;

        configurationNode->AddChildL( resourcesNode );

        resourcesNode->SetParent( configurationNode );

        }    

    // Loop ODT's resources (parsed ealier from the manifest file)

    const TInt resourceCount = aOdt.ResourceCount();

    TBool addResource = EFalse;

    for( TInt resourceIndex=0; resourceIndex < resourceCount; resourceIndex++ )

        {                

        ChspsResource& resource = aOdt.ResourceL( resourceIndex );                                

        addResource = EFalse;

        // If resource is located under the sources folder

        if ( resource.FileName().FindF( KSourcesFolder ) > 0 )        

            {                        

            // If resource is for the active device language or it's a locale independent resource

            addResource = ( resource.Language() == aOdt.OdtLanguage() || resource.Language() == ELangNone );                                     

            }

        if ( addResource )        	

        	{          	

	         // Create an object node and add the object into the resources list                    

	        ChspsDomNode* objectNode = dom.CreateElementNSL( 

	            KObjectElement,         

	            resourcesNode->Namespace()          

	            );                              

	        CleanupStack::PushL( objectNode );

	        resourcesNode->AddChildL( objectNode );

	        objectNode->SetParent( resourcesNode );

	        // Name (16->8bit conversion)

	        HBufC8* nameBuf = HBufC8::NewLC( resource.ResourceId().Length() );

	        TPtr8 namePtr( nameBuf->Des() );

	        namePtr.Copy( GetFixedOdtName( resource.ResourceId() ) );            

	        AddAttributeDescL( *objectNode, KObjectAttrFilename, namePtr );

	        CleanupStack::PopAndDestroy( nameBuf );

	        // Media type

	        TPtrC8 mimePtr( resource.MimeType().Des8() );           

	        if ( mimePtr.Length() )

	            {

	            AddAttributeDescL( *objectNode, KObjectAttrMediatype, mimePtr );

	            }

	        // Tag

            TPtrC tagPtr( resource.Tags() );           

            if ( tagPtr.Length() )

                {

                // (16->8bit conversion)

                HBufC8* buf = HBufC8::NewLC( tagPtr.Length() );

                TPtr8 bufPtr( buf->Des() );

                bufPtr.Copy( tagPtr );

                AddAttributeDescL( *objectNode, KObjectAttrTag, bufPtr );

                CleanupStack::PopAndDestroy( buf );

                }

	        // Path 

	        TInt pos = resource.FileName().FindF( KHspsFolder );

	        if ( pos > 0 )

	            {

	            // Remove filename and extension from the path

	            TParsePtrC parserPtr( resource.FileName() );

	            TFileName path( parserPtr.DriveAndPath() );

	            // Remove path to the Definition repository 

	            path.Copy( path.Mid( pos + KHspsFolder().Length() ) );

	            // Fix path references for localized resources

	            GetLocaleIndependentResourcePath( resource.Language(), path );	            	            

	            // 16->8bit conversion	            

	            HBufC8 *pathBuf = HBufC8::NewLC( path.Length() );                  	            

	            pathBuf->Des().Copy( path );

	            AddAttributeDescL( *objectNode, KObjectAttrPath, pathBuf->Des() );

	            CleanupStack::PopAndDestroy( pathBuf );

	            }

	        // Now the document has an ownership of the objectnode

	        CleanupStack::Pop( objectNode );

        	}

        } // for loop

    if ( popResources )

        {

        // Now the document has an ownership of the resourcesNode

        CleanupStack::Pop( resourcesNode );

        }

    }

TFileName hspsServerUtil::GetFixedOdtName( 

        const TDesC& aNameAndExtension )

    {        

    TParsePtrC parsePtr( aNameAndExtension );                      

    TPtrC fileExtension = parsePtr.Ext();

    if ( fileExtension.Length() > 2 && fileExtension.Left(2).CompareF( _L(".o") ) == 0 )

        {            

        // Strip the first letter            

        TInt odtIndex(0);                  

        TLex lex( fileExtension.Mid(3) );

        if ( lex.Val( odtIndex ) == KErrNone && odtIndex >= 0 )

            {                

            fileExtension.Set( _L(".o0000") );

            }

        }

    TFileName fileName( parsePtr.Name() );

    fileName.Append( fileExtension );

    return fileName;

    }

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

// hspsServerUtil::GetLocaleIndependentResourcePath

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

//

void hspsServerUtil::GetLocaleIndependentResourcePath(

		const TLanguage& aResourceLanguage,		 

		TFileName& aPath )

	{

	TBool isLocaleSpecificResource = ( aResourceLanguage != ELangNone );		

	// If locale specific resource

    if ( isLocaleSpecificResource )

    	{

    	// Remove locale specific subfolder from the path

    	TInt pos = aPath.FindF( KSourcesFolder );

    	if ( pos )

    		{    		    		    		    	

    		aPath.Copy( aPath.Left( pos + KSourcesFolder().Length() ) );

    		}

    	}    

	}

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

// hspsServerUtil::GetRelativeResourcePath

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

//

void hspsServerUtil::GetRelativeResourcePath(

        const TFileName& aSourceFile,

        TPath& aRelativePath )

    {    

    // find last part (structure after "/themes/") 

    TInt pos = aSourceFile.FindF( KThemesFolder );

    if( pos != KErrNotFound )

        {

        pos += KThemesFolder().Length();        

        TInt len( aSourceFile.Length() - pos );               

        aRelativePath.Copy( aSourceFile.Right( len ) );                     

        }    

    }

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

// hspsServerUtil::AddAttributeNumericL

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

//

TInt hspsServerUtil::AddAttributeNumericL(

        ChspsDomNode& aNode,

        const TDesC8& aAttrName, 

        const TInt aValue,

        const TRadix aFormat )

    {

    // Format change

    // Value string, 10 -> Max decimal 4294967295 , max hexadecimal 0xXXXXXXXX

    const TInt KMaxLength = 10;

    TBuf8<KMaxLength> attValueDes8; 

    if ( aFormat == EHex )

        {

        _LIT8( KFormat8, "%X" );

        _LIT8( KHexPrefix, "0x" );

        attValueDes8.Append( KHexPrefix );

        attValueDes8.AppendFormat( KFormat8, aValue );

        }

    else // EDecimal

        {

        _LIT8( KFormat8, "%d" );

        attValueDes8.AppendFormat( KFormat8, aValue );

        }

    ChspsDomList& attrList = aNode.AttributeList();

    ChspsDomAttribute* attr = static_cast<ChspsDomAttribute*>( attrList.FindByName(aAttrName) );

    if ( attr )

        {               

        // Replace value of the attribute

        attr->SetValueL( attValueDes8 );

        }

    else

        {              

        // Add an attribute

        ChspsDomAttribute* attr = ChspsDomAttribute::NewL( aAttrName, aNode.StringPool() );    

        CleanupStack::PushL( attr );            

        attr->SetValueL( attValueDes8 );

        ChspsDomList& attrList = aNode.AttributeList();

        attrList.AddItemL( attr );    //takes ownership

        CleanupStack::Pop( attr );

        }

    return KErrNone;

    }

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

// hspsServerUtil::AddAttributeDescL

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

//

void hspsServerUtil::AddAttributeDescL(

        ChspsDomNode& aNode,

        const TDesC8& aAttrName, 

        const TDesC8& aValue )

    {

    ChspsDomList& attrList = aNode.AttributeList();

    ChspsDomAttribute* attr = static_cast<ChspsDomAttribute*>( attrList.FindByName(aAttrName) );

    if ( attr )

        {               

        // Replace value of the attribute

        attr->SetValueL( aValue );

        }

    else

        {              

        // Add an attribute

        ChspsDomAttribute* attr = ChspsDomAttribute::NewL( aAttrName, aNode.StringPool() );    

        CleanupStack::PushL( attr );            

        attr->SetValueL( aValue );

        ChspsDomList& attrList = aNode.AttributeList();

        attrList.AddItemL( attr );    //takes ownership

        CleanupStack::Pop( attr );

        }        

    }

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

// Finds a configuration node with the provided id attribute

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

//

ChspsDomNode* hspsServerUtil::FindConfigurationNodeL(

		ChspsODT& aOdt,		

		const TInt aConfigurationId )

	{

	__UHEAP_MARK;

    ChspsDomNode *configurationNode = NULL;

    ChspsDomDocument& dom = aOdt.DomDocument();

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( *dom.RootNode() );

    CleanupStack::PushL( iter );

    // Find a configuration node with an id attribute that matches the provided id

    ChspsDomNode* node = iter->First();

    ChspsDomNode* prevNode = NULL;

    TBool jobDone = EFalse;

    while( node && !jobDone && prevNode != node )    

        {                

        const TDesC8& name = node->Name();

        // An element was found 

        if ( name == KConfigurationElement )

            {           

            ChspsDomList& attrList = node->AttributeList();                    

            ChspsDomAttribute* idAttr = static_cast<ChspsDomAttribute*>( attrList.FindByName(KConfigurationAttrId) );            

            if ( !idAttr )

                {

                // Return with NULL

                jobDone = ETrue;                                                 

                }

            else

                {            

                TInt id(0);            

                const TDesC8& idValue = idAttr->Value();                        

                TLex8 lex( idValue );                        

                lex.Val( id );            

                if ( aConfigurationId == id )

                    {

                    configurationNode = node;        

                    jobDone = ETrue;

                    }

                }

            }

        prevNode = node;        

        node = iter->NextL();

        }

    CleanupStack::PopAndDestroy( iter );

#ifdef _hsps_DEBUG_

    if ( !configurationNode )

        {

        RDebug::Print( _L("hspsServerUtil::FindConfigurationNodeL(): failed to find the configuration node") );

        }

#endif

    __UHEAP_MARKEND;

    return configurationNode;

    }

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

// Finds a plugin node with the provided id

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

//

ChspsDomNode* hspsServerUtil::FindPluginNodeL(

        ChspsODT& aOdt,        

        const TInt aPluginId )

    {            

    __UHEAP_MARK;

    ChspsDomNode* pluginNode = NULL;

    ChspsDomDocument& dom = aOdt.DomDocument();

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( *dom.RootNode() );

    CleanupStack::PushL( iter );

    // Find a plugin node with the provided id attribute

    ChspsDomNode* node = iter->First();

    ChspsDomNode* prevNode = NULL;

    TBool jobDone = EFalse;

    while( node && !jobDone && prevNode != node )

        {                

        const TDesC8& name = node->Name();

        // Plugin element was found 

        if ( name == KPluginElement )

            {           

            ChspsDomList& attrList = node->AttributeList();                    

            ChspsDomAttribute* idAttr = static_cast<ChspsDomAttribute*>( attrList.FindByName(KPluginAttrId) );            

            if ( !idAttr )

                {

                // Mandatory information is missing for some reason (should be set at installation handler)!

                // Exit with NULL

                jobDone = ETrue;                

                }

            else

                {            

                TInt id(0);            

                const TDesC8& idValue = idAttr->Value();                        

                TLex8 lex( idValue );                        

                lex.Val( id );            

                if ( aPluginId == id )

                    {

                    pluginNode = node;

                    jobDone = ETrue;

                    }

                }

            }

        prevNode = node;        

        node = iter->NextL();        

        }

    CleanupStack::PopAndDestroy( iter );

#ifdef _hsps_DEBUG_

    if ( !pluginNode )

        {

        RDebug::Print( _L("hspsServerUtil::FindPluginNodeL(): failed to find the plugin node") );

        }

#endif

    __UHEAP_MARKEND;

    return pluginNode;