/*

* 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:  HSPS Theme Server. For more information, see the header.

*

*/

#define __INCLUDE_CAPABILITY_NAMES__

// INCLUDE FILES

#include <mw/MemoryManager.h>

#include <centralrepository.h>

#include <f32file.h>

#include <bautils.h>

#include <sbdefs.h>

#include <sysversioninfo.h>

#include <sysutil.h>

#include "hsps_builds_cfg.hrh"

#include "hspsthemeserver.h"

#include "hspsthemeserversession.h"

#include "hspssecurityenforcer.h"

#include "hspsserverutil.h"

#include "hspsdefinitionrepository.h"

#include "hspsdefinitionengineinterface.h"

#include "hspsconfiguration.h"

#include "hspsfamily.h"

#ifdef _hsps_PERFORMANCE_TEST_

#include "hspstimemon.h"

#endif //_hsps_PERFORMANCE_TEST_

#ifndef __DISABLE_SISX_INSTALLATION_

#include "hspsrominstaller.h"

#include "hspsautoinstaller.h"

#include "hspsinstaller.h"

#include "hspsinstallationhandler.h"

#endif //__DISABLE_SISX_INSTALLATION_

#ifdef HSPS_LOG_ACTIVE

#include <hspsodtdump.h>

#include <hspslogbusfile.h>

#endif

// CONSTANTS

// Directories for backup folders

_LIT( KBackupThemesDirectoryC, "c:\\private\\200159c0\\backup\\themes\\" );

// Name of the installation file

_LIT( KManifestFile, "manifest.dat" );

// Name of the configuration file

_LIT( KConfFile, "*.o0000" );

// File prefixes for the *.DAT imports

_LIT( KPrefixFileApp, "app_");

_LIT( KPrefixFilePlugin, "plugin_");

_LIT( KUpgradePlugin, "upgrade_plugin" );

_LIT( KUpgrade, "upgrade" );

_LIT( KDoubleBackSlash, "\\" );

_LIT( KUpgradePluginWild, "upgrade_plugin_*.dat" );

// Just in case emulator cannot read system version we use this to

// prevent ROM installation on every boot up

_LIT( KDummyVersionInfo, "dummyversioninfo" );

_LIT( KProcessFindString, "hspsthemeserver*" ); 

const TUint KAppId_hspsAS =  270486738; //  0x101F4CD2 from S60 3.1 Xuikon AppShell in 3.1 product.

const TUint KAppId_hspsAI =  271012080 ; // 0x102750F0 support for Xuikon-based ActiveIdle 

const TUint KAppId_LE =    270551469 ; // 0x102049AD LayoutTest

const TInt KAppIdAny = -1; // All applications

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

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

// ResetAndDestroyHBufCArray 

// cleanup item for HBufC dynamic arrays

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

static void ResetAndDestroyHBufC8Array( TAny* aArray )

    {

    CArrayPtrSeg<HBufC8>* array = reinterpret_cast< CArrayPtrSeg<HBufC8>* >( aArray );

    array->ResetAndDestroy();

    delete array;

    }

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

// ResetAndDestroyChspsODTArray 

// cleanup item for ChspsODT dynamic arrays

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

static void ResetAndDestroyChspsODTArray( TAny* aArray )

    {

    CArrayPtrSeg<ChspsODT>* array = reinterpret_cast< CArrayPtrSeg<ChspsODT>* >( aArray );

    array->ResetAndDestroy();

    delete array;

    }

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

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

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

//

static void UnlockRepository( TAny* aObject )

    {

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

    if (DefRep->Locked())

        {

        DefRep->Unlock();

        }

    }

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

// GetFWVersion

// Gets firmware version of phone and sets it to buffer given as parameter

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

//

static void GetFWVersion( TDes& aVersion )

    {

    TInt err = SysVersionInfo::GetVersionInfo( SysVersionInfo::EFWVersion, aVersion );

    if ( err != KErrNone )

        {

        // emulator might not have fwid*.txt files so we need to read sw version

        // by using sysutil.

        aVersion.Zero();

        err = SysUtil::GetSWVersion( aVersion );

        if ( err != KErrNone )

            {

            // for some reason emulator cannot read version info

            aVersion.Copy( KDummyVersionInfo );

            }

        }

    }

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

// RunServerL()

// Server startup code

// Perform all server initialisation, in particular creation of the

// scheduler and server and then run the scheduler

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

//

static void RunServerL()

    {

#ifdef _hsps_PERFORMANCE_TEST_

    ChspsTimeMon::PrintUserMem( _L("hspsThemeServer::RunServerL(): - initialising..") );

#endif//_hsps_PERFORMANCE_TEST_

    // naming the server thread after the server helps to debug panics

    User::LeaveIfError(User::RenameThread(KhspsThemeServerName));

    // create and install the active scheduler we need

    CActiveScheduler* s=new(ELeave) CActiveScheduler;

    CleanupStack::PushL(s);

    CActiveScheduler::Install(s);

    // create the server (leave it on the cleanup stack)

    ChspsThemeServer::NewLC();

    // Initialisation complete, now signal the client

    RProcess::Rendezvous(KErrNone);

    CActiveScheduler::Start();

    // Cleanup the server and scheduler

    CleanupStack::PopAndDestroy( 2, s );

#ifdef _hsps_PERFORMANCE_TEST_

    ChspsTimeMon::PrintUserMem( _L("hspsThemeServer::RunServerL(): - server fully running") );

#endif//_hsps_PERFORMANCE_TEST_

    }

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

// E32Main

// Server process entry-point

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

//

TInt E32Main()

    {                   

    TFindProcess processFinder( KProcessFindString );

    TFullName fullName;

    TInt count = 0;

    while( processFinder.Next( fullName ) == KErrNone )

        {

        count++;

        }

    if( count > 1 )

        {

        return KErrAlreadyExists;

        }

    fullName = KNullDesC();

    RAllocator* iAllocator = MemoryManager::SwitchToFastAllocator();

    __UHEAP_MARK;

    CTrapCleanup* cleanup=CTrapCleanup::New();

    TInt r=KErrNoMemory;

    if (cleanup)

        {

        TRAP(r,RunServerL());

        delete cleanup;

        }

    __UHEAP_MARKEND;

    MemoryManager::CloseFastAllocator(iAllocator);

    return r;

    }

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

#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_

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

// CShutdown::NewL

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

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

//

CShutdown* CShutdown::NewL( MShutdownObserver& aObserver )

    {

    CShutdown* object = new (ELeave) CShutdown( aObserver );

    CleanupStack::PushL( object );

    object->ConstructL();

    CleanupStack::Pop( object );

    return object;    

    }

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

// CShutdown::CShutdown

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

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

//

CShutdown::CShutdown( MShutdownObserver& aObserver ) : CTimer(-1), iObserver( aObserver )

    {

    CActiveScheduler::Add(this);

    }

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

// CShutdown::ConstructL

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

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

//

void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

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

// CShutdown::Start

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

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

//

void CShutdown::Start()

    {

    After( KhspsShutdownDelay );

    }

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

// CShutdown::RunL

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

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

//

void CShutdown::RunL()

    {

    // Notify observer.

    iObserver.ShutdownInitiating();

    // Stop active scheduler.

    CActiveScheduler::Stop();

    }

#endif // _hsps_SERVER_SHUTDOWN_ENABLED_

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

// ChspsThemeServer::ChspsThemeServer

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

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

//

inline ChspsThemeServer::ChspsThemeServer():CPolicyServer(0,hspsThemePolicy,ESharableSessions)

    {

    }

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

// ChspsThemeServer::NewLC

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

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

//

CServer2* ChspsThemeServer::NewLC()

    {

#ifdef _hsps_PERFORMANCE_TEST_ 

    ChspsTimeMon::PrintUserMem( _L("SERVER: - ready to install server.") );

#endif    

    ChspsThemeServer* self=new(ELeave) ChspsThemeServer;

    CleanupStack::PushL(self);

    self->ConstructL();

#ifdef _hsps_PERFORMANCE_TEST_ 

    ChspsTimeMon::PrintUserMem( _L("SERVER: - server installed.") );

#endif        

    return self;

    }

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

// ChspsThemeServer::ConstructL

// 2nd phase construction - ensure the timer and server objects are running

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

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

//

void ChspsThemeServer::ConstructL()

    {

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

#ifdef HSPS_LOG_ACTIVE    

    iLogBus = ChspsLogBusFile::NewL( ChspsLogBusFile::CreateLogFilename( _L("themeserver") ) );

    iLogBus->LogText( _L( "--------------------------------------------------------" ) );

    iLogBus->LogText( _L( "hspsThemeServer: constructing server" ) );

#endif

    // Setup a runtime array of headers (=header cache)

    iHeaderListCache = new ( ELeave ) CArrayPtrSeg< ChspsODT >( KHeaderListGranularity );

    // Setup a Plug-in Repository listener

    iCentralRepository = CRepository::NewL( KhspsThemeStatusRepositoryUid );

    iDefinitionRepository = ChspsDefinitionRepository::NewL( *iCentralRepository );

#ifdef HSPS_LOG_ACTIVE    

    iDefinitionRepository->SetLogBus( iLogBus );

#endif    

    // Get active device language

    iDeviceLanguage = GetDeviceLanguage();

#ifdef HSPS_LOG_ACTIVE    

    iLogBus->LogText( _L( "ChspsThemeServer::GetDeviceLanguage() %d" ), iDeviceLanguage );

#endif

    // Setup a search mask for finding headers from the cache

    iCacheMask = ChspsODT::NewL();

    // Setup a listener for changes in the Central Repository

    iCenRepListener = ChspsCenRepListener::NewL( *this, KhspsThemeStatusRepositoryUid );        

	// Access lists for client processes

    iSecurityEnforcer = ChspsSecurityEnforcer::NewL( *iDefinitionRepository, *iCentralRepository );

#ifdef HSPS_LOG_ACTIVE    

     iSecurityEnforcer->SetLogBus( iLogBus );

#endif     

    // Find header files from the Plug-in Repository

	UpdateHeaderListCacheL();  

    // Initialize remove index

    iThemeIndexToRemove = KErrNotFound;

    // Listen to changes in any key

    iCenRepListener->SetupAll();     

    // Start observing the notifications

    iDefinitionRepository->RegisterObserverL( *this );

#if defined(WINSCW) || defined(__WINS__)

    // Resolution & orientation change listener

    iFamily = ChspsFamilyListener::NewL( *this );

#else 

    iFamily = ChspsFamily::NewL();

#endif //defined(WINSCW) || defined(__WINS__)

    // Auto-localize ODTs in the Definition Repository when the device language has changed

    HandleLanguageChangeL();            

    // Installs manifest files from the ROM drive when server is starting for the first time

    HandleRomInstallationsL();

#ifndef __DISABLE_SISX_INSTALLATION_

    // Start observing of import folder to enable autoinstallations

    EnableAutoInstallationL();

#endif //__DISABLE_SISX_INSTALLATION_    

    // Update configurations

    // When server is started all configurations with "WaitForConfirmation" state are updated

    // to "NotConfirmed" state to allow client to validate configurations

    User::LeaveIfError( iCentralRepository->Set( KCenrepKeyCheckConf, 0 ) );

    CheckConfigurationL( KAppIdAny );

    // Activate configuration checking

    // Configurations are checked every time when a new client session is created

    User::LeaveIfError( iCentralRepository->Set( KCenrepKeyCheckConf, 1 ) );

    // Backup event listener

    iBRObserver = CHSPSBRObserver::NewL( *this );

    iBRObserver->Start();

    // Initialize backup state

    iBRState = EhspsBRNormal;

#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_    

    iShutdown = CShutdown::NewL( *this );

#endif // _hsps_SERVER_SHUTDOWN_ENABLED_

    // Adds the server with the specified name to the active scheduler, and issues the 

    // first request for messages, and leaves if the operation fails

    StartL( KhspsThemeServerName );

#ifdef HSPS_LOG_ACTIVE	

    iLogBus->LogText( _L( "hspsThemeServer: server fully constructed" ) );

    iLogBus->LogText( _L( "--------------------------------------------------------" ) );

#endif    

    }

// Destructor

ChspsThemeServer::~ChspsThemeServer()

    {

#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_

    delete iShutdown;

    iShutdown = NULL;

#else

    // Server must call cleanup if shutdown object does not exist (and call it).

    Cleanup();

#endif // _hsps_SERVER_SHUTDOWN_ENABLED_        

#ifdef HSPS_LOG_ACTIVE    

    // Delete log bus as absolute last!

    // Some members might log destructor activity to this object.

    delete iLogBus;

    iLogBus = NULL;

#endif    

    iSessions.Reset();

    }

#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_

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

// ChspsThemeServer::ShutdownInitiating

// From MShutdownObserver.

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

//

void ChspsThemeServer::ShutdownInitiating()

    {

    Cleanup();

    }

#endif // #ifdef _hsps_SERVER_SHUTDOWN_ENABLED_

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

// ChspsThemeServer::Cleanup

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

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

//

void ChspsThemeServer::Cleanup()

    {

#ifdef HSPS_LOG_ACTIVE      

    iLogBus->LogText( _L( "hspsThemeServer: server is shutting down" ) );

#endif    

    delete iFileMan;

    if( iDefinitionRepository )

        {

        iDefinitionRepository->UnregisterObserver( *this );

        }

#ifndef __DISABLE_SISX_INSTALLATION_

    DisableAutoInstallation();

#endif //__DISABLE_SISX_INSTALLATION_

    if ( iFamily )

        {

        delete iFamily;

        iFamily = NULL;

        }

    delete iCenRepListener;

    iCenRepListener = NULL;

    delete iRomInstaller;

    iRomInstaller = NULL;

    delete iAutoInstaller;    

    iAutoInstaller = NULL;

    if( iHeaderListCache )

        {

        iHeaderListCache->ResetAndDestroy();

        delete iHeaderListCache;  

        iHeaderListCache = NULL;

        }

    delete iDefinitionRepository;

    iDefinitionRepository = NULL;

    delete iCentralRepository;

    iCentralRepository = NULL;

    delete iSecurityEnforcer;

    iSecurityEnforcer = NULL;

    delete iCacheMask;

    delete iBRObserver;

    delete iActiveBackupClient;

    delete iBRHandler;

    iCacheMask = NULL;

    iFsSession.Close();    

    }

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

// ChspsThemeServer::NewSessionL

// Create a new client session. This should really check the version number.

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

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

//

CSession2* ChspsThemeServer::NewSessionL(const TVersion&,const RMessage2& aMessage ) const

    {

    return new (ELeave) ChspsThemeServerSession( aMessage.SecureId().iId );

    }

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

// ChspsThemeServer::AddSession

// A new session is being created

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

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

//

void ChspsThemeServer::AddSession( ChspsThemeServerSession* aSession )