/*

* 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:  Implementaion of HSPS MhspsInstallationService interface defined 

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

*

*/

#include <bautils.h>

#include <utf.h>

#include <centralrepository.h>

#include "hsps_builds_cfg.hrh"

#include "hspsthememanagement.h"

#include "hspsdefinitionrepository.h"

#include "hspsodt.h"

#include "hspsdefinitionengineinterface.h"

#include "hspsdomdocument.h"

#include "hspsresource.h"

#include "hspsresult.h"

#include "hspsthemeserver.h"

#include "hspsinstallationhandler.h"

#include "hspssecurityenforcer.h"

#include "hspsuimanagererrorcodes.h"

#include "hspsdomattribute.h"

#include "hspsdomlist.h"

#include "hspsdomdepthiterator.h"

#include "hspsdomnode.h"

#include "hspsconfiguration.h"

#include "hspsmanifest.h"

#include "hspsserverutil.h"

#include "hspsfamilylistener.h"

#ifdef HSPS_LOG_ACTIVE

#include <hspsodtdump.h>

#include <hspslogbus.h>

#endif

#ifdef _hsps_PERFORMANCE_TEST_

#include "hspstimemon.h"

#endif

_LIT8(KUnknownMimeType, "unknown");    

_LIT8(KhspsDefinitionEngine, "hspsdefinitionengine");

_LIT(KPathDelim, "\\");

_LIT(KHsps, "\\hsps\\" );

_LIT(KXuikon, "xuikon\\" );

const TInt KMaxMediaTypeLength = 100;

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

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

// Callback function for removing repository lock if error occurs while repository is locked

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

//

LOCAL_C void UnlockRepository( TAny* aObject )

    {

    ChspsDefinitionRepository* DefRep = reinterpret_cast<ChspsDefinitionRepository*>( aObject );

    if (DefRep->Locked())

        {

        DefRep->Unlock();

        }

    }

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

// ChspsInstallationHandler::ChspsInstallationHandler()

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

// might leave.

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

//

ChspsInstallationHandler::ChspsInstallationHandler( ChspsThemeServer& aThemeServer )

    : iThemeServer( aThemeServer ), 

    iDefinitionRepository( aThemeServer.DefinitionRepository() ),

    iSecurityEnforcer( aThemeServer.SecurityEnforcer() ),    

    iCentralRepository( aThemeServer.CentralRepository() ),

    iHeaderListCache( aThemeServer.HeaderListCache() )

    {     

    iPackageVerSupported = EFalse;

    iInstallationPhase = EhspsPhaseIdle;

    iConfigurationType = EhspsAppConfiguration;

    iThemeStatus = EhspsThemeStatusNone;

    iFileNotFound = EFalse;

    iLocalized = EFalse;             

    iDefaultSpecificationSet = EFalse;

    iDefaultSpecification = ELangNone;

    iInstallationMode = EServiceHandler;

    iRomInstallation = EFalse;

	iInstallationType = EInstallationTypeNew;

	iFamilyMask = 0;

    }

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

// ChspsInstallationHandler::NewL

// Two-phased constructor.

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

//

ChspsInstallationHandler* ChspsInstallationHandler::NewL( ChspsThemeServer& aThemeServer )

    {

    ChspsInstallationHandler* h = ChspsInstallationHandler::NewLC( aThemeServer );

    CleanupStack::Pop( h );

    return ( h );

    }

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

// ChspsInstallationHandler::NewL

// Two-phased constructor.

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

//

ChspsInstallationHandler* ChspsInstallationHandler::NewLC( ChspsThemeServer& aThemeServer )

    {

    ChspsInstallationHandler* h = new (ELeave) ChspsInstallationHandler( aThemeServer );

    CleanupStack::PushL( h );

    h->ConstructL();

    return ( h );

    }

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

// Destructor

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

//

ChspsInstallationHandler::~ChspsInstallationHandler()

    {        

    iFsSession.Close();

    delete iXmlParser;

    delete iOdt;

    delete iDtdFile;

    delete iHeaderData;

    delete iThemeFullName;

    delete iThemeShortName;

    delete iThemeVersion;

    delete iThemeDesc;

    delete iResourceTag;

    delete iPackageVersion;

    if ( iTempLocalizedResourceList )

        {

        iTempLocalizedResourceList->ResetAndDestroy();

        delete iTempLocalizedResourceList;

        }

    if( iResourceList )

        {

        iResourceList->Reset(); // ODT has an ownership of the items

        delete iResourceList;

        }

    delete iContent;

    delete iXmlFile;

    delete iMediaType;

    delete iResource;

    delete iResult;

    if ( iDefEngine )

        {

        delete iDefEngine;

        }

    REComSession::FinalClose(); 

    }

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

// ChspsInstallationHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsInstallationHandler::ConstructL()

    {

    _LIT8(KMimeType, "text/xml");

    MContentHandler* contentHandler = this;

    iXmlParser = Xml::CParser::NewL( KMimeType, *contentHandler );

     iDefEngine = ChspsDefinitionEngineInterface::NewL(KhspsDefinitionEngine);

    iOdt = ChspsODT::NewL();

    iResourceList = new( ELeave ) CArrayPtrSeg<ChspsResource>( KPathListGranularity ); 

    iTempLocalizedResourceList = new( ELeave ) CArrayPtrSeg<ChspsResource>( KPathListGranularity );

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

    iResult = ChspsResult::NewL();

    iMultiInstanceFound = EFalse;

    }

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

// ChspsInstallationHandler::ServiceInstallThemeL

// Starts the actual installation in ChspsInstallationHandler.

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

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

//

void ChspsInstallationHandler::ServiceInstallThemeL( const RMessage2& aMessage )

    {    

 	// incoming arguments: TIpcArgs: &iResultData, &aManifestFileName, &aHeader

 	iMessagePtr = aMessage;

 	TBuf8<KMaxHeaderDataLength8> headerdata;

	iInstallationPhase = EhspsPhaseIdle;

	ThspsServiceCompletedMessage ret = EhspsInstallThemeFailed;

    if ( !iDefinitionRepository.Locked() )

        {

        // read name of the manifest file

        TBuf<KMaxHeaderDataLength8> manifestfilename;                

        iMessagePtr.ReadL( 1, manifestfilename, 0 );

#ifdef HSPS_LOG_ACTIVE  

        if( iLogBus )

            {

            iLogBus->LogText( _L( "ChspsInstallationHandler::ServiceInstallThemeL() - Manifest file '%S'" ),

                    &manifestfilename );

            }

#endif        

		// install the manifest file

		ret = hspsInstallTheme( manifestfilename, headerdata );

		// now there will be the time for query validity check

		if ( ret == EhspsInstallThemeSuccess )

			{

   		    ret = EhspsInstallPhaseSuccess;

            }

        }

       else

        {

        iResult->ResetData();

        iResult->iSystemError = KErrInUse;

        } 

    CompleteRequestL(ret, headerdata);

    }

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

// ChspsInstallationHandler::ServiceInstallNextPhaseL

// Starts subsequent installation phases.

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

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

//

void ChspsInstallationHandler::ServiceInstallNextPhaseL( const RMessage2& aMessage )

    {        

#ifdef HSPS_LOG_ACTIVE  

    if( iLogBus )

        {

        iLogBus->LogText( _L( "ChspsInstallationHandler::ServiceInstallNextPhaseL():" ) );

        }

#endif

    TBuf8<KMaxHeaderDataLength8> headerdata;

    iResult->ResetData();

    iInstallationMode = EServiceHandler;

    ThspsServiceCompletedMessage ret = EhspsInstallThemeFailed;

    // incoming arguments: TIpcArgs: &iResultData, &KNullDesC, &aHeaderData    

    iMessagePtr = aMessage;

    // calling installation of next phase

    ret = hspsInstallNextPhaseL( headerdata );

    CompleteRequestL( ret, headerdata );        

    }

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

// ChspsInstallationHandler::InstallNextPhase()

// Must be completed by EhspsInstallThemeSuccess, EhspsInstallPhaseSuccess or EhspsInstallThemeFailed 

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

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

//

void ChspsInstallationHandler::hspsInstallNextPhaseL( 

        TDes8& aHeaderData, 

        TRequestStatus& aRequestStatus )

    {

    ThspsServiceCompletedMessage ret = EhspsServiceNotSupported;

    iInstallationMode = EAsynchronousObject;

    iRequestStatus = &aRequestStatus;

    *iRequestStatus = KRequestPending;

    ret = hspsInstallNextPhaseL( aHeaderData );

    CompleteRequestL( ret );

    }

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

// ChspsInstallationHandler::ResetL()

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

void ChspsInstallationHandler::ResetL()

    {

    iFamilyMask = 0;

    iInstallationPhase = EhspsPhaseInitialise;    

    iThemeStatus = EhspsThemeStatusNone;  

    iFileNotFound = EFalse;

    delete iMediaType;

    iMediaType = NULL;

    delete iThemeDesc;

    iThemeDesc = NULL;

    delete iResourceTag;

    iResourceTag = NULL;

    iLocalized = EFalse;    

    iDefaultSpecificationSet = EFalse;

    iDefaultSpecification = ELangNone;

    if ( iOdt )

       {

       delete iOdt;

       iOdt = NULL;

       iOdt = ChspsODT::NewL();

       }

    delete iDtdFile;

    iDtdFile = NULL;

    delete iHeaderData;

    iHeaderData = NULL;

    if ( iDefEngine )

       {

       delete iDefEngine; 

       iDefEngine = NULL;

       iDefEngine = ChspsDefinitionEngineInterface::NewL(KhspsDefinitionEngine);

       }   

    if ( iResourceList )

       {

       iResourceList->Reset(); // ODT has an ownership of the items

       delete iResourceList;

       iResourceList = NULL;

       iResourceList = new( ELeave ) CArrayPtrSeg<ChspsResource>( KPathListGranularity ); 

       }    

    if ( iTempLocalizedResourceList )

       {

       iTempLocalizedResourceList->ResetAndDestroy(); 

       delete iTempLocalizedResourceList;

       iTempLocalizedResourceList = NULL;

       iTempLocalizedResourceList = new( ELeave ) CArrayPtrSeg<ChspsResource>( KPathListGranularity );

       }

    iInstallationType = EInstallationTypeNew;

    }

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

// ChspsInstallationHandler::hspsInstallTheme()

// From MhspsInstallationService 

// Must be completed by EhspsInstallThemeSuccess, EhspsInstallPhaseSuccess or EhspsInstallThemeFailed 

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

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

//

ThspsServiceCompletedMessage ChspsInstallationHandler::hspsInstallTheme(

        const TDesC& aManifestFileName, 

        TDes8& aHeaderData)

    {

    // Assume that the installation fails

    ThspsServiceCompletedMessage ret = EhspsInstallThemeFailed;           

    iResult->iXuikonError = KErrManifestFileCorrupted;

    // Reset memeber variables

    TInt errorCode = KErrNone;

    TRAP( errorCode, ResetL() );

    if ( !errorCode )

        {        

        // Get manifest file path

        iThemeFilePath.Set( TParsePtrC( aManifestFileName ).DriveAndPath() );

        // Check if ROM installation is requested

        iRomInstallation = EFalse;

        TParse driveParser;

        driveParser.Set( iThemeFilePath, NULL, NULL );

        TInt driveNumber;

        if ( RFs::CharToDrive( driveParser.Drive()[0], driveNumber ) == KErrNone )

            {

            if ( driveNumber == EDriveZ )

                {

                iRomInstallation = ETrue;

                }

            }

#ifdef HSPS_LOG_ACTIVE    

        if ( iLogBus )

            {            

            iLogBus->LogText( _L( "ChspsInstallationHandler::hspsInstallTheme() - *** Parsing a manifest file:" ) );

            }

#endif       

        if( BaflUtils::FileExists( iFsSession, aManifestFileName ) )

             {

             // Parse XML from the manifest file

             TRAP( errorCode, Xml::ParseL( *iXmlParser, iFsSession, aManifestFileName ));     

             }        

        else

            {

#ifdef HSPS_LOG_ACTIVE    

            if ( iLogBus )

                {           

                iLogBus->LogText( _L( "ChspsInstallationHandler::hspsInstallTheme() - Manifest was not found!" ) );

                }

#endif            

            iFileNotFound = ETrue;

            errorCode = KErrNotFound;

            }

        }

    if ( !errorCode && !iFileNotFound )

        {        

        // The manifest file has been read at this point and following callbacks have been executed:

        // (unless the manifest was invalid): OnContent, OnStartElement, OnEndElement

        // Detect installation type.

        // Performance optimization: do not check if installing from rom.

        if( !iRomInstallation )

            {

            // Check type of installation

            TBool instancesFound = EFalse;

            TRAP( errorCode, instancesFound = IsPluginUsedInAppConfsL() );            

            if( iThemeServer.PluginInHeaderCache( TUid::Uid( iThemeUid ) ) && instancesFound )                    

                {

                // Plugin should be found from cache, update notifications are

                // sent only when plugins are used by one/more app configurations

                iInstallationType = EInstallationTypeUpdate;

                }

            else

                {

                iInstallationType = EInstallationTypeNew;

                }

            }                

        if ( !errorCode )

            {

            // Check the manifest        

            TRAP( errorCode, ValidateL() );

            }

        if ( !errorCode )

            {

            // correct headerdata is in iHeaderData set by CheckHeaderL()

            aHeaderData = iHeaderData->Des();

            ret = EhspsInstallThemeSuccess;

            // Set next phase

            iInstallationPhase = EhspsPhaseCleanup;

            // number of all resources to iResult

            iResult->iIntValue2 = 0;

            }

        }

    if ( errorCode )

        {     

#ifdef HSPS_LOG_ACTIVE  

        if( iLogBus )

            {

            iLogBus->LogText( _L( "ChspsInstallationHandler::hspsInstallTheme(): - Installation failed with error code %d" ),

                    errorCode );

            }

#endif              

        }

    iResult->iSystemError = errorCode;

    return ret;

    }

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

// ChspsInstallationHandler::GetInterfacePath() 

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

//

TFileName ChspsInstallationHandler::GetInterfacePath()

    {        

    TFileName path;

    TParse pathParser;

    pathParser.Set( iThemeFilePath, NULL, NULL );                               

    pathParser.PopDir(); // pop locale specific folder  

    TPtrC parentFolder = pathParser.FullName().Mid( pathParser.FullName().Length() - KHsps().Length() );

    if ( parentFolder.CompareF(KHsps) == 0 )

        {

        pathParser.PopDir(); // pop "hsps" folder 

        path.Copy( pathParser.FullName() );

        path.Append( KXuikon );        

        }

    return path;

    }

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

// ChspsInstallationHandler::ValidateL() 

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

//

void ChspsInstallationHandler::ValidateL()

    {                                    

    TFileName interfacePath( GetInterfacePath() );       

    if ( interfacePath.Length() )        

       {

       // If name of the DTD file was specified in the manifest

       if ( iDtdFile )

          { 

          TParse pathParser;

          pathParser.Set( iThemeFilePath, NULL, NULL );                               

          pathParser.PopDir(); // pop locale specific folder

          // Find locale specific DTD file

          AddHspsLocalesV2L( pathParser.FullName() );

          }

       // Find Xuikon resources of each locale 

       AddInterfaceResourcesV2L( interfacePath );

       }

    else

       {

       // Find DTD files and locale specific resources from subdirectories under the installation path

       AddLocalesL( iThemeFilePath );                       

       }       

   // Validate input from the manifest

   CheckHeaderL();

   if ( iSecurityEnforcer.CheckThemeLockingL( *iOdt ) )

       {

       iResult->iXuikonError = KErrThemeStatusLocked;    

#ifdef HSPS_LOG_ACTIVE  

       if( iLogBus )

           {

           iLogBus->LogText( _L( "ChspsInstallationHandler::ValidateL(): - CheckThemeLockingL" ) );

           }

#endif              

       User::Leave( KErrAccessDenied );