/*

* Copyright (c) 2002-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:  Implementation of HSPS MhspsMaintenanceService interface defined

*                in hspsThemeManagement.h. For details, see header file.

*

*/

#include <centralrepository.h>

#include "hsps_builds_cfg.hrh"

#include "hspsthememanagement.h"

#include "hspsdefinitionrepository.h"

#include "hspsresource.h"

#include "hspsresult.h"

#include "hspspluginidlist.h"

#include "hspsodt.h"

#include "hspsmaintenancehandler.h"

#include "hspsthemeserver.h"

#include "hspsinstallationhandler.h"

#include "hspssecurityenforcer.h"

#include "hspsconfiguration.h"

#include "hspsdomdocument.h"

#include "hspsdomlist.h"

#include "hspsdomdepthiterator.h"

#include "hspsdomnode.h"

#include "hspsdomattribute.h"

#include "hspsmanifest.h"

#include "hspsserverutil.h"

#include "hspsthemeserversession.h"

#ifdef HSPS_LOG_ACTIVE

#include <hspsodtdump.h>

#include <hspslogbus.h>

#endif

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

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

const TInt KAdditionalRequiredDiskSpace = 256 * 1024; /// 256KB in bytes.

// ============================= 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();

        }

    }

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

// ResetAndDestroyArray Callback function for cleaning up the CArrayPtr.

// Returns: void

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

//

LOCAL_C void ResetAndDestroyArray( TAny* aArray )

    {

    reinterpret_cast<CArrayPtrSeg<HBufC>*>( aArray )->ResetAndDestroy();

    }

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

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

// ChspsMaintenanceHandler::ChspsMaintenanceHandler

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

// might leave.

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

//

ChspsMaintenanceHandler::ChspsMaintenanceHandler( 

        ChspsThemeServer& aThemeServer, 

        const TUint aSecureId ): 

    CTimer(EPriorityLow), 

    iThemeServer( aThemeServer ), 

    iSecureId( aSecureId ),

    iCentralRepository( aThemeServer.CentralRepository() ),    

    iDefinitionRepository( aThemeServer.DefinitionRepository() ),

    iSecurityEnforcer( aThemeServer.SecurityEnforcer() ),

    iHeaderListCache( aThemeServer.HeaderListCache() ),

    { 

    iDeliveryCount = 0;

    iSubscription = EFalse;

    }

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

// ChspsMaintenanceService::NewL

// Two-phased constructor.

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

//

ChspsMaintenanceHandler* ChspsMaintenanceHandler::NewL( 

        ChspsThemeServer& aThemeServer,

        const TUint aSecureId )

    {

    ChspsMaintenanceHandler* h = ChspsMaintenanceHandler::NewLC( 

            aThemeServer, aSecureId );

    CleanupStack::Pop(h);

    return (h);

    }

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

// ChspsMaintenanceService::NewLC

// Two-phased constructor.

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

//

ChspsMaintenanceHandler* ChspsMaintenanceHandler::NewLC( 

        ChspsThemeServer& aThemeServer,

        const TUint aSecureId )

    {

    ChspsMaintenanceHandler* h = new (ELeave) ChspsMaintenanceHandler( 

            aThemeServer, aSecureId );

    CleanupStack::PushL(h);

    h->ConstructL();

    return (h);

    }

// Destructor

ChspsMaintenanceHandler::~ChspsMaintenanceHandler()

    {

    Cancel();

    if (iHeaderDataList)

        {

        iHeaderDataList->ResetAndDestroy();

        }

    delete iHeaderDataList;

    delete iSearchMask;

    delete iSetMask;

    delete iResult;

    delete iFileMan;

    iDefinitionRepository.UnregisterObserver( *this );

    }

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

// ChspsMaintenanceHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsMaintenanceHandler::ConstructL()

    {

    // call the base class ConstructL

    CTimer::ConstructL();

    iHeaderDataList = new( ELeave ) CArrayPtrSeg<HBufC8>(KHeaderListGranularity);

    iResult = ChspsResult::NewL();

    // add this timer to the active scheduler   

    CActiveScheduler::Add(this);

    iDefinitionRepository.RegisterObserverL( *this );

    }

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

// ChspsMaintenanceHandler::ServiceGetListHeadersL

// Fetches the header list from repository and writes the first header back to the caller 

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

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

//

void ChspsMaintenanceHandler::ServiceGetListHeadersL(const RMessage2& aMessage)

    {

    // only allow one request to be submitted at a time

    // all synch call must use local message pointer variable

    RMessagePtr2 messagePtr = aMessage;

    ThspsServiceCompletedMessage ret = EhspsGetListHeadersFailed;

    iDeliveryCount = 0;

    if (!IsActive() && !iSubscription)    // first request

        {

        TBuf8<KMaxHeaderDataLength8> searchMaskData;// save a search mask

        messagePtr.ReadL(1,searchMaskData,0);

        // constructing iSearcMask -object

        if (iSearchMask)

            {

            delete iSearchMask;

            iSearchMask = NULL;

            }

        iSearchMask = ChspsODT::NewL();

        iSearchMask->UnMarshalHeaderL(searchMaskData);

        // now there is a subscription

        iSubscription = ETrue;

        // fetch the header list from repository

        ret = hspsGetListHeaders(searchMaskData, *iHeaderDataList);

        if (ret == EhspsGetListHeadersSuccess)

            {

            TInt count = iHeaderDataList->Count();

            // result informs list count in query

            iResult->iIntValue1 = count;

            if ( !count )

                {

                ret = EhspsGetListHeadersEmpty;

                }

            }

        CompleteRequest(ret, messagePtr);    

        }

    else

        {

        iResult->iSystemError = KErrInUse;

        iResult->iSystemError = KErrInUse;

        CompleteRequest( EhspsServiceRequestError, iMessagePtr );

        }

    }

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

// ChspsMaintenanceHandler::ServiceGetNextHeaderL

// Writes back to the caller the next headers in the header list one at a time

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

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

//

void ChspsMaintenanceHandler::ServiceGetNextHeaderL(const RMessage2& aMessage)

    {

    // only allow one request to be submitted at a time

    iRequestMessage = (ThspsServiceRequestMessage) aMessage.Function();

    iCompletedMessage = EhspsGetListHeadersUpdate;

    // now using message pointer as member variable because of asynch call

    iMessagePtr = aMessage;

    if ( !IsActive() && iSubscription)  // requesting next as should

        {

        // is there headers to delivere left

        if (iHeaderDataList->Count() > iDeliveryCount)

            {                                    

            // at least one header on the list

            TPtr8 bufPtr( iHeaderDataList->At(iDeliveryCount)->Des() );

            iMessagePtr.WriteL(2, bufPtr, 0);

            // add list count

            iDeliveryCount++;

            // deliver a list item

            CompleteRequest( EhspsGetListHeadersUpdate, iMessagePtr );

            }

        }

    else

        {

        iResult->iSystemError = KErrInUse;

        iResult->iXuikonError = KErrPermissionDenied;

        CompleteRequest( EhspsServiceRequestError, iMessagePtr );

        }

    }

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

// ChspsMaintenanceHandler::SetServerSession

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

//

void ChspsMaintenanceHandler::SetServerSession(

        ChspsThemeServerSession* aServerSession )

    {

    iServerSession = aServerSession;

    }

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

// ChspsMaintenanceHandler::ServiceSetActiveThemeL

// Sets the active theme and writes back that themes header data

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

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

//    

void ChspsMaintenanceHandler::ServiceSetActiveThemeL(const RMessage2& aMessage)

    {

    ThspsServiceCompletedMessage ret = EhspsSetActiveThemeFailed;

    // using message pointer as a local variable because of a synch call

    RMessagePtr2 messagePtr = aMessage;

    TBuf8<KMaxHeaderDataLength8> setMaskData;

    messagePtr.ReadL(1,setMaskData,0);

    //constructing setMask -object

    if( iSetMask )

        {

        delete iSetMask;

        iSetMask = NULL;

        }

    iSetMask = ChspsODT::NewL();

    iSetMask->UnMarshalHeaderL( setMaskData );

    // calling actual activation

    ChspsODT* odt;

    odt = ChspsODT::NewL();

    CleanupStack::PushL(odt);

    iDefinitionRepository.Lock();

    // In case of error. repository is unlocked    

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

    ret = hspsSetActiveTheme( *iSetMask, *odt );

    if ( ret == EhspsSetActiveThemeSuccess )

        {                

        // Store updated ODT to definition repository

        iDefinitionRepository.SetOdtL( *odt );

        HBufC8* headerdata;

        headerdata = odt->MarshalHeaderL();

        if (headerdata != NULL)

            {

            // Write activated ODT header data to client

            CleanupStack::PushL(headerdata);

            messagePtr.WriteL(2,headerdata->Des(),0);

            CleanupStack::PopAndDestroy(headerdata);

            ThspsRepositoryInfo info( EhspsODTActivated );

            iDefinitionRepository.RegisterNotification( info );

        }

    }

    iDefinitionRepository.Unlock();

    CleanupStack::Pop(&iDefinitionRepository);

    CleanupStack::Pop(odt);

    if (odt)

        {

        delete odt;

        odt = NULL;

        }

    // complete the message

    CompleteRequest(ret, messagePtr );        

    }

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

// ChspsMaintenanceHandler::ServiceRestoreDefaultL

// Restores the default theme according to the information in aMessage and writes 

// back restored themes header data. 

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

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

//    

void ChspsMaintenanceHandler::ServiceRestoreDefaultL( const RMessage2& aMessage )

    {

    ThspsServiceCompletedMessage ret = EhspsRestoreDefaultFailed;

    // using message pointer as a local variable because of synch call

    RMessagePtr2 messagePtr = aMessage;

    // TIpcArgs(TInt aAppUid, &aSetMaskData, &aHeaderData)

    TBuf8<KMaxHeaderDataLength8> setMaskData;

    messagePtr.ReadL( 1, setMaskData, 0 );

    //constructing setMask -object

    if ( iSetMask )

        {

        delete iSetMask;

        iSetMask = NULL;

        }

    iSetMask = ChspsODT::NewL();

    iSetMask->UnMarshalHeaderL( setMaskData );

    ChspsODT* odt;

    odt = ChspsODT::NewL();

    CleanupStack::PushL( odt );

    if ( !iDefinitionRepository.Locked() )

        {

        iDefinitionRepository.Lock();

        // In case of error. repository is unlocked    

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

        // calling actual restoration

        ret = hspsRestoreDefault( *iSetMask, *odt );

        if ( ret == EhspsRestoreDefaultSuccess )

            {

            HBufC8* headerdata;

            headerdata = odt->MarshalHeaderL();

            if (headerdata != NULL)

                {

                CleanupStack::PushL( headerdata );

                messagePtr.WriteL( 2, headerdata->Des(), 0 );

                CleanupStack::PopAndDestroy( headerdata );

                // inform for cache update to the repository so that everyone will know 

                // about the change

                ThspsRepositoryInfo info( EhspsCacheUpdate );

                iDefinitionRepository.RegisterNotification( info );

                }

            }

        iDefinitionRepository.Unlock();

        CleanupStack::Pop(&iDefinitionRepository);

        }

    else

        {

        ret = EhspsRestoreDefaultFailed;

#ifdef HSPS_LOG_ACTIVE  

        if( iLogBus )

            {

            iLogBus->LogText( _L( "ChspsMaintenanceHandler::ServiceRestoreDefaultL(): - failed, repository is locked." ) );

            }

#endif            

        }

    CleanupStack::PopAndDestroy( odt );

    // complete the message

    CompleteRequest( ret, messagePtr );

    }

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

// ChspsMaintenanceHandler::ServiceRemoveThemeL

// Reads ODT from RMessage2 and calls the actual removal method.

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

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

//    

void ChspsMaintenanceHandler::ServiceRemoveThemeL( const RMessage2& aMessage )

    {

    ThspsServiceCompletedMessage ret = EhspsRemoveThemeFailed;

    // using message pointer as a local variable because of synch call

    RMessagePtr2 messagePtr = aMessage;

    // TIpcArgs(TInt aAppUid, &aSetMaskData, &aHeaderData)

    TBuf8<KMaxHeaderDataLength8> setMaskData;

    messagePtr.ReadL( 1, setMaskData, 0 );

    //constructing setMask -object

    if ( iSetMask )

        {

        delete iSetMask;

        iSetMask = NULL;

        }

    iSetMask = ChspsODT::NewL();

    iSetMask->UnMarshalHeaderL( setMaskData );

    // calling actual removal

    ret = hspsRemoveThemeL( *iSetMask );

    // complete the message

    CompleteRequest( ret, messagePtr );

    }

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

// Appends an application configuration with the provided plugin configuration

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

//    

void ChspsMaintenanceHandler::ServiceAddPluginL( const RMessage2& aMessage )

    {

    // Defaults

    ThspsServiceCompletedMessage ret = EhspsAddPluginFailed;

    iResult->iXuikonError = KErrNotFound;

    TInt err = KErrNone;

    // Parameters

    RMessagePtr2 messagePtr = aMessage;

    // IPC slots: 

    // #0) output: externalized ChspsResult for error handling

    // #1) input: ThpsParamAddPlugin struct

    // #2) output: added plugin id

    // Get service parameters from IPC slot #1

    ThpsParamAddPlugin params;        

    TPckg<ThpsParamAddPlugin> packagedStruct(params);    

    aMessage.ReadL(1, packagedStruct);                        

    const TInt appUid = params.appUid;

    const TInt configurationId = params.configurationId;

    const TInt pluginUid = params.pluginUid;

    const TInt newPos = params.positionIndex;    

    // Application configuration

    ChspsODT *appODT = NULL;

    if ( !err )

        {    

        // Get active application configuration from the central repository

        TInt appConfUid;       

        err = iCentralRepository.Get( appUid, appConfUid );

        if ( err || appConfUid < 1 )

            {

            err = KErrNotFound;         

            }

        else

            {

            // Get application configuration

            appODT = ChspsODT::NewL();

            CleanupStack::PushL( appODT );

            err = iThemeServer.GetConfigurationL( 

                    appUid, 

                    appConfUid,

                    *appODT );                                    

            }

        }

    // Plugin configuration

    ChspsODT* pluginODT = NULL;

    if ( !err )

        {

        // Find the plugin configuration (interface is unknown, so 1st argument is set to zero)

        pluginODT = ChspsODT::NewL();

        CleanupStack::PushL( pluginODT );        

        err = iThemeServer.GetConfigurationL( 

                0, 

                pluginUid,

                *pluginODT );

        }

    // Check needed space for addition. Returns system wide error code.

    if( !err )

        {    

        err = hspsServerUtil::EnoughDiskSpaceAvailableL(

                *pluginODT, 

                iThemeServer.DeviceLanguage(),

                iServerSession->FileSystem(),

                EDriveC,

                KAdditionalRequiredDiskSpace );

        }

    // Modifications

    TInt usedConfId = 0;

    TInt usedPluginId = 0;

    if ( !err && appODT && pluginODT )

       {       

           if ( iDefinitionRepository.Locked() )

               {

            // Repository locked