/*

* 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:                  

*

*/

#include "hsps_builds_cfg.hrh"

#include <e32base.h>

#include <f32file.h>

#include <bautils.h>

#include "hspsrominstaller.h"

#include "hspsthemeserver.h"

#include "hspsinstallationhandler.h"

#include "hspsclientrequesthandler.h"

#include "hspsserverutil.h"

_LIT( KInstallDirectoryZ, "z:\\private\\200159c0\\install\\" );

_LIT( KHsps, "hsps");

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

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

// ChspsRomInstaller::NewL()

// Two-phased constructor.

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

ChspsRomInstaller* ChspsRomInstaller::NewL( 

		ChspsThemeServer& aThemeServer,

		RFs& aFsSession )

    {

    ChspsRomInstaller* self = NewLC( aThemeServer, aFsSession );

    CleanupStack::Pop( self );

    return( self ) ;

    }

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

// ChspsRomInstaller::NewLC()

// Two-phased constructor.

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

ChspsRomInstaller* ChspsRomInstaller::NewLC( 

		ChspsThemeServer& aThemeServer,

		RFs& aFsSession)

    {

    ChspsRomInstaller* self = new ( ELeave ) ChspsRomInstaller( aThemeServer, aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// ChspsRomInstaller::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void ChspsRomInstaller::ConstructL()

    {    

    iInstallationHandler = ChspsInstallationHandler::NewL( iThemeServer );    

    // Prevent notifications from ROM based installations

    iInstallationHandler->DisableNotifications();

    }

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

// ChspsRomInstaller::ChspsRomInstaller()

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

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

ChspsRomInstaller::ChspsRomInstaller(

		ChspsThemeServer& aThemeServer,

        RFs& aFsSession )

		: CActive(EPriorityStandard), 

		    iThemeServer(aThemeServer), 

		    iFsSession(aFsSession),

		    iRet(EhspsInstallThemeFailed)

    {

    CActiveScheduler::Add( this );

    }

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

// ChspsRomInstaller::~ChspsRomInstaller()

// Destructor.

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

//

ChspsRomInstaller::~ChspsRomInstaller()

    {            

    Cancel(); // Causes call to DoCancel()    

    delete iInstallationHandler; 

    iImportsArrayV1.ResetAndDestroy();    

    }

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

// ChspsRomInstaller::SetImportsFilterL()

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

//

TBool ChspsRomInstaller::SetImportsFilterL(      

        const TDesC& aFileFilter )                        

    {

    TFindFile fileFinder( iFsSession );

    CDir* fileList( NULL );

    fileFinder.FindWildByDir( aFileFilter, KInstallDirectoryZ, fileList );

    if ( fileList )

        {

        CleanupStack::PushL( fileList );

        TFileName sourceName;               

        for( TInt i = 0; i < fileList->Count(); i++ )       

            {

            const TEntry& entry = (*fileList)[i];                        

            sourceName.Copy( KInstallDirectoryZ );          

            sourceName.Append( entry.iName );                   

            iImportsArrayV1.AppendL( sourceName.AllocL() );            

            }

        CleanupStack::PopAndDestroy( fileList );

        fileList = NULL;

        }

    return EFalse;

    }

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

// ChspsRomInstaller::GetInstallationFoldersL()

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

//

void ChspsRomInstaller::GetInstallationFoldersL(  

        RPointerArray<HBufC>& aFolders )

    {

    aFolders.ResetAndDestroy();

    _LIT(KAllFolders, "*");    

    _LIT(KFolderSuffix, "\\");

    CDir* fileList( NULL );    

    TFindFile fileFinder( iFsSession );    

    fileFinder.FindWildByDir( KAllFolders, KInstallDirectoryZ, fileList );        

    if ( fileList )

        {

        CleanupStack::PushL( fileList );

        TFileName sourceName;

        TBool verChecked = EFalse;

        for( TInt i = 0; i < fileList->Count(); i++ )       

            {

            const TEntry& entry = (*fileList)[i];                        

            if ( entry.IsDir() )

                {                                  

                const TEntry& entry = (*fileList)[i];                        

                sourceName.Copy( KInstallDirectoryZ );          

                sourceName.Append( entry.iName );

                sourceName.Append( KFolderSuffix );

                if ( !verChecked )

                    {

                    // Check whether the V2 directory structure is available

                    TFileName nameV2;

                    nameV2.Copy( sourceName );                    

                    nameV2.Append( KHsps );

                    nameV2.Append( KFolderSuffix );

                    if( !BaflUtils::FolderExists( iFsSession, nameV2 ) )

                        {

                        CleanupStack::PopAndDestroy( fileList );

                        return;            

                        }

                    verChecked = ETrue;

                    }

                aFolders.AppendL( sourceName.AllocL() );                    

                }

            }

        CleanupStack::PopAndDestroy( fileList );

        fileList = NULL;

        }            

    }

void ChspsRomInstaller::FindImportsV1L()

    {

    iImportsArrayV1.ResetAndDestroy();

    SetImportsFilterL( KFilterAllPluginImportsV1 );            

    SetImportsFilterL( KFilterAllAppImportsV1 );

    }

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

// ChspsRomInstaller::ImportsV1

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

//

const RPointerArray<HBufC>& ChspsRomInstaller::ImportsV1()

    {

    return iImportsArrayV1;

    }

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

// ChspsRomInstaller::InstallThemeL

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

//

ThspsServiceCompletedMessage ChspsRomInstaller::InstallThemeL( 

		const TDesC& aFileName )

    {            	

    // Start installation by reading the manifest file

    iRet = iInstallationHandler->hspsInstallTheme( aFileName, iHeaderData );    

    if ( iRet == EhspsInstallThemeSuccess && !IsActive() )

        {                

        // Continue with remaining installation phases

        SetActive();

        iInstallationHandler->hspsInstallNextPhaseL( iHeaderData, iStatus );        

        // Wait until the installation phases have been executed (async->sync) 

        CActiveScheduler::Start();

        }

    return iRet;

    }

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

// ChspsRomInstaller::ReinstallThemeL

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

//

ThspsServiceCompletedMessage ChspsRomInstaller::ReinstallThemeL(

        const TInt aAppUid,

        const TInt aConfigurationUid )

    {    

    ThspsServiceCompletedMessage ret = EhspsInstallThemeFailed;

    iImportsArrayV1.ResetAndDestroy();

    if ( aAppUid > 0 && aConfigurationUid > 0 )

        {

        // Setup a filter for finding a specific import

        _LIT(KFormat, "app_%X_*_%X_1.0.dat");    

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

        filter->Des().AppendFormat( KFormat, aAppUid, aConfigurationUid );                        

        SetImportsFilterL( *filter );        

        CleanupStack::PopAndDestroy( filter );

        // There should be only one import matching the UIDs

        if ( iImportsArrayV1.Count() == 1 )

            {           

            // Get path for a manifest from the import's file name

            HBufC* manifestBuf = iThemeServer.GetManifestFromImportLC( 

                    iImportsArrayV1[0]->Des(),

                    KInstallDirectoryZ );

            if ( manifestBuf )

                {         

                // Sync request

                ret = InstallThemeL( manifestBuf->Des() );

                CleanupStack::PopAndDestroy( manifestBuf );

                }

            }

        iImportsArrayV1.ResetAndDestroy();

        }

    // Complete application configuration reinstallation

    ChspsODT* odt = ChspsODT::NewL();

    CleanupStack::PushL( odt );

    User::LeaveIfError( iThemeServer.GetConfigurationL( aAppUid, aConfigurationUid, *odt ) );

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

        {

        // Add plugin configurations to the application configuration

        ChspsClientRequestHandler* clientReqHandler = ChspsClientRequestHandler::NewL( iThemeServer );

        CleanupStack::PushL( clientReqHandler );

        clientReqHandler->HandlePluginReferencesL( *odt );

        CleanupStack::PopAndDestroy( clientReqHandler );

        }

    CleanupStack::PopAndDestroy( odt );

    return ret;

    }

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

// ChspsRomInstaller::SetLogBus()

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

//

#ifdef HSPS_LOG_ACTIVE        

void ChspsRomInstaller::SetLogBus( ChspsLogBus* aLogBus )

    {

    iLogBus = aLogBus;

    iInstallationHandler->SetLogBus( aLogBus );

    }

#endif

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

// ChspsRomInstaller::RunError

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

//

TInt ChspsRomInstaller::RunError( TInt /*aError*/ )

    {

    // Called when error occurred in asynchronous request

    CActiveScheduler::Stop();    

    return KErrNone;

    }  

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

// ChspsRomInstaller::RunL

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

//

void ChspsRomInstaller::RunL()

    {

    iRet = (ThspsServiceCompletedMessage)iStatus.Int();

    switch ( iStatus.Int() )

        {                     

        case EhspsInstallPhaseSuccess:

        	{

        	// Execute next phase of the installation

            if ( !IsActive() )

                {                

                SetActive();

                iInstallationHandler->hspsInstallNextPhaseL( iHeaderData, iStatus  );

                }

        	}

        	break;

        case EhspsInstallThemeSuccess:

        case EhspsInstallThemeFailed:                        

        default:

            {

            // Allow continuation of the InstallTheme function

            CActiveScheduler::Stop();            

            }

        	break;

        }

    }

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

// ChspsRomInstaller::DoCancel()

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

//

void ChspsRomInstaller::DoCancel()

    {

    // Cancels any outstanding operation - nothing to do  

    }

// End of File