/*

* 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:  Retrieves configurations from the Definition Repository

*

*/

#include "hsps_builds_cfg.hrh"

#include <f32file.h> 

#include <centralrepository.h>

#ifdef HSPS_LOG_ACTIVE

#include <hspsodtdump.h>

#include <hspslogbus.h>

#endif

#include "hspsresource.h"

#include "hspsdomdocument.h"

#include "hspsdomnode.h"

#include "hspsthememanagement.h"

#include "hspsdefinitionrepository.h"

#include "hspsodt.h"

#include "hspsresult.h"

#include "hspsreqnotifparam.h"

#ifdef _hsps_PERFORMANCE_TEST_

#include "hspstimemon.h"

#endif

#include "hspsclientrequesthandler.h"

#include "hspsmaintenancehandler.h"

#include "hspssecurityenforcer.h"

#include "hspsthemeserver.h"

#include "hspscenreplistener.h"

#include "hspsserverutil.h"

#include "hspsdomattribute.h"

#include "hspsdomlist.h"

#include "hspsdomdepthiterator.h"

#include "hspsdomnode.h"

#include "hspsconfiguration.h"

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

_LIT(KLocalesSubFolder, "\\locales\\");

// ============================= LOCAL FUNCTIONS ===============================

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

// Callback function for removing repository lock if error occurs while repository is locked

// Returns: void

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

//

LOCAL_C void UnlockRepository( TAny* aObject )

    {

    ChspsDefinitionRepository* DefRep = reinterpret_cast<ChspsDefinitionRepository*>( aObject );

    if( DefRep->Locked() )

        {

        DefRep->Unlock();

        }

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// ChspsClientRequestHandler::ChspsClientRequestHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

ChspsClientRequestHandler::ChspsClientRequestHandler( ChspsThemeServer& aThemeServer ): 

    iThemeServer( aThemeServer ), 

    iCentralRepository( aThemeServer.CentralRepository() ),  

    iDefinitionRepository( aThemeServer.DefinitionRepository() ),

    iSecurityEnforcer( aThemeServer.SecurityEnforcer() ),

    iHeaderListCache (aThemeServer.HeaderListCache() )            

    { 

    iLastSuccessThemeLoadTime = 0;

    iRestoreDefault = EFalse;

    }

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

// ChspsDefinitionRepository::NewL

// Two-phased constructor.

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

//

ChspsClientRequestHandler* ChspsClientRequestHandler::NewL( ChspsThemeServer& aThemeServer )

    {

    ChspsClientRequestHandler* h = ChspsClientRequestHandler::NewLC( aThemeServer );

    CleanupStack::Pop(h);

    return (h);

    }

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

// ChspsDefinitionRepository::NewLC

// Two-phased constructor.

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

//

ChspsClientRequestHandler* ChspsClientRequestHandler::NewLC( ChspsThemeServer& aThemeServer )

    {

    ChspsClientRequestHandler* h = new (ELeave) ChspsClientRequestHandler( aThemeServer );

    CleanupStack::PushL(h);

    h->ConstructL();

    return (h);

    }

// Destructor

ChspsClientRequestHandler::~ChspsClientRequestHandler()

    {

    delete iOdt;

    delete iResult;

    delete iReqNotifParams;

    delete iRequestData;

    iFs.Close();

    delete iCenRepListener;

    iDefinitionRepository.UnregisterObserver( *this );

    }

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

// ChspsDefinitionRepository::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsClientRequestHandler::ConstructL()

    {

    // call the base class ConstructL

    User::LeaveIfError(iFs.Connect());

    iResult = ChspsResult::NewL();

    iReqNotifParams = ChspsRequestNotificationParams::NewL();

    iDefinitionRepository.RegisterObserverL( *this );    

    iCenRepListener = NULL;    

    }

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

// ChspsClientRequestHandler::ServiceGetOdtL

// Serves hspsRequestClient on hspsGetODT() service call.

// (other items were commented in a header).

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

//

void ChspsClientRequestHandler::ServiceGetOdtL(const RMessage2& aMessage)

    {

    iThemeLoadRepeatCount = 0;

    TInt errorCode = KErrNone;

    RMessagePtr2 msgPtr = aMessage;

    // Get configuration from IPC slot #1

    ThspsConfiguration configuration;        

    TPckg<ThspsConfiguration> packagedStruct(configuration);    

    aMessage.ReadL(1, packagedStruct);                        

    iRootUid = configuration.rootUid;    

    iSecureId = msgPtr.SecureId().iId;

    iRequestMessage = (ThspsServiceRequestMessage) aMessage.Function();

    // Get header data from IPC slot #2

    TBuf8<KMaxHeaderDataLength8> requestData; 

    msgPtr.ReadL( 2, requestData, 0 );

    ThspsServiceCompletedMessage ret = EhspsGetODTFailed;

    // resetting previous request objects

    if ( iRequestData )

        {

        delete iRequestData;

        iRequestData = NULL;

        }

    // constructing new data request objects  

    iRequestData = requestData.AllocL();

    // reset previous ODT

    if ( iOdt )

        {

        delete iOdt;

        iOdt = NULL;

        }

    // constructing new ODT

    iOdt = ChspsODT::NewL();

    iOdt->UnMarshalHeaderL( iRequestData->Des() );

    TBool err = EFalse;

    if ( !iRootUid )

        {

        err = ETrue;

        iResult->iSystemError = KErrInUse;

        CompleteRequestL( EhspsServiceRequestError, msgPtr );

        }

    if ( !err )

        {

        // Get configuration: 1st attempt

        ret = hspsGetODT(iRootUid, *iOdt );

        // If fetching failed

        if ( ret != EhspsGetODTSuccess )

            {

            // If not restoring yet

            if ( iRestoreDefault )

                {

                // Restore a default configuration

                TRAP( errorCode, RestoreDefaultL( *iOdt ) );    

                if ( !errorCode )

                    {

                    // 2nd attempt: try to fetch the default configuration

                    ret = hspsGetODT(iRootUid, *iOdt );

                    if ( ret != EhspsGetODTSuccess )

                        {                         

#ifdef HSPS_LOG_ACTIVE  

                        if( iLogBus )

                            {

                            iLogBus->LogText( _L( "ChspsClientRequestHandler::ServiceGetODTL(): - default theme for appuid %d is not available." ),

                                    iOdt->RootUid() );

                            }

#endif                        

                        CompleteRequestL( EhspsGetODTFailed, msgPtr );

                        }

                    } // !errorCode

                } // iRestoreDefault            

            } // !EhspsGetODTSuccess

        // If a configuration was found (either after the first attempt or after restoring the default configuration)

        if ( ret == EhspsGetODTSuccess )

            {           

            // If an application configuration was fetched

            if ( iOdt->ConfigurationType() == EhspsAppConfiguration )

                {

                // Finnish installation of the application configuration

                HandlePluginReferencesL( *iOdt );

                }                

            // write ODT-file path back to the client for theme load

            msgPtr.WriteL( 3, iODTPath, 0 );

            CompleteRequestL( ret, msgPtr );

            } // success

        else 

            {

            if ( !iHeaderListCache.Count() )

                {

                // header list cache is empty. This may also occur when memory is full

#ifdef HSPS_LOG_ACTIVE  

                if( iLogBus )

                    {

                    iLogBus->LogText( _L( "ChspsClientRequestHandler::ServiceGetODTL(): - theme cache is empty." ) );

                    }

#endif                    

                CompleteRequestL( EhspsGetODTFailed, msgPtr ); 

                }

            else if ( iRestoreDefault )

                {

#ifdef HSPS_LOG_ACTIVE  

                if( iLogBus )

                    {

                    iLogBus->LogText( _L( "ChspsClientRequestHandler::ServiceGetODTL(): - default theme cannot be restored." ) );

                    }

#endif                   

                CompleteRequestL( EhspsGetODTFailed, msgPtr );

                }

            else if ( iDefinitionRepository.Locked() )

                {

                // possible repository lock, wait for checking the theme availability after a while

#ifdef HSPS_LOG_ACTIVE  

                if( iLogBus )

                    {

                    iLogBus->LogText( _L( "ChspsClientRequestHandler::ServiceGetODTL(): - theme repository is locked, trying again after reasonable time .." ) );

                    }

#endif                    

                CompleteRequestL( EhspsGetODTFailed, msgPtr ); 

                }

            else

                {

#ifdef HSPS_LOG_ACTIVE  

                if( iLogBus )

                    {

                    iLogBus->LogText( _L( "ChspsClientRequestHandler::ServiceGetODTL(): - theme load failed." ) );

                    }

#endif                    

                CompleteRequestL( EhspsGetODTFailed, msgPtr ); 

                }

            } // else (!EhspsGetODTSuccess)

        } // !err

    }

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

// ChspsClientRequestHandler::HandlePluginReferencesL()

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

//

void ChspsClientRequestHandler::HandlePluginReferencesL(

        ChspsODT& aAppODT )

    {

    // Input validation

    if ( aAppODT.ConfigurationType() != EhspsAppConfiguration )

        {

        User::Leave( KErrGeneral );

        }

    // Assume that plugins need to be added

    TBool addPlugins = ETrue;     

    // Check whether the plugins needs to be added

    ChspsDomDocument& appDom = aAppODT.DomDocument(); 

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

    CleanupStack::PushL( iter );

    ChspsDomNode* prevNode = NULL;

    ChspsDomNode* node = iter->First();

    TInt tempCount = 0;

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

        {           

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

        if ( name == KConfigurationElement )

            {

            tempCount++;

            if ( tempCount > 1 )

                {

                addPlugins = EFalse;

                }                           

            }    

        prevNode = node;    

        node = iter->NextL();   

        }

    CleanupStack::PopAndDestroy( iter );

    // If plugin configurations need to be added

    if ( addPlugins )

        {    

        if ( iDefinitionRepository.Locked() )

            {

            // Repository was locked by another session?!

            User::Leave( KErrAccessDenied );

            }

        // Lock the Plugin Repository (a.k.a. Def.rep)

        iDefinitionRepository.Lock();                               

        CleanupStack::PushL( TCleanupItem( UnlockRepository, &iDefinitionRepository ) );

        // Go through the XML document, find all plugin nodes and append plugin specifc XML configurations

        AppendPluginConfigurationsL( aAppODT );       

        //Append widget instance specific predefined settings

        User::LeaveIfError( AppendInitialSettingsL( aAppODT ));

        // Set first plugin nodes from levels to be active. Others are to be deactivated.

        hspsServerUtil::EditPluginNodeActivityL( aAppODT.DomDocument().RootNode(),

                                                 hspsServerUtil::EActivateFirst );

        // Update changes into the Plug-in Repository

        User::LeaveIfError( iDefinitionRepository.SetOdtL( aAppODT ) );           

        // Unlock after the changes have been done

        iDefinitionRepository.Unlock();

        CleanupStack::Pop(&iDefinitionRepository);        

#ifdef HSPS_LOG_ACTIVE    

        if( iLogBus )

            {

            iLogBus->LogText( _L( "ChspsClientRequestHandler::HandlePluginReferencesL(): - dumping updated full XML document" ) );

            ChspsOdtDump::Dump( aAppODT, *iLogBus );

            }

#endif        

        }

    }

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

// ChspsClientRequestHandler::AddErrorConfigurationL()

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

//

void ChspsClientRequestHandler::AddErrorConfigurationL(

        ChspsDomDocument& aAppDom,

        ChspsDomNode& aMissingPluginNode,

        const TInt aPluginUid

        )        

    {    

    // Create a new dummy configuration element

    ChspsDomNode* confNode = aAppDom.CreateElementNSL( 

        KConfigurationElement,         

        aMissingPluginNode.Namespace()            

        );

    CleanupStack::PushL( confNode );        

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrType, KConfTypeWidget );

    _LIT8( KUnknown, "unknown" );

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrInterface, KUnknown );

    hspsServerUtil::AddAttributeNumericL( *confNode, KConfigurationAttrUid, aPluginUid, EHex );

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrName, KUnknown );

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrNameEntity, KUnknown );

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrVersion, KUnknown );        

    hspsServerUtil::AddAttributeNumericL( *confNode, KConfigurationAttrMaxChild, 0, EDecimal );        

    // Indicate that the configuration is in error state

    hspsServerUtil::AddAttributeDescL( *confNode, KConfigurationAttrState, KConfStateError );

    // Set parent node

    aMissingPluginNode.AddChildL( confNode );

    CleanupStack::Pop( confNode );

    confNode->SetParent( &aMissingPluginNode );

    // Mandatory configuration-control node

    ChspsDomNode* controlNode = aAppDom.CreateElementNSL( 

        KControlElement,         

        confNode->Namespace()            

        );

    CleanupStack::PushL( controlNode );    

    confNode->AddChildL( controlNode );

    CleanupStack::Pop( controlNode );

    controlNode->SetParent( confNode );

    // Mandatory configuration-control-settings node

    ChspsDomNode* settingsNode = aAppDom.CreateElementNSL( 

        KSettingsElement,         

        controlNode->Namespace()            

        );

    CleanupStack::PushL( settingsNode );    

    controlNode->AddChildL( settingsNode );

    CleanupStack::Pop( settingsNode );

    settingsNode->SetParent( controlNode );           

    // Mandatory configuration-resources node

    ChspsDomNode* resourcesNode = aAppDom.CreateElementNSL( 

        KResourcesElement,         

        confNode->Namespace()            

        );

    CleanupStack::PushL( resourcesNode );    

    confNode->AddChildL( resourcesNode );

    CleanupStack::Pop( resourcesNode );        

    resourcesNode->SetParent( confNode );           

    }

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

// ChspsClientRequestHandler::PrepareAndCompleteRequestL()

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

//

void ChspsClientRequestHandler::PrepareAndCompleteRequestL( const ThspsRepositoryInfo& aInfo,

                                                            const ThspsServiceCompletedMessage& aMessage )

    {

    TBool LastDefinitionRepositoryEvent(ETrue);

    if( !iReqNotifParams )

        {

        User::Leave( KErrCorrupt );

        }

    if( !aInfo.iLastNotification )

        {

        LastDefinitionRepositoryEvent = EFalse;

        }

    // Prepare request notification object.

    if(iReqNotifParams->iEvent == EhspsNoEvent || iReqNotifParams->iEvent == aInfo.iEventType )

        {

        iReqNotifParams->iEvent = aInfo.iEventType;  

        iReqNotifParams->iAppUid = aInfo.iAppUid;

        iReqNotifParams->iAppConfUid = aInfo.iAppConfUid;

        iReqNotifParams->iOrigUid = aInfo.iSecureId;

        iReqNotifParams->iPluginUid = aInfo.iPluginUid;

        iReqNotifParams->iCount++;

        iReqNotifParams->iPluginIds.Append( aInfo.iPluginId );

        if( aInfo.iName.Length() > 0 )

            {

            iReqNotifParams->SetNameL( aInfo.iName );

            }   

        }

    if( LastDefinitionRepositoryEvent )

        {

        // Externalize request notification object to message structure.

        TInt errorCode = KErrNone;

        RDesWriteStream writeBuf( iReqNotifData );

        CleanupClosePushL( writeBuf );

        TRAP( errorCode, iReqNotifParams->ExternalizeL( writeBuf ) );

        CleanupStack::PopAndDestroy();

        if ( !iMessagePtr.IsNull() )

            {

            if ( errorCode )    

                { 

                iMessagePtr.WriteL( 1, KNullDesC8, 0 );

                }    

            else

                {

                iMessagePtr.WriteL( 1, iReqNotifData, 0 );   

                }

            }   

        // theres no request message pending until request new one

        iRequestMessage = EhspsClientRequestBase;

        // Send message.    

        CompleteRequestL( aMessage, iMessagePtr );

        iReqNotifParams->ResetData();

        }

    }

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

// ChspsClientRequestHandler::AppendPluginConfigurationsL()

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

//

void ChspsClientRequestHandler::AppendPluginConfigurationsL( 

        ChspsODT& aAppODT )

    {    

    ChspsDomDocument& appDom = aAppODT.DomDocument(); 

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

    CleanupStack::PushL( iter );

    // Each configuration element get's an unique id value - same applies to the plugin elements.

    // The ids are then used for referencing a specific configuration or plug-in instance 

    // in the whole application configuration

    TInt confId = 0;

    TInt pluginId = 0;    

    ChspsDomNode* prevNode = NULL;

    ChspsDomNode* node = iter->First();

    while( node && prevNode != node )

        {