/*

* 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), 

    iLanguage ( aThemeServer.DeviceLanguage() ),

    iThemeServer( aThemeServer ), 

    iSecureId( aSecureId ),

    iCentralRepository( aThemeServer.CentralRepository() ),    

    iDefinitionRepository( aThemeServer.DefinitionRepository() ),

    iSecurityEnforcer( aThemeServer.SecurityEnforcer() ),

    iHeaderListCache( aThemeServer.HeaderListCache() ),

    iFileMan( NULL )

    { 

    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);

        // check the device language

        iLanguage  = iThemeServer.DeviceLanguage();        

 	    iSearchMask->SetOdtLanguage( (TInt)iLanguage );

        // 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)

            {                                    

            // Handle copying of logo icon resources

            CopyIconsToHomescreenL( aMessage.SecureId().iId );

            // 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::CopyIconsToHomescreenL

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

//

void ChspsMaintenanceHandler::CopyIconsToHomescreenL(

        const TUint aAppUid ) 

    {        

    HBufC8* headerData = iHeaderDataList->At(iDeliveryCount);

    ChspsODT* header = ChspsODT::UnMarshalHeaderLC( headerData->Des() );

    if ( iServerSession && header )

        {    

        if( header->LogoFile().Length() )

            {                              

            // If a file reference was found from the logo declaration

            TFileName filename;

            if ( hspsServerUtil::IsFile( header->LogoFile(), filename ) )

                {

                if ( !iFileMan )

                    {                

                    iFileMan = CFileMan::NewL( iServerSession->FileSystem() );

                    }

                // Get client's private directory: 

                // We should use some common directory if there are more than one SAPI clients,

                // for now we can copy files to AI3's private folder

                _LIT( KPrivatePath, "c:\\private\\%X\\");

                TPath privatePath;            

                privatePath.Format( KPrivatePath, aAppUid );                

                // Append private path to the logo file reference

                TInt offset = header->LogoFile().FindF( filename );

                if ( offset >= 0 )

                    {                                      

                    // Insert private path prior to the file reference                    

                    HBufC* logoBuf = HBufC::NewLC( 

                            privatePath.Length() + header->LogoFile().Length() );

                    logoBuf->Des().Copy( header->LogoFile() );

                    logoBuf->Des().Insert( offset, privatePath );

                    header->SetLogoFileL( logoBuf->Des() );

                    CleanupStack::PopAndDestroy( logoBuf );

                    // Replace the serialized header descriptor                    

                    HBufC8* newHeaderData = header->MarshalHeaderL();                    

                    CleanupStack::PushL( newHeaderData );

                    iHeaderDataList->InsertL( 

                           iDeliveryCount,

                           newHeaderData );                       

                    CleanupStack::Pop( newHeaderData );                    

                    delete headerData;

                    headerData = 0;

                    iHeaderDataList->Delete( iDeliveryCount + 1 );

                    }                               

                // Set target directory for file copying

                TPath targetPath;            

                targetPath.Copy( privatePath );

                targetPath.Append( filename );

                // Set source directory for file copying

                TFileName sourceFile;     

                _LIT( KThemesFolder, "themes\\" );

                iServerSession->FileSystem().SessionPath( sourceFile );

                sourceFile.Append( KThemesFolder );                

                sourceFile.Append( filename );

                // Create the target path and copy files when required

                hspsServerUtil::CopyResourceFileL(

                        iServerSession->FileSystem(),

                        *iFileMan, 

                        targetPath,

                        sourceFile );

                }

            }

        }

    CleanupStack::PopAndDestroy( header );

    }

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

// 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 )

    {