/*

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

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

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

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

// ChspsDefinitionRepository::ChspsDefinitionRepository

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

// might leave.

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

//

ChspsDefinitionRepository::ChspsDefinitionRepository()

    {

    }

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

// ChspsDefinitionRepository::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsDefinitionRepository::ConstructL()

    {

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

    {

    ChspsDefinitionRepository* self = new( ELeave ) ChspsDefinitionRepository;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

ChspsDefinitionRepository::~ChspsDefinitionRepository()

    {

    iFs.Close();

    iRepositoryInfoQueue.Reset();

    iRepositoryInfoQueue.Close();

    iObservers.Reset();

    iObservers.Close(); 

    delete iPath;

	iTempFileName1 = KNullDesC;

	iTempFileName2 = KNullDesC;    

    }

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

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

    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;		

		}

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

        if ( err == KErrNotFound )

            {

            TPtrC pathPtr = pathList->MdcaPoint(i);

           	aThemeList.AppendL( pathPtr );	

            }

        }

    CleanupStack::PopAndDestroy( 4, pathList );//path, match, pathList, tempPathList

    }

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

// ChspsDefinitionRepository::GetThemeListAsStreamL

// Retrieves the headers of installed themes as an array of streams.

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

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

//

EXPORT_C void ChspsDefinitionRepository::GetThemeListAsStreamL( CArrayPtrSeg<HBufC8>& aHeaderList, const ChspsODT& aODT )

    {

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

    CleanupStack::PushL( pathList );

    GetThemePathListL( *pathList, aODT );

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

    CleanupStack::PushL( themeList );

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

        {

        SelectFilesFromPathL( *themeList,  pathList->MdcaPoint( i ), ESortByDate, KMatchSkeleton );

        }

    for ( TInt j = 0; j < themeList->MdcaCount(); j++ )

        {

        TPtrC ptr( themeList->MdcaPoint( j ) );

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

        	{

	        HBufC8* temp = StreamHeaderFromFileL( themeList->MdcaPoint( j ) );

	        if ( temp )

	            {

	            aHeaderList.AppendL( temp );         

	            }

        	}

        }

    CleanupStack::PopAndDestroy( 2, pathList );//themeList, pathList

    }

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

// ChspsDefinitionRepository::RemoveThemeL

// Removes the specified theme.

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

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

EXPORT_C void ChspsDefinitionRepository::RemoveThemeL( const ChspsODT& aODT )

    {

    GetPathL( aODT, EResourceNone );

    RemoveDirectoryL();

    // theme removal is not informed to the clients through RepositoryInfoArray 

    // because this function is used also by the theme server's clean up functions - 

    // and it not necessary inform about them.

    // insteads, maintenance handler does inform the removal.

    }

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

// ChspsDefinitionRepository::MakeResourcePathL

// Makes a path in the repository that can be used to store the resource file. 

// The path is written back into aResource  

// The path depends on the locale under which the resource belongs.

// The path information will be used to retrieve the source later.

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

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

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

	{

    // get the path for source resources to store (results are stored into the iPath instance)

    GetPathL( aODT, aResource.ResourceType() );

    TPtr pathPtr = iPath->Des();

    // If the resource is of type "Other" then skip renaming of the file extension

    if ( aResource.ResourceType() == EResourceOther )

    	{

    	if ( aResource.Language() != ELangNone )

    	    {    	    

    	    AddLocalePathL( pathPtr, aODT.OdtLanguage() );

    	    AppendDesCIntoPathL( pathPtr, KDoubleBackSlash );

    	    }

    	// Append the iPath with the resource name

    	AppendDesCIntoPathL( pathPtr, aResource.ResourceId() );

    	// Append with original file extension or fix it

    	const TDesC& name = aResource.FileName();

    	TParsePtr parsePtr( (TDes&)name );		   				

        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 )