/*

* 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:  Service for maintaining contents of the "themes" folder

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <s32mem.h>

#include <sysutil.h>

#include <bautils.h>

#include <centralrepository.h>

#include "hsps_builds_cfg.hrh"

#include "hspsthememanagement.h"

#include "hspsdefinitionrepository.h"

#include "hspsodt.h"

#ifdef HSPS_LOG_ACTIVE

#include <hspslogbus.h>

#endif

// CONSTANTS

const TInt KDefRepArrayGranularity = 5;

_LIT(KImportFolder, "import");

_LIT(KThemesFolder, "themes");

_LIT(KSourceFolder, "sources");

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

_LIT(KLocaleFolder, "locales");

_LIT(KBackupFolder, "backup");

_LIT(KDoubleBackSlash,"\\");

_LIT(KFolderFormat,"%d"); // folder format for localized resources

_LIT(KMatchAll, "*");

_LIT(KMatchSkeleton, ".o0000");

const TInt KTIntMahspsumbers( 11 );

_LIT_SECURITY_POLICY_C1( KPSReadPolicy, ECapabilityReadDeviceData );

_LIT_SECURITY_POLICY_C1( KPSWritePolicy, ECapabilityWriteDeviceData );

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

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

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

// ChspsDefinitionRepository::ChspsDefinitionRepository

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

// might leave.

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

//

ChspsDefinitionRepository::ChspsDefinitionRepository( 

        CRepository& aCentralRepository ) :

        iCacheLastODT( NULL ),

        iCentralRepository( aCentralRepository )

    {        

    }

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

// ChspsDefinitionRepository::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsDefinitionRepository::ConstructL()

    {    

    // Setup RProperty keys for the client applications

    SetupPropertiesL( KPropertyAI3Key );

    SetupPropertiesL( KPropertyMTKey );

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

	//Create private path if it doesn't exist already

	TInt err = iFs.CreatePrivatePath(EDriveC);

	if (err!=KErrNone && err!=KErrAlreadyExists)

		{

		User::Leave(err);	

		}

	HBufC* path = HBufC::NewLC( KMaxFileName );

    TPtr pathPtr = path->Des();

    User::LeaveIfError( iFs.PrivatePath( pathPtr ));     	

	AppendDesCIntoPathL( pathPtr, KImportFolder );

    AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );

    iFs.MkDir( pathPtr );

    CleanupStack::PopAndDestroy( path );

    User::LeaveIfError(iFs.SetSessionToPrivate(EDriveC));

	iLicenseDefault = EFalse;

	iLockSemaphore = 0;

	iTempFileName1 = KNullDesC;

	iTempFileName2 = KNullDesC;

    }

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

// ChspsDefinitionRepository::NewL

// Two-phased constructor.

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

//

EXPORT_C ChspsDefinitionRepository* ChspsDefinitionRepository::NewL(

        CRepository& aCentralRepository )

    {

    ChspsDefinitionRepository* self = 

            new( ELeave ) ChspsDefinitionRepository( aCentralRepository );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

ChspsDefinitionRepository::~ChspsDefinitionRepository()

    {

    iProperty.Close();

    iFs.Close();

    iRepositoryInfoQueue.Reset();

    iRepositoryInfoQueue.Close();

    iObservers.Reset();

    iObservers.Close(); 

    delete iPath;

    delete iCacheLastODT;    

	iTempFileName1 = KNullDesC;

	iTempFileName2 = KNullDesC;    

    }

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

// ChspsDefinitionRepository::SetupPropertiesL

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

//

void ChspsDefinitionRepository::SetupPropertiesL( const TUint aKey )

    {    

    TInt err = RProperty::Define(

        KPropertyHspsCat,

        aKey,

        RProperty::EInt,

        KPSReadPolicy,

        KPSWritePolicy );

    if( err != KErrAlreadyExists && err != KErrNone )

        {

        User::LeaveIfError( err );

        }    

    // Init

    User::LeaveIfError( 

        RProperty::Set( 

            KPropertyHspsCat, 

            aKey, 

            KPropertyKeyDefault ) 

        );

    }

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

// ChspsDefinitionRepository::SetLocaleL

// Saves the dtd-file into the repository.

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

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

EXPORT_C TInt ChspsDefinitionRepository::SetLocaleL( ChspsODT& aODT, ChspsResource& aResource )

    {

    // Populate a path based on ODT attributes and file extension of the resource file

    GetPathL( aODT, EResourceDTD );

    // Results are in iPath, copy resouce file from temp path to a new path in the repository

    TInt errorCode = CopyFileL( aResource.FileName() );

    if ( !errorCode )

    	{

    	// Store the new path

    	aResource.SetFileNameL( iPath->Des() );

    	}

    return errorCode;

    }

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

// ChspsDefinitionRepository::MakeODTPathL

// Creates a path for given ODT.

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

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

EXPORT_C void ChspsDefinitionRepository::MakeODTPathL( ChspsODT& aODT, ChspsResource& aResource )

    {

    // make sure the temporary buffer is empty

    iTempFileName1.Zero();

    // get the path for ODT-resource to store

    GetPathL( aODT, EResourceODT );

   	TPtr ptrPath = iPath->Des();

   	TParsePtr p( ptrPath );	

   	aODT.SetThemeShortNameL(p.Name());

   	// iPath is modified

   	TPtrC pathPtr = iPath->Des();

   	iTempFileName1.Format( _L("%S%S"), &KCDrive, &pathPtr );

    aResource.SetFileNameL( iTempFileName1 ); 

    iTempFileName1.Zero(); 	    

    }

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

// ChspsDefinitionRepository::SetOdtL

// Saves the odt-structure into the repository.

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

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

//

EXPORT_C TInt ChspsDefinitionRepository::SetOdtL( const ChspsODT &aODT )

    {

    TInt ret = KErrGeneral;

#ifdef HSPS_LOG_ACTIVE

    if( iLogBus )

        {

        iLogBus->LogText( _L( "ChspsDefinitionRepository::SetOdtL(): - rewriting the binary file." ) );

        }

#endif

    GetPathL( aODT, EResourceODT );

    ret = WriteToFileL( aODT);

#ifdef HSPS_LOG_ACTIVE

    if( iLogBus )

        {

        iLogBus->LogText( _L( "ChspsDefinitionRepository::SetOdtL(): - rewriting done. return code: %d." ), ret );

        }

#endif

    if( aODT.ConfigurationType() == EhspsAppConfiguration )

        {

        delete iCacheLastODT;

		iCacheLastODT = NULL;        

        iCacheLastODT = aODT.CloneL();              

        // Check whether we updated active application configuration

        TInt configurationUid = -1;

        User::LeaveIfError( 

            iCentralRepository.Get( iCacheLastODT->RootUid(), configurationUid ) 

            );

        if( configurationUid == aODT.ThemeUid() )

            {            

            const TUint key = iCacheLastODT->RootUid();

            // Get current value

            TInt version( 0 );

            User::LeaveIfError( 

                RProperty::Get( 

                        KPropertyHspsCat, 

                        key, 

                        version ) 

                    );

            // Increment the version, each client session should update the ODT copies            

            version++;

            if( version < 1 )

                {

                version = 1;

                }                                

            User::LeaveIfError( 

                RProperty::Set( 

                        KPropertyHspsCat, 

                        key, 

                        version ) 

                    );

            }

        }

    return ret;

    }

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

// ChspsDefinitionRepository::GetOdtL

// Retrieves the odt-structure from the repository as a reference.

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

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

//

EXPORT_C TInt ChspsDefinitionRepository::GetOdtL( ChspsODT& aODT )

    {

    TInt errorCode = KErrNone;

    if ( aODT.Flags() & EhspsThemeStatusLicenceeDefault )

		{

		iLicenseDefault = ETrue;

		}

	else

		{

		iLicenseDefault = EFalse;		

		}

    if( iCacheLastODT &&

        iCacheLastODT->RootUid() == aODT.RootUid() &&

        iCacheLastODT->ThemeUid() == aODT.ThemeUid() )  

        {

        aODT.CloneL( *iCacheLastODT );

        }

    else       

        {    

        TRAP( errorCode, GetPathL( aODT, EResourceODT ));

        if ( !errorCode )

            {

            errorCode = ReadFromFileL( *iPath, aODT ); 

            }         

        }

    iLicenseDefault = EFalse;

    return errorCode;

    }

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

// ChspsDefinitionRepository::GetOdtHeaderL

// Retrieves the odt-structure from the repository as a reference.

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

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

//

EXPORT_C TInt ChspsDefinitionRepository::GetOdtHeaderL( TDes& aPath, TLanguage /*aLang*/, ChspsODT& aODT )

    {    

    TInt err( KErrNotFound );

    CDesCArraySeg* themeList = new ( ELeave ) CDesCArraySeg( KDefRepArrayGranularity );

    CleanupStack::PushL( themeList );

    SelectFilesFromPathL( *themeList, aPath, ESortByDate, KMatchSkeleton );

    if( themeList->MdcaCount() > 0 )

        {

        TPtrC name = themeList->MdcaPoint( 0 );

        if ( name.FindF( KSourceFolderWithSeperators ) == KErrNotFound )

        	{

	        HBufC8* header( StreamHeaderFromFileL( name ) );

	        CleanupStack::PushL( header );

	        if( header )

	            {

	            aODT.UnMarshalHeaderL( *header );            

	            err = KErrNone;

	            }

	        CleanupStack::PopAndDestroy( header );            

        	}

        }

    CleanupStack::PopAndDestroy( themeList );

    User::LeaveIfError( err );

    return err;

    }

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

// ChspsDefinitionRepository::GetODTPathL

// Retrieves the path of given ODT.

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

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

//

EXPORT_C void ChspsDefinitionRepository::GetResourcePathL( const ChspsODT& aODT, ThspsResourceType aResourceType, TDes& aFilePath )

    {

    // get the path for source resources to store

    GetPathL( aODT, aResourceType );

    TPtrC ptr = iPath->Des();

	// modifying the resource file path on the resource

	aFilePath.Format( _L("%S%S"), &KCDrive, &ptr );

    }    

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

// ChspsDefinitionRepository::GetThemePathListL

// Retrieves the list of installed themes.

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

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

EXPORT_C void ChspsDefinitionRepository::GetThemePathListL( CDesCArraySeg& aThemeList, const ChspsODT& aODT )

    {    

    CDesCArraySeg* pathList = new( ELeave ) CDesCArraySeg(KDefRepArrayGranularity);

    CleanupStack::PushL( pathList );

    CDesCArraySeg* tempPathList = new( ELeave ) CDesCArraySeg(KDefRepArrayGranularity);

    CleanupStack::PushL( tempPathList );

    // The "themes" folder must exist at this point (C drive)

    _LIT( KDriveC, "C:" );

    TFileName themesPath;

    User::LeaveIfError( iFs.PrivatePath( themesPath ));

    HBufC* path = HBufC::NewLC( KMaxFileName );

    TPtr pathPtr = path->Des();        

    AppendDesCIntoPathL( pathPtr, KDriveC );    

    AppendDesCIntoPathL( pathPtr, themesPath );

    AppendDesCIntoPathL( pathPtr, KThemesFolder );

    AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );    

    // Allocate memory for the folder name to be found (uid folder)

    HBufC* match = HBufC::NewLC( KTIntMahspsumbers );

    TPtr matchPtr = match->Des();

    // Setup a mask from the search criterias     

    TInt8 rootUid = aODT.RootUid() ? 1 : 0;

    TInt8 provUid = aODT.ProviderUid() ? 2 : 0;

    TInt8 themeUid = aODT.ThemeUid() ? 4 : 0;

    TInt8 mask = rootUid | provUid | themeUid;

    TInt index( 0 );

    switch ( mask )

        {

        case 0://No data in ODT.

            {

            MatchingFoldersFromAllDrivesL( KMatchAll, pathPtr, *pathList );

            }

            break;

        case 1://AppUid given.

        case 3://AppUid and ProviderUid given.

        case 7://AppUid, ProviderUid and ThemeUid given.

            {

            if ( aODT.RootUid() )

                {

                AppendNumIntoPathL( pathPtr, aODT.RootUid() );

                AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );

                }            

            if ( aODT.ProviderUid() )

                {

                AppendNumIntoPathL( pathPtr, aODT.ProviderUid() );

                AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );

                }                

            if ( aODT.ThemeUid() )

                {

                AppendNumIntoPathL( pathPtr, aODT.ThemeUid() );

                AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );

                }

            MatchingFoldersFromAllDrivesL( KMatchAll, pathPtr, *pathList );

            }

            break;

        case 2://ProviderUid given.

            {

            MatchingFoldersFromAllDrivesL( KMatchAll, pathPtr, *tempPathList );

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.ProviderUid() );

            for ( index = 0; index < tempPathList->Count(); index++ )

                {

                MatchingFoldersL( *match, tempPathList->MdcaPoint( index ), *pathList );

                }

            }

            break;

        case 4://ThemeUid given.

            {

            MatchingFoldersFromAllDrivesL( KMatchAll, pathPtr, *pathList );

            for ( index = 0; index < pathList->Count(); index++ )

                {

                MatchingFoldersL( *match, pathList->MdcaPoint( index ), *tempPathList );

                }

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.ThemeUid() );

            pathList->Reset();

            for ( index = 0; index < tempPathList->Count(); index++ )

                {

                MatchingFoldersL( *match, tempPathList->MdcaPoint( index ), *pathList );

                }

            }

            break;

        case 6://ProviderUid and ThemeUid given.

            {

            MatchingFoldersFromAllDrivesL( KMatchAll, pathPtr, *pathList );

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.ProviderUid() );

            for ( index = 0; index < pathList->Count(); index++ )

                {

                MatchingFoldersL( *match, pathList->MdcaPoint( index ), *tempPathList );

                }

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.ThemeUid() );

            pathList->Reset();

            for ( index = 0; index < tempPathList->Count(); index++ )

                {

                MatchingFoldersL( *match, tempPathList->MdcaPoint( index ), *pathList );

                }

            }

            break;

        case 5://AppUid and ThemeUid given.

            {

            // Get paths matching the 1st argument into pathList array

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.RootUid() );

            MatchingFoldersFromAllDrivesL( *match, pathPtr, *pathList );

            // From previous results, match and store results into tempPathList array

            matchPtr.Zero();

            matchPtr = KMatchAll;

            for ( index = 0; index < pathList->Count(); index++ )

                {

                MatchingFoldersL( *match, pathList->MdcaPoint( index ), *tempPathList );

                }

            // From previous results, find mathing plugins and store them back to the pathList

            matchPtr.Zero();

            matchPtr.AppendNum( aODT.ThemeUid() );

            pathList->Reset();

            for ( index = 0; index < tempPathList->Count(); index++ )

                {

                MatchingFoldersL( *match, tempPathList->MdcaPoint( index ), *pathList );

                }

            }

            break;

        default:

            {

            pathList->AppendL( pathPtr );

            }

            break;

        }

    TInt err( KErrNotFound );

    for ( TInt i = 0; i < pathList->MdcaCount(); i++ )

        {

        err = MatchingFoldersL( KMatchAll, pathList->MdcaPoint(i), *pathList );