/*

* 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(KPrivateInstall, "\\private\\200159c0\\install\\");

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

_LIT(KXuikon, "xuikon" );

const TInt KMaxMediaTypeLength = 100;

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

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

// CleanupResetAndDestroy()

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

//

template<class T>

static void CleanupResetAndDestroy( TAny* aObj )

    {

    if( aObj )

        {

        static_cast<T*>( aObj )->ResetAndDestroy();

        }

    }

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

// CleanupResetAndDestroyPushL

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

//

template<class T>

static void CleanupResetAndDestroyPushL(T& aArray)

    {

    CleanupStack::PushL( TCleanupItem( &CleanupResetAndDestroy<T>, &aArray ) );

    }

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

    iTrustedInstallation = EFalse;

	iInstallationType = EInstallationTypeNew;

	iInstallFromUDAEmmc = ETrue;

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

    {

    iThemeFilePath.FillZ();    

    iFamilyMask = 0;

    iInstallationPhase = EhspsPhaseInitialise;    

    iThemeStatus = EhspsThemeStatusNone;

    iTrustedInstallation = EFalse;

    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 = 0;    

    iResult->iIntValue2 = 0;

    TRAPD( err, DoInstallThemeL(aManifestFileName) );

    if( !err )

        {

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

        aHeaderData = iHeaderData->Des();        

        // Set next phase

        iInstallationPhase = EhspsPhaseCleanup;

        ret = EhspsInstallThemeSuccess;

        }

    else

        {     

#ifdef HSPS_LOG_ACTIVE  

        if( iLogBus )

            {

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

                    err );

            }

#endif       

        }

    iResult->iSystemError = err;

    return ret;

    }

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

// ChspsInstallationHandler::DoInstallThemeL()

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

void ChspsInstallationHandler::DoInstallThemeL(

        const TDesC& aManifest )

    {        

    // Reset memeber variables    

    ResetL();

    TParsePtrC parsePtr( aManifest );        

    // Store the path to the installation file     

    __ASSERT_DEBUG( aManifest.Length() < KMaxFileName, User::Leave( KErrBadName ) );

    iThemeFilePath.Copy( parsePtr.DriveAndPath() );    

    // If trying to install widgets from one of our private install directories

    const TPath path = parsePtr.Path();

    if( path.Length() > KPrivateInstall().Length() 

            && path.Left( KPrivateInstall().Length() ) == KPrivateInstall() ) 

        {                    

        // Check if ROM or UDA installation was requested

        if( parsePtr.DrivePresent() )

            {            

            TInt driveNumber;

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

                {

                iTrustedInstallation = ( driveNumber == EDriveZ || driveNumber == EDriveC );                

                }

            }

        }    

    if( !BaflUtils::FileExists( iFsSession, aManifest ) )

        {

#ifdef HSPS_LOG_ACTIVE    

        if ( iLogBus )

            {           

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

            }

#endif    

        User::Leave( KErrNotFound );

        }

#ifdef HSPS_LOG_ACTIVE    

    if ( iLogBus )

        {            

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

        }

#endif       

    // Parse XML from the manifest file

    Xml::ParseL( *iXmlParser, iFsSession, aManifest );    

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

    // OnContent(), OnStartElement() and OnEndElement()

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

    if( !iTrustedInstallation )

        {

        // Check type of installation        

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

            }

        }                

    // Check the parsed input        

    FinalizeParsingL();                    

    }

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

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

        path.Append( KPathDelim );

        }

    return path;

    }